From 5acaa7af29b2210fbcf0e570047525ca9669e492 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sat, 17 Oct 2026 01:02:38 +0000
Subject: [PATCH 01/87] refactor(crypt): EME with the steps and the names of
 the paper

eme.js now follows the paper of Halevi and Rogaway and rfjakob/eme step by step, with the names of the paper (P, C, T, L, PPP, MP, MC, M, CCC), and a comment for each step. The doubling in GF(2^128) changes the block in place, with no branch on the data. The checks give a TypeError or a RangeError with a clear message, and the check of the sizes in xorBlocks, which used && in place of ||, goes away. The exports are encrypt and decrypt. The output is the same as before for 2000 random inputs, and the speed is the same.

eme_test.js checks the two vectors of rfjakob/eme (16 and 2048 bytes) with the AES of aes-js and of node:crypto, the decrypt of each encrypt, the change of each block when one bit of the input or of the tweak changes, and the checks of the input.
---
 backend/crypt/PathCipher.js |   6 +-
 backend/crypt/eme.js        | 298 +++++++++++++++---------------------
 backend/crypt/eme_test.js   | 202 ++++++++++++++++++++++++
 dev_deps.js                 |   3 +-
 4 files changed, 331 insertions(+), 178 deletions(-)
 create mode 100644 backend/crypt/eme_test.js

diff --git a/backend/crypt/PathCipher.js b/backend/crypt/PathCipher.js
index 6ca95af..282de4f 100644
--- a/backend/crypt/PathCipher.js
+++ b/backend/crypt/PathCipher.js
@@ -1,5 +1,5 @@
 import { AES, decodeBase32, encodeBase32 } from "../../deps.js";
-import { Decrypt, Encrypt } from "./eme.js";
+import * as EME from "./eme.js";
 import { pad, Padding, unpad } from "./padding.js";
 
 const encoder = new TextEncoder();
@@ -41,7 +41,7 @@ export default function PathCipher({ nameKey, nameTweak } = {}) {
     if (name === "") return "";
     const ciphertext = encoder.encode(name);
     const paddedCipherText = pad(ciphertext, Padding.PKCS7, 16);
-    const rawCipherText = Encrypt(nameCipher, nameTweak, paddedCipherText);
+    const rawCipherText = EME.encrypt(nameCipher, nameTweak, paddedCipherText);
 
     const encodedCipher = encodeBase32(rawCipherText, "RFC4648-HEX");
     return encodedCipher.replace(/=+$/, "").toLowerCase();
@@ -68,7 +68,7 @@ export default function PathCipher({ nameKey, nameTweak } = {}) {
     const rawCipherText = new Uint8Array(
       decodeBase32(name.toUpperCase(), "RFC4648-HEX"),
     );
-    const paddedPlaintext = Decrypt(nameCipher, nameTweak, rawCipherText);
+    const paddedPlaintext = EME.decrypt(nameCipher, nameTweak, rawCipherText);
     return decoder.decode(unpad(paddedPlaintext, Padding.PKCS7, 16));
   }
 
diff --git a/backend/crypt/eme.js b/backend/crypt/eme.js
index aabfe50..c783acd 100644
--- a/backend/crypt/eme.js
+++ b/backend/crypt/eme.js
@@ -1,219 +1,169 @@
-// TypeScript port of https://github.com/rfjakob/eme/blob/master/eme.go by rfjakob
-
-// EME is a wide-block encryption mode developed by Halevi and Rogaway.
+// EME (ECB-Mix-ECB) is the wide-block encryption mode of Halevi and Rogaway,
+// "A Parallelizable Enciphering Mode" (2003): https://eprint.iacr.org/2003/147
+//
+// EME makes one cipher for 1 to 128 blocks (16 to 2048 bytes) from a block
+// cipher of 16 bytes, such as AES. Each bit of the output changes with each
+// bit of the input and of the tweak.
+//
+// rclone encrypts each name of a file with EME and AES-256, through the
+// library https://github.com/rfjakob/eme. This module does the same steps.
+// The names are the names of the paper: P is the input, C is the output, T
+// is the tweak, and E is the block cipher. Encryption and decryption have
+// the same steps: only the direction of E changes.
+
+/** The size of one block, in bytes. */
+const BLOCK_SIZE = 16;
+
+/** The largest input, in blocks: 2048 bytes. */
+const MAX_BLOCKS = 128;
 
 /**
- * @typedef {ArrayBuffer | Uint8Array | number[]} ByteSource
+ * A block cipher of 16 bytes with its key, for example `new AES(key)` of
+ * `aes-js`. Each function takes one block and gives a new block. It does not
+ * change its input.
+ * @typedef {Object} BlockCipher
+ * @property {(block: Uint8Array) => Uint8Array} encrypt
+ * @property {(block: Uint8Array) => Uint8Array} decrypt
  */
 
 /**
- * @enum { number }
+ * Encrypts the data with EME.
+ * @param {BlockCipher} cipher The block cipher, with the key.
+ * @param {Uint8Array} tweak 16 bytes.
+ * @param {Uint8Array} data 1 to 128 blocks of 16 bytes.
+ * @returns {Uint8Array} The encrypted data, a new array of the same size.
  */
-const Direction = {
-  Encrypt: 0,
-  Decrypt: 1,
-};
+export function encrypt(cipher, tweak, data) {
+  return transform(cipher, tweak, data, (block) => cipher.encrypt(block));
+}
 
 /**
- * @typedef {Object} BlockCipher
- * @property {function(ByteSource): ByteSource} encrypt
- * @property {function(ByteSource): ByteSource} decrypt
+ * Decrypts the data with EME.
+ * @param {BlockCipher} cipher The block cipher, with the key.
+ * @param {Uint8Array} tweak 16 bytes.
+ * @param {Uint8Array} data 1 to 128 blocks of 16 bytes.
+ * @returns {Uint8Array} The decrypted data, a new array of the same size.
  */
+export function decrypt(cipher, tweak, data) {
+  return transform(cipher, tweak, data, (block) => cipher.decrypt(block));
+}
 
 /**
- * @param {Uint8Array} out
- * @param {Uint8Array} input
+ * The steps of EME.
+ * @param {BlockCipher} cipher The block cipher. The table L uses its
+ *   encryption in the two directions.
+ * @param {Uint8Array} T The tweak.
+ * @param {Uint8Array} P The input.
+ * @param {(block: Uint8Array) => Uint8Array} E The block cipher, in the
+ *   direction of the transform.
+ * @returns {Uint8Array} C, the output.
  */
-function multByTwo(out, input) {
-  if (input.length !== 16) {
-    throw new Error("Invalid length");
+function transform(cipher, T, P, E) {
+  check(T, P);
+  const m = P.length / BLOCK_SIZE;
+  const L = table(cipher, m);
+  const C = new Uint8Array(P.length);
+
+  // PPP_j = E(P_j xor L_j), and MP = T xor PPP_1 xor ... xor PPP_m.
+  const MP = T.slice();
+  for (let j = 0; j < m; j++) {
+    const PPP = E(xor(block(P, j).slice(), L[j]));
+    C.set(PPP, j * BLOCK_SIZE);
+    xor(MP, PPP);
   }
-  let last = input[0];
 
-  out[0] = (2 * input[0]) & 0xff;
-  if (input[15] >= 128) {
-    out[0] ^= 135;
-  }
-  for (let j = 1; j < 16; j++) {
-    const tmp = input[j];
-    out[j] = (2 * input[j]) & 0xff;
-    if (last >= 128) {
-      out[j] = (out[j] + 1) & 0xff;
-    }
-    last = tmp;
-  }
-}
+  // MC = E(MP), and the mask M = MP xor MC.
+  const MC = E(MP);
+  const M = xor(MP.slice(), MC);
 
-/**
- * @param {Uint8Array} out
- * @param {Uint8Array} in1
- * @param {Uint8Array} in2
- */
-function xorBlocks(out, in1, in2) {
-  if (in1.length !== in2.length && in2.length !== out.length) {
-    throw new Error("Length must all match");
+  // CCC_j = PPP_j xor 2^(j-1) M for j = 2 to m, in place in C.
+  // CCC_1 = MC xor T xor CCC_2 xor ... xor CCC_m.
+  const CCC1 = xor(MC.slice(), T);
+  for (let j = 1; j < m; j++) {
+    xor(CCC1, xor(block(C, j), double(M)));
   }
+  C.set(CCC1, 0);
 
-  for (let i = 0; i < in1.length; i++) {
-    out[i] = in1[i] ^ in2[i];
+  // C_j = E(CCC_j) xor L_j.
+  for (let j = 0; j < m; j++) {
+    const Cj = block(C, j);
+    Cj.set(E(Cj));
+    xor(Cj, L[j]);
   }
+
+  return C;
 }
 
 /**
- * @param {BlockCipher} bc
+ * The table of L for m blocks. The paper sets L = 2 E(0), and the block j
+ * (from 1) uses 2^(j-1) L. Thus L[0] is L, L[1] is 2 L, and so on.
+ * @param {BlockCipher} cipher
  * @param {number} m
- * @returns
+ * @returns {Uint8Array[]}
  */
-function tabulateL(bc, m) {
-  /**
-   * @type {Uint8Array}
-   */
-  const Li = bc.encrypt([
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-  ]);
-  const LTable = new Array(m);
-  for (let i = 0; i < m; i++) {
-    multByTwo(Li, Li);
-    LTable[i] = Li.slice();
-  }
-  return LTable;
+function table(cipher, m) {
+  const L = cipher.encrypt(new Uint8Array(BLOCK_SIZE)).slice();
+  return Array.from({ length: m }, () => double(L).slice());
 }
 
 /**
- * @param {ByteSource} src
- * @param {Direction} direction
- * @param {BlockCipher} bc
- * @returns {Uint8Array}
+ * Multiplies the block by 2 in GF(2^128), in place, as `multByTwo` of the
+ * draft EME-32: the bytes are little-endian, and a carry out of the last byte
+ * adds the polynomial 135 (x^7 + x^2 + x + 1) to the first byte. No branch
+ * depends on the data.
+ * @param {Uint8Array} block
+ * @returns {Uint8Array} The same block.
  */
-function aesTransform(src, direction, bc) {
-  if (direction === Direction.Encrypt) {
-    return bc.encrypt(src);
-  } else {
-    return bc.decrypt(src);
+function double(block) {
+  const carry = block[BLOCK_SIZE - 1] >> 7;
+  for (let i = BLOCK_SIZE - 1; i > 0; i--) {
+    block[i] = (block[i] << 1) | (block[i - 1] >> 7);
   }
+  block[0] = (block[0] << 1) ^ (135 * carry);
+  return block;
 }
 
 /**
- * @param {BlockCipher} bc
- * @param {Uint8Array} tweak
- * @param {Uint8Array} inputData
- * @param {Direction} direction
- * @returns {Uint8Array}
+ * Puts `a` xor `b` in `a`.
+ * @param {Uint8Array} a A block, which changes.
+ * @param {Uint8Array} b A block.
+ * @returns {Uint8Array} The block `a`.
  */
-function Transform(bc, tweak, inputData, direction) {
-  // In the paper, the tweak is just called "T". Call it the same here to
-  // make following the paper easy.
-  const T = tweak; // in bytes
-
-  // In the paper, the plaintext data is called "P" and the ciphertext is
-  // called "C". Because encryption and decryption are virtually indentical,
-  // we share the code and always call the input data "P" and the output data
-  // "C", regardless of the direction.
-  const P = inputData; // in bytes
-
-  if (T.length !== 16) {
-    throw new Error("Tweak must be 16 bytes long");
-  }
-  if (P.length % 16 !== 0) {
-    throw new Error("Input Data must be a multiple of 16 long");
-  }
-
-  const m = P.length / 16;
-  if (m === 0 || m > 128) {
-    throw new Error(
-      "EME operates on 1 to 128 block-cipher blocks, you passed " + m,
-    );
-  }
-
-  // Result
-  const C = new Uint8Array(P.length); // in bytes
-  const LTable = tabulateL(bc, m); // in bytes
-
-  const PPj = new Uint8Array(16); // in bytes
-  for (let j = 0; j < m; j++) {
-    const Pj = P.slice(j * 16, (j + 1) * 16);
-    /* PPj = 2**(j-1)*L xor Pj */
-    xorBlocks(PPj, Pj, LTable[j]);
-
-    /* PPPj = AESenc(K; PPj) */
-    C.set(aesTransform(PPj, direction, bc), j * 16);
-  }
-
-  /* MP =(xorSum PPPj) xor T */
-  const MP = new Uint8Array(16);
-  xorBlocks(MP, C.subarray(0, 16), T);
-  for (let j = 1; j < m; j++) {
-    xorBlocks(MP, MP, C.subarray(j * 16, (j + 1) * 16));
-  }
-  /* MC = AESenc(K; MP) */
-  const MC = aesTransform(MP, direction, bc);
-
-  /* M = MP xor MC */
-  const M = new Uint8Array(16);
-  xorBlocks(M, MP, MC);
-  const CCCj = new Uint8Array(16);
-  for (let j = 1; j < m; j++) {
-    multByTwo(M, M);
-    /* CCCj = 2**(j-1)*M xor PPPj */
-    xorBlocks(CCCj, C.subarray(j * 16, (j + 1) * 16), M);
-    C.set(CCCj, j * 16);
-  }
-
-  /* CCC1 = (xorSum CCCj) xor T xor MC */
-  const CCC1 = new Uint8Array(16);
-  xorBlocks(CCC1, MC, T);
-  for (let j = 1; j < m; j++) {
-    xorBlocks(CCC1, CCC1, C.subarray(j * 16, (j + 1) * 16));
-  }
-  C.set(CCC1, 0);
-
-  for (let j = 0; j < m; j++) {
-    /* CCj = AES-enc(K; CCCj) */
-    C.set(
-      aesTransform(C.subarray(j * 16, (j + 1) * 16), direction, bc),
-      j * 16,
-    );
-
-    const tmp = C.subarray(j * 16, (j + 1) * 16);
-    /* Cj = 2**(j-1)*L xor CCj */
-    xorBlocks(tmp, tmp, LTable[j]);
-    C.set(tmp, j * 16);
+function xor(a, b) {
+  for (let i = 0; i < BLOCK_SIZE; i++) {
+    a[i] ^= b[i];
   }
-  return C;
+  return a;
 }
 
 /**
- * Encrypts the data using the EME mode.
- * @param {BlockCipher} bc
- * @param {Uint8Array} tweak
+ * Gives the block j (from 0) of the data, as a view: a change of the view
+ * changes the data.
  * @param {Uint8Array} data
+ * @param {number} j
  * @returns {Uint8Array}
  */
-export function Encrypt(bc, tweak, data) {
-  return Transform(bc, tweak, data, Direction.Encrypt);
+function block(data, j) {
+  return data.subarray(j * BLOCK_SIZE, (j + 1) * BLOCK_SIZE);
 }
+
 /**
- * Decrypts the data using the EME mode.
- * @param {BlockCipher} bc
+ * Makes sure that the tweak and the data have a size that EME accepts.
  * @param {Uint8Array} tweak
  * @param {Uint8Array} data
- * @returns {Uint8Array}
  */
-export function Decrypt(bc, tweak, data) {
-  return Transform(bc, tweak, data, Direction.Decrypt);
+function check(tweak, data) {
+  if (!(tweak instanceof Uint8Array) || tweak.length !== BLOCK_SIZE) {
+    throw new TypeError(`EME: the tweak must be ${BLOCK_SIZE} bytes.`);
+  }
+  if (!(data instanceof Uint8Array)) {
+    throw new TypeError("EME: the data must be a Uint8Array.");
+  }
+  const blocks = data.length / BLOCK_SIZE;
+  if (!Number.isInteger(blocks) || blocks < 1 || blocks > MAX_BLOCKS) {
+    throw new RangeError(
+      `EME: the data must be 1 to ${MAX_BLOCKS} blocks of ${BLOCK_SIZE} ` +
+        `bytes, not ${data.length} bytes.`,
+    );
+  }
 }
diff --git a/backend/crypt/eme_test.js b/backend/crypt/eme_test.js
new file mode 100644
index 0000000..9fbe9be
--- /dev/null
+++ b/backend/crypt/eme_test.js
@@ -0,0 +1,202 @@
+import { test } from "node:test";
+import { createCipheriv, createDecipheriv } from "node:crypto";
+import { AES } from "../../deps.js";
+import {
+  assertEquals,
+  assertNotEquals,
+  assertThrows,
+  fc,
+} from "../../dev_deps.js";
+
+import { decrypt, encrypt } from "./eme.js";
+
+/**
+ * Makes the bytes of a text in hexadecimal. The text can have spaces and
+ * line breaks.
+ * @param {string} text
+ * @returns {Uint8Array}
+ */
+function hex(text) {
+  const digits = text.replace(/\s/g, "");
+  return Uint8Array.from(
+    { length: digits.length / 2 },
+    (_, i) => parseInt(digits.slice(i * 2, i * 2 + 2), 16),
+  );
+}
+
+/**
+ * AES with the key, as a block cipher of `node:crypto` (AES-ECB with no
+ * padding), to compare with the AES of `aes-js`.
+ * @param {Uint8Array} key 32 bytes.
+ * @returns {import("./eme.js").BlockCipher}
+ */
+function nodeAES(key) {
+  const ecb = (make) => (block) => {
+    const cipher = make("aes-256-ecb", key, null).setAutoPadding(false);
+    return new Uint8Array(cipher.update(block));
+  };
+  return { encrypt: ecb(createCipheriv), decrypt: ecb(createDecipheriv) };
+}
+
+/**
+ * Gives the blocks of 16 bytes of the data, as views.
+ * @param {Uint8Array} data
+ * @returns {Uint8Array[]}
+ */
+function blocks(data) {
+  return Array.from(
+    { length: data.length / 16 },
+    (_, j) => data.subarray(j * 16, (j + 1) * 16),
+  );
+}
+
+const CIPHERS = {
+  "aes-js": (key) => new AES(key),
+  "node:crypto": nodeAES,
+};
+
+// The vectors of https://github.com/rfjakob/eme (eme_test.go), the library of
+// rclone: the key, the tweak and the input are zeros.
+const VECTORS = {
+  16: hex("f1b9ce8ca15a4ba9fb476905434b9fd3"),
+  2048: hex(`
+  630500884158a8d41216aaa6351e92ea7ca540a949e73f1d6069afef372eae226d426d8f
+  4dbbce505051fcd596e7b32cdd1e44a40bcce0887ebbc160f779dafbb68bc25a40040987
+  cdb5aba19b956e11dd69d7ce74d1d8788903254217300f3afd9a92cea395a89fd842256d
+  3919ac303c1d1a21ec44cb2898acabb3d0e04e05845e9183a64b4148f9614f62f79fa971
+  799c896c58cd2b285cb00e40720b5c118ef1c0dbf5e51f09cd10db672b9c22c53d4bf5da
+  bf16cfcbc382e3209e7ba27955b2afa055924d2155319205f964492e0e88172f4ffadca3
+  5cd3e694fd3d803f610edc1696113996749bdb2a2dfb8fbd92f0ef723146f93d969d1de4
+  cc1c19efa33785f135a1203005ba2208fcd6b9f0d0e942993671b0c5baefe7ed0bbfe070
+  a9e1d26eed37228ceda64b70c25a59fd040703acc385c6e4093a8e258984371c2d811c01
+  723b87c820a55470501b245d97a0c7564c44e1e31a89457c1125198d27ac2dec67f7237c
+  781f9f622e420da471af577fa6ad8014bb1dad52dc450e37ebeeb1f1b7ba3c3d5796c664
+  6bd052fe66cf61d22f6e58efcbf0328d3b6e1088603e54bfd2da241c970fec58c7d21fc2
+  b2f1b4b79552a92500a7e6848a22ec47ee362cef9787af3b26439470992c8d103997395a
+  efeff10802673d4630009e4e5ed26038d5f05c589e64046274d5ff133398e4bab08ca71c
+  0ce93dbd0657785b150c9e418339e8e47d02ae7322b5b55364dfe10dd02d54dc5f2dbe82
+  e55bcf0503b30d709301fc7f63cd15e7e1245189405b1364b6074c0e493f7beb27385986
+  4e95643c7d914279d95f220247618b7a5c896d604e9ce88e0a3ab434cfe97cabc520b20e
+  2fffee958972e82e98b952cbf3567be560a8385e520b636829252cae16ac882d1d3dde44
+  7a90af52be7967f357a36382c9672a659ed0ffae9ee7b969c8c788f982fbd524efb6b852
+  f65be5f371032691e9ef6e5a217607cf990e5351b251f841834045d9bd54633e8bb0d195
+  69377f805857a503a2642dfc06e2063dfd465dcae83b1e362394cdf20bd6a6d5dd0bacad
+  7f2d407e597b004e90683bfc23b92796bb0cdf67752765dbba2d1332848adcb83e60b7f3
+  f8c397a3aa5de08bf491676a18ee4a6ed9b342b33c081794365a72668f273a655e150fa3
+  6686aa5dfbc87ccda9cbe7982e531044cd9fcea68ca1a5034ee64e0558b7c6af56808c03
+  43506dccf39e4ca8634518e6420c107b7d5fe89943e9f40044b2ae7f047d97275ec4763b
+  41416fb3faff897e6ee0047f97b215b02ee09a3f533cba2ee131a0aa68772860759325ea
+  4dc7ab86528d0aff55f96d00a908ea32f9fa8bd0640d632bf0d812f43beb03e6c6d4a654
+  b41f27143fde4aa7ed16ae4bba939fbed8ae28dace83fcb49fd3ca910512902fc6964199
+  68e260901796f3af75d059c6e93a8f53b445f921e60d9429007c78107309a86102b923db
+  b2f1fa04f84539c7c58ed45b40d4b267541d8f2f932ae75dfc13ef906089e1c847635aaa
+  da201e32301f326a733f4a99caa56fa00ccd6de2752a4495408bb4c930eaf84c97a28767
+  a036f65627efa868adeee1cf47840e67ac4489381da1513dd3d1707a5ad91ac4ba1c3571
+  4b1cd77e05551612cdfb88187a5a39afd5b2a54f88aeb9605c1e01cd7a976a168c6e40ed
+  dcb20f09fe54a07a7c971eda08789b41e450f46a30c2b3494f30a06073631d151ae04879
+  3fe32ff08a08b8693d1da71451f7ff2438d7a521f8c97e4bc8ee744c1574d296c799d3f9
+  4e81522ce81def780660cee061d3110c1f18133dca1daabb2268aad76327f3cb6ae8c96f
+  c66b5506f5644f2652d022d7b616209970f78b8e5c9a74f5d1fc31037d01733bff097a66
+  1d4331adc087b84e32afb9d82a0614ea459022918f8ca60e74b7c6865d3e86e6ae4acf95
+  46985dc5ccf242dd9ab0486bde99a1e656499cbfceef8de5beafda89965bf208c70f4a0f
+  8f677792962b09e0a355d53bbacb4a7acc16e50aa483994d85ca7e28a34ee52843d4f27a
+  cfb3b5347b89099fd01642b605f87f82283bb146aa319048462fe11a71d0fa064e825f69
+  a502ae539240b13a2568383f80c30ebb9a29d2de4c45e6405bd8d1586fe5eef0477d3c21
+  434b3471c0f864dd4c2f135278645ef1b1ebb4d6954f92763d787ad3d0bb48409782cd80
+  3a877027ae105511cdaefe0110f9f6c65f2a34ad12532f4715c0341346dc06bcc4bb0e5c
+  04ffdfd3f625e7e3811a760a2cfa9cbe1c2914882c192b793aeeb3ab8b03fd8be7e248fc
+  9e5aa0c651d4bb5318c8a266b735ddc167d837499a3b38dcdfe188e25172eb974eb0eff2
+  0cc5c6e42e505fea7a3b6edfdf93b7062737ea00f72a415c4dfd3cd4fab2dad812d88d02
+  690f606b52dcfb0ab220dc65a7dee6f31e951324a1c442adfe9cf672646876bedc2c2cb7
+  1bac583f3cf4ea6769eb54d22bf22b0d908a297caa13767ed14c44b738799e821885b2b2
+  988a9b88a2f35bf8d307543af9007fadcfcc273f8029c2fe3d59449c5f193ca7f8986ca7
+  451d9a3ee14335b10868421b64ea1605d48d4fc22e378f82b7fe3e88aada30b4c545408b
+  87b24511e371f25d1a94e7b78a6a7aec848e6f82614f96ef5ed8705e0adec0f889c1860c
+  f8211d716fddf319862290019a4387fb77c89a5ae7d0074fa72024f2e5096d39ebac8e8e
+  d02191879585394987fea3a07a720d6880910629cdcd83a02ffd98830d2f57ee6c53b5cf
+  edb42ec7c3d925cf3080c343f21711a90f117e9eaf91402d09b83e83bd18d1c4e3d165a8
+  b9bac7adca12cb0147bfc4c6e2166c57b8182e63fbc698881ed5b329eb491eb98050a922
+  c15804021013bf08942db9ee6d8f2a2c4eb93771340ed9e323d09e4256b7e5ac
+  `),
+};
+
+for (const [name, AESCipher] of Object.entries(CIPHERS)) {
+  test(`the vectors of rfjakob/eme, with AES of ${name}`, () => {
+    const cipher = AESCipher(new Uint8Array(32));
+    const tweak = new Uint8Array(16);
+    for (const [size, expected] of Object.entries(VECTORS)) {
+      const zeros = new Uint8Array(Number(size));
+      assertEquals(encrypt(cipher, tweak, zeros), expected);
+      assertEquals(decrypt(cipher, tweak, expected), zeros);
+    }
+  });
+}
+
+const KEY = fc.uint8Array({ minLength: 32, maxLength: 32 });
+const TWEAK = fc.uint8Array({ minLength: 16, maxLength: 16 });
+const DATA = fc.integer({ min: 1, max: 128 }).chain((blocks) =>
+  fc.uint8Array({ minLength: blocks * 16, maxLength: blocks * 16 })
+);
+
+test("decrypt gives the data that encrypt took", () => {
+  fc.assert(
+    fc.property(KEY, TWEAK, DATA, (key, tweak, data) => {
+      const cipher = new AES(key);
+      const encrypted = encrypt(cipher, tweak, data);
+      assertEquals(encrypted.length, data.length);
+      assertEquals(decrypt(cipher, tweak, encrypted), data);
+    }),
+  );
+});
+
+test("a change of one bit of the input or of the tweak changes each block", () => {
+  fc.assert(
+    fc.property(KEY, TWEAK, DATA, fc.nat(), (key, tweak, data, bit) => {
+      const cipher = new AES(key);
+      const before = blocks(encrypt(cipher, tweak, data));
+
+      const changed = data.slice();
+      changed[(bit >> 3) % data.length] ^= 1 << (bit & 7);
+      blocks(encrypt(cipher, tweak, changed)).forEach((block, j) =>
+        assertNotEquals(block, before[j])
+      );
+
+      const otherTweak = tweak.slice();
+      otherTweak[(bit >> 3) % 16] ^= 1 << (bit & 7);
+      blocks(encrypt(cipher, otherTweak, data)).forEach((block, j) =>
+        assertNotEquals(block, before[j])
+      );
+    }),
+  );
+});
+
+test("encrypt and decrypt do not change their input", () => {
+  const cipher = new AES(new Uint8Array(32));
+  const tweak = new Uint8Array(16);
+  const data = new Uint8Array(64).fill(7);
+  decrypt(cipher, tweak, encrypt(cipher, tweak, data));
+  assertEquals(tweak, new Uint8Array(16));
+  assertEquals(data, new Uint8Array(64).fill(7));
+});
+
+test("the tweak is 16 bytes, and the data are 1 to 128 blocks", () => {
+  const cipher = new AES(new Uint8Array(32));
+  const tweak = new Uint8Array(16);
+  for (const f of [encrypt, decrypt]) {
+    assertThrows(() => f(cipher, new Uint8Array(15), new Uint8Array(16)), {
+      name: "TypeError",
+      message: "EME: the tweak must be 16 bytes.",
+    });
+    assertThrows(() => f(cipher, tweak, [0, 0]), {
+      name: "TypeError",
+      message: "EME: the data must be a Uint8Array.",
+    });
+    for (const size of [0, 15, 17, 2064]) {
+      assertThrows(() => f(cipher, tweak, new Uint8Array(size)), {
+        name: "RangeError",
+        message:
+          `EME: the data must be 1 to 128 blocks of 16 bytes, not ${size} bytes.`,
+      });
+    }
+  }
+});
diff --git a/dev_deps.js b/dev_deps.js
index 0c396cc..e54c001 100644
--- a/dev_deps.js
+++ b/dev_deps.js
@@ -3,8 +3,9 @@ import {
   notDeepEqual as assertNotEquals,
   ok as assert,
   rejects as assertRejects,
+  throws as assertThrows,
 } from "node:assert/strict";
-export { assert, assertEquals, assertNotEquals, assertRejects };
+export { assert, assertEquals, assertNotEquals, assertRejects, assertThrows };
 
 /**
  * Asserts a header

From 763d82f3a085dd8d8094d129177bc304ab90dda5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sat, 17 Oct 2026 01:02:44 +0000
Subject: [PATCH 02/87] fix(crypt): an empty name decrypts to an empty name

decryptName gave 0 blocks to EME for an empty segment of a path, for example the end of a folder (x/), and EME threw. An empty segment now stays empty in the two directions, as in rclone. The test encode, with an empty name from fast-check, passes now.
---
 backend/crypt/PathCipher.js | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/backend/crypt/PathCipher.js b/backend/crypt/PathCipher.js
index 282de4f..0b88830 100644
--- a/backend/crypt/PathCipher.js
+++ b/backend/crypt/PathCipher.js
@@ -65,6 +65,8 @@ export default function PathCipher({ nameKey, nameTweak } = {}) {
    * @returns {string}
    */
   function decryptName(name) {
+    // An empty segment of a path stays empty, as in rclone.
+    if (name === "") return "";
     const rawCipherText = new Uint8Array(
       decodeBase32(name.toUpperCase(), "RFC4648-HEX"),
     );

From bb396508589ab38bf91b13196f66b918b81c80da Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sat, 17 Oct 2026 01:28:10 +0000
Subject: [PATCH 03/87] refactor(crypt): AES-256 of node:crypto in place of
 aes-js

aes.js gives AES-256-ECB of node:crypto with no padding as the block cipher of EME, and the dependency aes-js goes away. It works in Node.js and in workerd with nodejs_compat at the compatibility date of wrangler.toml (a check with wrangler dev). workerd refuses null as the IV, so the IV is empty.

A block cipher of EME now takes one or more blocks (ECB), so each ECB layer of EME is one call: 4 calls for each name. With node:crypto, 2048 bytes take 58 us (176 us before), and a short name about 9 us.

EME copies with new Uint8Array in place of slice: the slice of a Buffer is a view, and node:crypto gives Buffers. A new test examines a Buffer as input. The output is the same as the first code for 2000 random inputs.
---
 backend/crypt/PathCipher.js |  7 ++-
 backend/crypt/aes.js        | 21 +++++++++
 backend/crypt/eme.js        | 91 +++++++++++++++++++++----------------
 backend/crypt/eme_test.js   | 66 ++++++++++-----------------
 deps.js                     |  5 --
 package-lock.json           |  6 ---
 package.json                |  1 -
 7 files changed, 99 insertions(+), 98 deletions(-)
 create mode 100644 backend/crypt/aes.js

diff --git a/backend/crypt/PathCipher.js b/backend/crypt/PathCipher.js
index 0b88830..66e6fa6 100644
--- a/backend/crypt/PathCipher.js
+++ b/backend/crypt/PathCipher.js
@@ -1,4 +1,5 @@
-import { AES, decodeBase32, encodeBase32 } from "../../deps.js";
+import { decodeBase32, encodeBase32 } from "../../deps.js";
+import { aes256 } from "./aes.js";
 import * as EME from "./eme.js";
 import { pad, Padding, unpad } from "./padding.js";
 
@@ -28,9 +29,7 @@ export default function PathCipher({ nameKey, nameTweak } = {}) {
   if (nameKey === undefined || nameTweak === undefined) {
     throw new Error("nameKey and nameTweak must be specified");
   }
-  // Name Cipher Fuctions
-  // TODO: Switch to https://github.com/invisal/god_crypto/blob/master/src/aes/aes_wc.ts
-  const nameCipher = new AES(nameKey);
+  const nameCipher = aes256(nameKey);
 
   /**
    * Encrypts a name
diff --git a/backend/crypt/aes.js b/backend/crypt/aes.js
new file mode 100644
index 0000000..8ea1070
--- /dev/null
+++ b/backend/crypt/aes.js
@@ -0,0 +1,21 @@
+import { createCipheriv, createDecipheriv } from "node:crypto";
+
+/**
+ * AES-256 of `node:crypto` in ECB mode with no padding, the block cipher of
+ * EME. Each call takes one or more blocks of 16 bytes. One object does all
+ * the calls of one direction, because ECB keeps no state between blocks.
+ * @param {Uint8Array} key 32 bytes.
+ * @returns {import("./eme.js").BlockCipher}
+ */
+export function aes256(key) {
+  // ECB has no IV. workerd refuses null, so the IV is empty.
+  const iv = new Uint8Array(0);
+  const encryptor = createCipheriv("aes-256-ecb", key, iv);
+  const decryptor = createDecipheriv("aes-256-ecb", key, iv);
+  encryptor.setAutoPadding(false);
+  decryptor.setAutoPadding(false);
+  return {
+    encrypt: (block) => encryptor.update(block),
+    decrypt: (block) => decryptor.update(block),
+  };
+}
diff --git a/backend/crypt/eme.js b/backend/crypt/eme.js
index c783acd..e7908a8 100644
--- a/backend/crypt/eme.js
+++ b/backend/crypt/eme.js
@@ -18,12 +18,13 @@ const BLOCK_SIZE = 16;
 const MAX_BLOCKS = 128;
 
 /**
- * A block cipher of 16 bytes with its key, for example `new AES(key)` of
- * `aes-js`. Each function takes one block and gives a new block. It does not
- * change its input.
+ * A block cipher of 16 bytes in ECB mode, with its key, for example
+ * AES-256-ECB of `node:crypto`. Each function takes one or more blocks,
+ * encrypts or decrypts each block alone, and gives the blocks in a new array.
+ * It does not change its input.
  * @typedef {Object} BlockCipher
- * @property {(block: Uint8Array) => Uint8Array} encrypt
- * @property {(block: Uint8Array) => Uint8Array} decrypt
+ * @property {(blocks: Uint8Array) => Uint8Array} encrypt
+ * @property {(blocks: Uint8Array) => Uint8Array} decrypt
  */
 
 /**
@@ -34,7 +35,7 @@ const MAX_BLOCKS = 128;
  * @returns {Uint8Array} The encrypted data, a new array of the same size.
  */
 export function encrypt(cipher, tweak, data) {
-  return transform(cipher, tweak, data, (block) => cipher.encrypt(block));
+  return transform(cipher, tweak, data, (blocks) => cipher.encrypt(blocks));
 }
 
 /**
@@ -45,16 +46,17 @@ export function encrypt(cipher, tweak, data) {
  * @returns {Uint8Array} The decrypted data, a new array of the same size.
  */
 export function decrypt(cipher, tweak, data) {
-  return transform(cipher, tweak, data, (block) => cipher.decrypt(block));
+  return transform(cipher, tweak, data, (blocks) => cipher.decrypt(blocks));
 }
 
 /**
- * The steps of EME.
+ * The steps of EME: an ECB layer, a mix, and a second ECB layer. Each ECB
+ * layer is one call of the block cipher for all the blocks.
  * @param {BlockCipher} cipher The block cipher. The table L uses its
  *   encryption in the two directions.
  * @param {Uint8Array} T The tweak.
  * @param {Uint8Array} P The input.
- * @param {(block: Uint8Array) => Uint8Array} E The block cipher, in the
+ * @param {(blocks: Uint8Array) => Uint8Array} E The block cipher, in the
  *   direction of the transform.
  * @returns {Uint8Array} C, the output.
  */
@@ -62,48 +64,47 @@ function transform(cipher, T, P, E) {
   check(T, P);
   const m = P.length / BLOCK_SIZE;
   const L = table(cipher, m);
-  const C = new Uint8Array(P.length);
 
-  // PPP_j = E(P_j xor L_j), and MP = T xor PPP_1 xor ... xor PPP_m.
-  const MP = T.slice();
+  // The first ECB layer: PPP_j = E(P_j xor L_j).
+  const PPP = E(xor(copy(P), L));
+
+  // The mix: MP = T xor PPP_1 xor ... xor PPP_m, MC = E(MP), and the mask
+  // M = MP xor MC.
+  const MP = copy(T);
   for (let j = 0; j < m; j++) {
-    const PPP = E(xor(block(P, j).slice(), L[j]));
-    C.set(PPP, j * BLOCK_SIZE);
-    xor(MP, PPP);
+    xor(MP, block(PPP, j));
   }
-
-  // MC = E(MP), and the mask M = MP xor MC.
   const MC = E(MP);
-  const M = xor(MP.slice(), MC);
+  const M = xor(copy(MP), MC);
 
-  // CCC_j = PPP_j xor 2^(j-1) M for j = 2 to m, in place in C.
+  // CCC_j = PPP_j xor 2^(j-1) M for j = 2 to m, and
   // CCC_1 = MC xor T xor CCC_2 xor ... xor CCC_m.
-  const CCC1 = xor(MC.slice(), T);
+  const CCC = copy(PPP);
+  const CCC1 = xor(copy(MC), T);
   for (let j = 1; j < m; j++) {
-    xor(CCC1, xor(block(C, j), double(M)));
+    xor(CCC1, xor(block(CCC, j), double(M)));
   }
-  C.set(CCC1, 0);
+  CCC.set(CCC1, 0);
 
-  // C_j = E(CCC_j) xor L_j.
-  for (let j = 0; j < m; j++) {
-    const Cj = block(C, j);
-    Cj.set(E(Cj));
-    xor(Cj, L[j]);
-  }
-
-  return C;
+  // The second ECB layer: C_j = E(CCC_j) xor L_j.
+  return xor(copy(E(CCC)), L);
 }
 
 /**
- * The table of L for m blocks. The paper sets L = 2 E(0), and the block j
- * (from 1) uses 2^(j-1) L. Thus L[0] is L, L[1] is 2 L, and so on.
+ * The table of L for m blocks, as m blocks in one array. The paper sets
+ * L = 2 E(0), and the block j (from 1) uses 2^(j-1) L. Thus the first block
+ * of the table is L, the second is 2 L, and so on.
  * @param {BlockCipher} cipher
  * @param {number} m
- * @returns {Uint8Array[]}
+ * @returns {Uint8Array}
  */
 function table(cipher, m) {
-  const L = cipher.encrypt(new Uint8Array(BLOCK_SIZE)).slice();
-  return Array.from({ length: m }, () => double(L).slice());
+  const L = new Uint8Array(m * BLOCK_SIZE);
+  const Lj = copy(cipher.encrypt(new Uint8Array(BLOCK_SIZE)));
+  for (let j = 0; j < m; j++) {
+    L.set(double(Lj), j * BLOCK_SIZE);
+  }
+  return L;
 }
 
 /**
@@ -124,18 +125,28 @@ function double(block) {
 }
 
 /**
- * Puts `a` xor `b` in `a`.
- * @param {Uint8Array} a A block, which changes.
- * @param {Uint8Array} b A block.
- * @returns {Uint8Array} The block `a`.
+ * Puts `a` xor `b` in `a`. The two have the same size.
+ * @param {Uint8Array} a Blocks, which change.
+ * @param {Uint8Array} b Blocks.
+ * @returns {Uint8Array} The array `a`.
  */
 function xor(a, b) {
-  for (let i = 0; i < BLOCK_SIZE; i++) {
+  for (let i = 0; i < a.length; i++) {
     a[i] ^= b[i];
   }
   return a;
 }
 
+/**
+ * Gives a copy of the block. `slice` does not do this for each array: the
+ * `slice` of a `Buffer` of Node.js is a view.
+ * @param {Uint8Array} block
+ * @returns {Uint8Array}
+ */
+function copy(block) {
+  return new Uint8Array(block);
+}
+
 /**
  * Gives the block j (from 0) of the data, as a view: a change of the view
  * changes the data.
diff --git a/backend/crypt/eme_test.js b/backend/crypt/eme_test.js
index 9fbe9be..b4aba11 100644
--- a/backend/crypt/eme_test.js
+++ b/backend/crypt/eme_test.js
@@ -1,6 +1,5 @@
 import { test } from "node:test";
-import { createCipheriv, createDecipheriv } from "node:crypto";
-import { AES } from "../../deps.js";
+import { aes256 } from "./aes.js";
 import {
   assertEquals,
   assertNotEquals,
@@ -24,20 +23,6 @@ function hex(text) {
   );
 }
 
-/**
- * AES with the key, as a block cipher of `node:crypto` (AES-ECB with no
- * padding), to compare with the AES of `aes-js`.
- * @param {Uint8Array} key 32 bytes.
- * @returns {import("./eme.js").BlockCipher}
- */
-function nodeAES(key) {
-  const ecb = (make) => (block) => {
-    const cipher = make("aes-256-ecb", key, null).setAutoPadding(false);
-    return new Uint8Array(cipher.update(block));
-  };
-  return { encrypt: ecb(createCipheriv), decrypt: ecb(createDecipheriv) };
-}
-
 /**
  * Gives the blocks of 16 bytes of the data, as views.
  * @param {Uint8Array} data
@@ -50,11 +35,6 @@ function blocks(data) {
   );
 }
 
-const CIPHERS = {
-  "aes-js": (key) => new AES(key),
-  "node:crypto": nodeAES,
-};
-
 // The vectors of https://github.com/rfjakob/eme (eme_test.go), the library of
 // rclone: the key, the tweak and the input are zeros.
 const VECTORS = {
@@ -120,17 +100,15 @@ const VECTORS = {
   `),
 };
 
-for (const [name, AESCipher] of Object.entries(CIPHERS)) {
-  test(`the vectors of rfjakob/eme, with AES of ${name}`, () => {
-    const cipher = AESCipher(new Uint8Array(32));
-    const tweak = new Uint8Array(16);
-    for (const [size, expected] of Object.entries(VECTORS)) {
-      const zeros = new Uint8Array(Number(size));
-      assertEquals(encrypt(cipher, tweak, zeros), expected);
-      assertEquals(decrypt(cipher, tweak, expected), zeros);
-    }
-  });
-}
+test("the vectors of rfjakob/eme", () => {
+  const cipher = aes256(new Uint8Array(32));
+  const tweak = new Uint8Array(16);
+  for (const [size, expected] of Object.entries(VECTORS)) {
+    const zeros = new Uint8Array(Number(size));
+    assertEquals(encrypt(cipher, tweak, zeros), expected);
+    assertEquals(decrypt(cipher, tweak, expected), zeros);
+  }
+});
 
 const KEY = fc.uint8Array({ minLength: 32, maxLength: 32 });
 const TWEAK = fc.uint8Array({ minLength: 16, maxLength: 16 });
@@ -141,7 +119,7 @@ const DATA = fc.integer({ min: 1, max: 128 }).chain((blocks) =>
 test("decrypt gives the data that encrypt took", () => {
   fc.assert(
     fc.property(KEY, TWEAK, DATA, (key, tweak, data) => {
-      const cipher = new AES(key);
+      const cipher = aes256(key);
       const encrypted = encrypt(cipher, tweak, data);
       assertEquals(encrypted.length, data.length);
       assertEquals(decrypt(cipher, tweak, encrypted), data);
@@ -152,7 +130,7 @@ test("decrypt gives the data that encrypt took", () => {
 test("a change of one bit of the input or of the tweak changes each block", () => {
   fc.assert(
     fc.property(KEY, TWEAK, DATA, fc.nat(), (key, tweak, data, bit) => {
-      const cipher = new AES(key);
+      const cipher = aes256(key);
       const before = blocks(encrypt(cipher, tweak, data));
 
       const changed = data.slice();
@@ -170,17 +148,21 @@ test("a change of one bit of the input or of the tweak changes each block", () =
   );
 });
 
-test("encrypt and decrypt do not change their input", () => {
-  const cipher = new AES(new Uint8Array(32));
-  const tweak = new Uint8Array(16);
-  const data = new Uint8Array(64).fill(7);
-  decrypt(cipher, tweak, encrypt(cipher, tweak, data));
-  assertEquals(tweak, new Uint8Array(16));
-  assertEquals(data, new Uint8Array(64).fill(7));
+test("encrypt and decrypt do not change their input, also a Buffer", () => {
+  const cipher = aes256(new Uint8Array(32));
+  // The slice of a Buffer is a view, not a copy.
+  for (const make of [(n) => new Uint8Array(n), (n) => Buffer.alloc(n)]) {
+    const tweak = make(16);
+    const data = make(64).fill(7);
+    const encrypted = encrypt(cipher, tweak, data);
+    assertEquals(decrypt(cipher, tweak, encrypted), new Uint8Array(64).fill(7));
+    assertEquals(new Uint8Array(tweak), new Uint8Array(16));
+    assertEquals(new Uint8Array(data), new Uint8Array(64).fill(7));
+  }
 });
 
 test("the tweak is 16 bytes, and the data are 1 to 128 blocks", () => {
-  const cipher = new AES(new Uint8Array(32));
+  const cipher = aes256(new Uint8Array(32));
   const tweak = new Uint8Array(16);
   for (const f of [encrypt, decrypt]) {
     assertThrows(() => f(cipher, new Uint8Array(15), new Uint8Array(16)), {
diff --git a/deps.js b/deps.js
index 79c4a83..b0914a8 100644
--- a/deps.js
+++ b/deps.js
@@ -13,11 +13,6 @@ import { crypto } from "@std/crypto";
 export { default as decodeBase32 } from "base32-decode";
 export { default as encodeBase32 } from "base32-encode";
 
-import aesjs from "aes-js";
-// `aes-js` is a CommonJS module, so we need to use `default` to import it.
-const { AES } = aesjs;
-export { AES };
-
 export { xsalsa20poly1305 } from "@noble/ciphers/salsa";
 export { scryptAsync as scrypt } from "@noble/hashes/scrypt";
 
diff --git a/package-lock.json b/package-lock.json
index 63eb940..3709f10 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -20,7 +20,6 @@
         "@std/ini": "npm:@jsr/std__ini@^0.225.1",
         "@std/media-types": "npm:@jsr/std__media-types@^1.0.0-rc.1",
         "@std/path": "npm:@jsr/std__path@^1.0.0-rc.2",
-        "aes-js": "^3.1.2",
         "base32-decode": "^1.0.0",
         "base32-encode": "^2.0.0"
       },
@@ -176,11 +175,6 @@
       "resolved": "https://npm.jsr.io/~/11/@jsr/std__path/1.0.0-rc.2.tgz",
       "integrity": "sha512-qUHfVMqAtMGPFmdkOfmkCONqgpe4UFVAaD+wL6ZdlQxtvQiNxHQWsje+djri+0095s/kkoBOPH4CpYxBq+zh3A=="
     },
-    "node_modules/aes-js": {
-      "version": "3.1.2",
-      "resolved": "https://registry.npmjs.org/aes-js/-/aes-js-3.1.2.tgz",
-      "integrity": "sha512-e5pEa2kBnBOgR4Y/p20pskXI74UEz7de8ZGVo58asOtvSVG5YAbJeELPZxOmt+Bnz3rX753YKhfIn4X4l1PPRQ=="
-    },
     "node_modules/base32-decode": {
       "version": "1.0.0",
       "resolved": "https://registry.npmjs.org/base32-decode/-/base32-decode-1.0.0.tgz",
diff --git a/package.json b/package.json
index 8709463..afddcd9 100644
--- a/package.json
+++ b/package.json
@@ -38,7 +38,6 @@
     "@std/ini": "npm:@jsr/std__ini@^0.225.1",
     "@std/media-types": "npm:@jsr/std__media-types@^1.0.0-rc.1",
     "@std/path": "npm:@jsr/std__path@^1.0.0-rc.2",
-    "aes-js": "^3.1.2",
     "base32-decode": "^1.0.0",
     "base32-encode": "^2.0.0"
   },

From 3d689cac2185b91cdc0580aa66a7bc131541e3e6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sat, 17 Oct 2026 01:31:02 +0000
Subject: [PATCH 04/87] build: Node.js only, with no Deno

deno.json, the Deno settings of VS Code and the engine deno go away. main.js runs with node, and the backends have no shebang of deno serve: a backend is a module, not a program. The two benchmarks run with node and lib/bench.js, a small helper with the timer of Deno.bench, in place of Deno.bench and Deno.Command (npm run bench). The README and CONTRIBUTING.md tell the npm commands and node:test. The tests give the same result as before: 68 of 93 pass on Node.js 26.
---
 .vscode/settings.json         |   4 --
 CONTRIBUTING.md               |   6 +-
 README.md                     |  14 +++--
 backend/chunker/main.js       |   2 -
 backend/chunker/main_bench.js | 101 +++++++++++++---------------------
 backend/crypt/main.js         |   2 -
 backend/drive/main.js         |   2 -
 backend/http/main.js          |   2 -
 backend/local/main.js         |   2 -
 backend/memory/main.js        |   2 -
 cmd/lsjson/main_bench.js      |  62 ++++++---------------
 deno.json                     |   6 --
 lib/bench.js                  |  51 +++++++++++++++++
 main.js                       |   2 +-
 package.json                  |   4 +-
 15 files changed, 119 insertions(+), 143 deletions(-)
 delete mode 100644 .vscode/settings.json
 delete mode 100644 deno.json
 create mode 100644 lib/bench.js

diff --git a/.vscode/settings.json b/.vscode/settings.json
deleted file mode 100644
index aa1c94e..0000000
--- a/.vscode/settings.json
+++ /dev/null
@@ -1,4 +0,0 @@
-{
-  "deno.enable": true,
-  "deno.unstable": true
-}
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 37b131e..87c3abc 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -9,9 +9,9 @@ Choose a name. The docs here will use `remote` as an example.
 Note that in rfetch terminology a file system backend is called a remote or an
 fs.
 
-- `deno init backend/remote`
-- Edit "backend/remote/main.js" and "backend/remote/main_test.js" for the new
-  backend.
+- Make the folder "backend/remote" with the files "main.js" and
+  "main_test.js" for the new backend. The tests use the test runner of
+  Node.js (`node:test`).
 - Implements a `fetch` default export function that handles "GET", "PUT" and
   "DELETE".
 - Uses `backend/local/main.js` as reference, or the boilerplate below:
diff --git a/README.md b/README.md
index 1a4e9b4..6cebbca 100644
--- a/README.md
+++ b/README.md
@@ -40,9 +40,11 @@ These backends adapt or modify other storage providers
 
 ## Development
 
-- Clone the repository and navigate to the folder.
-- `deno task start` to execute commands.
-- Alternatively, `deno task install` to install a `rfetch` executable in PATH
-  that is symbolic linked to the `main.js` file and use `rfetch` in place of
-  `deno task start`.
-- `deno task test` to run the test suites.
+- Clone the repository and go to its folder.
+- `npm install` to get the dependencies (Node.js 22.2 or later).
+- `npm start -- COMMAND ...` to run a command.
+- Alternatively, `npm link` to install a `rfetch` program in the PATH, with a
+  symbolic link to `main.js`, and use `rfetch` in place of `npm start --`.
+- `npm test` to run the tests, with the test runner of Node.js.
+- `npm run bench` to compare some commands with `rclone`, which must be in the
+  PATH.
diff --git a/backend/chunker/main.js b/backend/chunker/main.js
index 69fd307..4b90dd7 100644
--- a/backend/chunker/main.js
+++ b/backend/chunker/main.js
@@ -1,5 +1,3 @@
-#!/usr/bin/env -S deno serve --allow-all
-
 /**
  * Chunker
  *
diff --git a/backend/chunker/main_bench.js b/backend/chunker/main_bench.js
index 7b5de63..f4ef1c2 100644
--- a/backend/chunker/main_bench.js
+++ b/backend/chunker/main_bench.js
@@ -1,4 +1,13 @@
+/**
+ * Benchmark of `PUT` of chunker against `rclone rcat` of a chunker remote.
+ *
+ * `rclone` must be in the PATH. Run with `node backend/chunker/main_bench.js`.
+ */
+import { spawn } from "node:child_process";
+import { once } from "node:events";
+import { Writable } from "node:stream";
 import { mkBuffer } from "../../deps.js";
+import { bench } from "../../lib/bench.js";
 import backend from "./main.js";
 
 const buffer = mkBuffer(1024 * 1024 * 10); // 10M
@@ -8,73 +17,39 @@ const file = new File([buffer], "10M.bin", {
 
 const chunkSize = 1024 * 1024 * 4; // 4M
 
-//#region No chunking
-Deno.bench(
-  "rclone",
-  { group: "backend/chunker: default chunk_size" },
-  async () => {
-    const rclone = new Deno.Command("rclone", {
-      args: [
-        "rcat",
-        `:chunker,remote=':memory:':${file.name}`,
-      ],
-      stdin: "piped",
-    });
-    const rcat = rclone.spawn();
-    file.stream().pipeTo(rcat.stdin);
-    await rcat.status;
-  },
-);
-
-Deno.bench("rfetch", {
-  group: "backend/chunker: default chunk_size",
-  baseline: true,
-}, async () => {
+/**
+ * Sends the file to `rclone rcat` of the remote.
+ * @param {string} remote
+ */
+async function rcat(remote) {
+  const rclone = spawn("rclone", ["rcat", `${remote}:${file.name}`], {
+    stdio: ["pipe", "ignore", "inherit"],
+  });
+  await file.stream().pipeTo(Writable.toWeb(rclone.stdin));
+  await once(rclone, "close");
+}
+
+/**
+ * Sends the file to chunker with `PUT`.
+ * @param {Record<string, string>} params
+ */
+async function put(params) {
   const url = new URL(`/${file.name}`, "file:");
-  url.searchParams.set("remote", ":memory:");
-
+  for (const [name, value] of Object.entries(params)) {
+    url.searchParams.set(name, value);
+  }
   const response = await backend.fetch(
-    new Request(url, {
-      method: "PUT",
-      body: file,
-    }),
+    new Request(url, { method: "PUT", body: file }),
   );
   await response.arrayBuffer();
-});
-//#endregion No chunking
+}
 
-//#region Chunking
-Deno.bench(
-  "rclone",
-  { group: "backend/chunker: small chunk_size" },
-  async () => {
-    const rclone = new Deno.Command("rclone", {
-      args: [
-        "rcat",
-        `:chunker,remote=':memory:',chunk_size=${chunkSize}:${file.name}`,
-      ],
-      stdin: "piped",
-    });
-    const rcat = rclone.spawn();
-    file.stream().pipeTo(rcat.stdin);
-    await rcat.status;
-  },
-);
-
-Deno.bench("rfetch", {
-  group: "backend/chunker: small chunk_size",
-  baseline: true,
-}, async () => {
-  const url = new URL(`/${file.name}`, "file:");
-  url.searchParams.set("remote", ":memory:");
-  url.searchParams.set("chunk_size", `${chunkSize}`);
+await bench("backend/chunker: default chunk_size", {
+  rfetch: () => put({ remote: ":memory:" }),
+  rclone: () => rcat(":chunker,remote=':memory:'"),
+});
 
-  const response = await backend.fetch(
-    new Request(url, {
-      method: "PUT",
-      body: file,
-    }),
-  );
-  await response.arrayBuffer();
+await bench("backend/chunker: small chunk_size", {
+  rfetch: () => put({ remote: ":memory:", chunk_size: `${chunkSize}` }),
+  rclone: () => rcat(`:chunker,remote=':memory:',chunk_size=${chunkSize}`),
 });
-//#endregion Chunking
diff --git a/backend/crypt/main.js b/backend/crypt/main.js
index 94f48c1..3b43a22 100644
--- a/backend/crypt/main.js
+++ b/backend/crypt/main.js
@@ -1,5 +1,3 @@
-#!/usr/bin/env -S deno serve --allow-all
-
 /**
  * Crypt remote
  *
diff --git a/backend/drive/main.js b/backend/drive/main.js
index 56c4615..1747f43 100644
--- a/backend/drive/main.js
+++ b/backend/drive/main.js
@@ -1,5 +1,3 @@
-#!/usr/bin/env -S deno serve --allow-all
-
 import { formatBytes } from "../../deps.js";
 
 import { auth } from "./auth.js";
diff --git a/backend/http/main.js b/backend/http/main.js
index 44dda4c..96f1938 100644
--- a/backend/http/main.js
+++ b/backend/http/main.js
@@ -1,5 +1,3 @@
-#!/usr/bin/env -S deno serve --allow-all
-
 /**
  * The HTTP remote is a read only remote for reading files of a webserver. The
  * webserver should provide file listings which rfetch will read and turn into
diff --git a/backend/local/main.js b/backend/local/main.js
index 06378d5..6ca9171 100644
--- a/backend/local/main.js
+++ b/backend/local/main.js
@@ -1,5 +1,3 @@
-#!/usr/bin/env -S deno serve --allow-all
-
 import process from "node:process";
 import { contentType, extname, formatBytes, join } from "../../deps.js";
 
diff --git a/backend/memory/main.js b/backend/memory/main.js
index 518bdac..60c051c 100644
--- a/backend/memory/main.js
+++ b/backend/memory/main.js
@@ -1,5 +1,3 @@
-#!/usr/bin/env -S deno serve --allow-all
-
 /**
  * Memory Backend
  *
diff --git a/cmd/lsjson/main_bench.js b/cmd/lsjson/main_bench.js
index 30f1a2c..1693341 100644
--- a/cmd/lsjson/main_bench.js
+++ b/cmd/lsjson/main_bench.js
@@ -1,61 +1,31 @@
 /**
- * Benchmark `lsjson` command vs `rclone lsjson` command.
+ * Benchmark of the `lsjson` command against `rclone lsjson`.
  *
- * `rclone` must be installed and available in the PATH.
+ * `rclone` must be in the PATH. Run with `node cmd/lsjson/main_bench.js`.
  *
- * This benchmark skips the time to spawn `rclone` process for more
- * accurate comparison.
+ * This benchmark leaves out the time to start the `rclone` process, for a
+ * more accurate comparison.
  */
-
+import { spawn } from "node:child_process";
+import { Readable } from "node:stream";
+import { bench } from "../../lib/bench.js";
 import { lsjson } from "./main.js";
 
 const remotes = ["./", "./backend/", "./cmd/"];
 
 for (const remote of remotes) {
-  Deno.bench(
-    `rfetch lsjson ${remote} --recursive`,
-    {
-      baseline: true,
-      group: `timing ${remote} --recursive`,
-      permissions: {
-        env: true,
-        read: true,
-      },
-    },
-    async () => {
+  await bench(`timing ${remote} --recursive`, {
+    [`rfetch lsjson ${remote} --recursive`]: async () => {
       const response = await lsjson(remote, { recursive: true });
       await response.arrayBuffer();
     },
-  );
-
-  Deno.bench(
-    `rclone lsjson ${remote} --recursive`,
-    {
-      group: `timing ${remote} --recursive`,
-      permissions: {
-        env: true,
-        read: true,
-        run: true,
-      },
-    },
-    async (b) => {
-      const command = new Deno.Command("rclone", {
-        args: [
-          "lsjson",
-          remote,
-          "--recursive",
-        ],
-        stdout: "piped",
+    [`rclone lsjson ${remote} --recursive`]: async (timer) => {
+      const rclone = spawn("rclone", ["lsjson", remote, "--recursive"], {
+        stdio: ["ignore", "pipe", "inherit"],
       });
-
-      const process = command.spawn();
-
-      b.start();
-
-      const response = new Response(process.stdout);
-      await response.arrayBuffer();
-
-      b.end();
+      timer.start();
+      await new Response(Readable.toWeb(rclone.stdout)).arrayBuffer();
+      timer.end();
     },
-  );
+  });
 }
diff --git a/deno.json b/deno.json
deleted file mode 100644
index 724bbe0..0000000
--- a/deno.json
+++ /dev/null
@@ -1,6 +0,0 @@
-{
-  "tasks": {
-    "start": "deno run -A main.js",
-    "test": "deno test -A --fail-fast"
-  }
-}
diff --git a/lib/bench.js b/lib/bench.js
new file mode 100644
index 0000000..500a080
--- /dev/null
+++ b/lib/bench.js
@@ -0,0 +1,51 @@
+/**
+ * A small benchmark for the scripts `*_bench.js`, in place of `Deno.bench`.
+ * Run a script with `node FILE`.
+ *
+ * Each case is a function that gets a timer. By default the time of a run is
+ * the time of the whole function. A case can call `timer.start()` and
+ * `timer.end()` to time only a part, for example to leave out the start of a
+ * process.
+ */
+
+/**
+ * @typedef {Object} Timer
+ * @property {() => void} start
+ * @property {() => void} end
+ */
+
+/**
+ * Runs each case of the group one time to warm up, then `runs` times, and
+ * prints the mean time of a run.
+ * @param {string} group
+ * @param {Record<string, (timer: Timer) => Promise<void>>} cases
+ * @param {{ runs?: number }} [options]
+ */
+export async function bench(group, cases, { runs = 10 } = {}) {
+  console.log(group);
+  for (const [name, run] of Object.entries(cases)) {
+    await time(run);
+    let total = 0;
+    for (let i = 0; i < runs; i++) {
+      total += await time(run);
+    }
+    console.log(`  ${name}: ${(total / runs).toFixed(1)} ms`);
+  }
+}
+
+/**
+ * Gives the time of one run, in milliseconds.
+ * @param {(timer: Timer) => Promise<void>} run
+ * @returns {Promise<number>}
+ */
+async function time(run) {
+  let start, end;
+  const timer = {
+    start: () => (start = performance.now()),
+    end: () => (end = performance.now()),
+  };
+  const before = performance.now();
+  await run(timer);
+  const after = performance.now();
+  return (end ?? after) - (start ?? before);
+}
diff --git a/main.js b/main.js
index d26f471..0dd3257 100755
--- a/main.js
+++ b/main.js
@@ -1,4 +1,4 @@
-#!/usr/bin/env -S deno run --allow-all
+#!/usr/bin/env node
 
 /**
  * rfetch - fetching between remotes
diff --git a/package.json b/package.json
index afddcd9..a399405 100644
--- a/package.json
+++ b/package.json
@@ -3,8 +3,7 @@
   "version": "0.1.0",
   "description": "Fetching between remotes, using Web APIs.",
   "engines": {
-    "node": ">=22.2.0",
-    "deno": ">=1.44.4"
+    "node": ">=22.2.0"
   },
   "bin": {
     "rfetch": "main.js"
@@ -18,6 +17,7 @@
   "scripts": {
     "start": "node main.js",
     "test": "node --test",
+    "bench": "node backend/chunker/main_bench.js && node cmd/lsjson/main_bench.js",
     "worker": "npx wrangler pages dev ."
   },
   "author": "Trần Nguyễn Sơn",

From c7246228fe5e1e88e6d101b5048bb01c05bc79ad Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sat, 17 Oct 2026 01:38:02 +0000
Subject: [PATCH 05/87] fix(obscure): import the key at its first use

The key of obscure came from a top-level await. With the circular imports of mod.js and the backends, esbuild puts each module in a lazy function, and a top-level await cannot be in such a function: wrangler pages dev 4.142 could not build _worker.js, also on the first commit. The key is now a promise that getKey makes at its first use.
---
 cmd/obscure/main.js | 98 +++++++++++++++++++++++++--------------------
 deps.js             | 93 ------------------------------------------
 dev_deps.js         | 42 -------------------
 3 files changed, 55 insertions(+), 178 deletions(-)
 delete mode 100644 deps.js
 delete mode 100644 dev_deps.js

diff --git a/cmd/obscure/main.js b/cmd/obscure/main.js
index 78faeb4..9d20f48 100644
--- a/cmd/obscure/main.js
+++ b/cmd/obscure/main.js
@@ -1,46 +1,58 @@
 const ALGORITHM = "AES-CTR";
 
-const KEY = await crypto.subtle.importKey(
-  "raw",
-  // https://github.com/rclone/rclone/blob/10c884552caab3d3d8484ed3401e94f983a23f93/fs/config/obscure/obscure.go#L17-L22
-  Uint8Array.from([
-    0x9c,
-    0x93,
-    0x5b,
-    0x48,
-    0x73,
-    0x0a,
-    0x55,
-    0x4d,
-    0x6b,
-    0xfd,
-    0x7c,
-    0x63,
-    0xc8,
-    0x86,
-    0xa9,
-    0x2b,
-    0xd3,
-    0x90,
-    0x19,
-    0x8e,
-    0xb8,
-    0x12,
-    0x8a,
-    0xfb,
-    0xf4,
-    0xde,
-    0x16,
-    0x2b,
-    0x8b,
-    0x95,
-    0xf6,
-    0x38,
-  ]),
-  ALGORITHM,
-  false,
-  ["encrypt", "decrypt"],
-);
+/** @type {Promise<CryptoKey> | undefined} */
+let key;
+
+/**
+ * Gives the key of rclone for `obscure`. The import happens at the first use,
+ * not at the load of the module: a top-level await breaks the bundle of a
+ * Worker, and a Worker cannot use some APIs at the load.
+ * @returns {Promise<CryptoKey>}
+ */
+function getKey() {
+  key ??= crypto.subtle.importKey(
+    "raw",
+    // https://github.com/rclone/rclone/blob/10c884552caab3d3d8484ed3401e94f983a23f93/fs/config/obscure/obscure.go#L17-L22
+    Uint8Array.from([
+      0x9c,
+      0x93,
+      0x5b,
+      0x48,
+      0x73,
+      0x0a,
+      0x55,
+      0x4d,
+      0x6b,
+      0xfd,
+      0x7c,
+      0x63,
+      0xc8,
+      0x86,
+      0xa9,
+      0x2b,
+      0xd3,
+      0x90,
+      0x19,
+      0x8e,
+      0xb8,
+      0x12,
+      0x8a,
+      0xfb,
+      0xf4,
+      0xde,
+      0x16,
+      0x2b,
+      0x8b,
+      0x95,
+      0xf6,
+      0x38,
+    ]),
+    ALGORITHM,
+    false,
+    ["encrypt", "decrypt"],
+  );
+  return key;
+}
 
 const BlockSize = 16;
 
@@ -64,7 +76,7 @@ export async function obscure(password) {
       counter: iv,
       length: 64,
     },
-    KEY,
+    await getKey(),
     plaintext,
   );
   // Copies the encrypted buffer into the ciphertext buffer.
@@ -94,7 +106,7 @@ export async function reveal(cipherText) {
       counter: iv,
       length: 64,
     },
-    KEY,
+    await getKey(),
     data,
   );
 
diff --git a/deps.js b/deps.js
deleted file mode 100644
index b0914a8..0000000
--- a/deps.js
+++ /dev/null
@@ -1,93 +0,0 @@
-import { env } from "node:process";
-
-export * as INI from "@std/ini";
-export { basename, extname, join, resolve } from "@std/path";
-export { getCookies } from "@std/http/cookie";
-export { contentType } from "@std/media-types";
-export { format as formatBytes } from "@std/fmt/bytes";
-export { format as formatDuration } from "@std/fmt/duration";
-
-export { encodeBase64Url, encodeHex } from "@std/encoding";
-import { crypto } from "@std/crypto";
-
-export { default as decodeBase32 } from "base32-decode";
-export { default as encodeBase32 } from "base32-encode";
-
-export { xsalsa20poly1305 } from "@noble/ciphers/salsa";
-export { scryptAsync as scrypt } from "@noble/hashes/scrypt";
-
-import { HTMLRewriter } from "@sntran/html-rewriter";
-globalThis.HTMLRewriter = HTMLRewriter;
-export { HTMLRewriter };
-
-/**
- * Calculates the hash of a file.
- * @param {string} path
- * @param {import("@std/crypto").DigestAlgorithm} [algorithm=""]
- * @returns {string}
- */
-async function digest(path, algorithm = "MD5") {
-  const { readFile } = await import("node:fs/promises");
-  const payload = await readFile(path);
-  const buffer = await crypto.subtle.digest(algorithm, payload);
-  const hashArray = Array.from(new Uint8Array(buffer));
-  return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
-}
-
-export { crypto, digest };
-
-/**
- * Retrieves the configuration directory for current platform.
- * @returns {string | null}
- */
-export function config_dir() {
-  let dir = env["XDG_CONFIG_HOME"];
-  if (!dir) {
-    dir = env["APPDATA"]; // Windows
-  }
-  if (!dir) {
-    dir = env["HOME"];
-    if (dir) {
-      dir += "/.config";
-    }
-  }
-
-  return dir;
-}
-
-/**
- * Converts a date string to a locale ISO string.
- * @param {string | null} value
- * @returns {string}
- */
-export function toLocaleISOString(value) {
-  if (!value) return undefined;
-
-  let date = new Date(value);
-  const off = date.getTimezoneOffset() * -1;
-  const del = date.getMilliseconds() ? "Z" : "."; // have milliseconds ?
-  date = new Date(date.getTime() + off * 60000); // add or subtract time zone
-  return date
-    .toISOString()
-    .split(del)[0] +
-    (off < 0 ? "-" : "+") +
-    ("0" + Math.abs(Math.floor(off / 60))).substring(-2) +
-    ":" +
-    ("0" + Math.abs(off % 60)).substring(-2);
-}
-
-/**
- * Makes a buffer filled with random values.
- * @param {number} sizeInBytes
- * @param {(Uint8Array) => Uint8Array} fill
- * @returns {Uint8Array}
- */
-export function mkBuffer(sizeInBytes, fill = crypto.getRandomValues) {
-  const buffer = new Uint8Array(sizeInBytes);
-  const chunkSize = 65536; // maximum chunk size allowed by crypto.getRandomValues()
-  for (let i = 0; i < buffer.length; i += chunkSize) {
-    const chunk = buffer.subarray(i, i + chunkSize);
-    fill(chunk); // fill the chunk with random values
-  }
-  return buffer;
-}
diff --git a/dev_deps.js b/dev_deps.js
deleted file mode 100644
index e54c001..0000000
--- a/dev_deps.js
+++ /dev/null
@@ -1,42 +0,0 @@
-import {
-  deepEqual as assertEquals,
-  notDeepEqual as assertNotEquals,
-  ok as assert,
-  rejects as assertRejects,
-  throws as assertThrows,
-} from "node:assert/strict";
-export { assert, assertEquals, assertNotEquals, assertRejects, assertThrows };
-
-/**
- * Asserts a header
- * @param {Headers} headers
- * @param {string} name
- * @param {string} [value]
- */
-export function assertHeader(headers, name, value) {
-  if (value !== undefined) {
-    assertEquals(
-      headers.get(name),
-      value,
-      `should have ${name} header of ${value} instead of ${headers.get(name)}`,
-    );
-  } else {
-    assert(headers.get(name), `should have ${name} header`);
-  }
-}
-
-/**
- * Checks if two byte arrays are equal
- * @param {Uint8Array} a
- * @param {Uint8Array} b
- * @returns {boolean}
- */
-export function equalBytes(a, b) {
-  // Should not happen
-  if (a.length !== b.length) return false;
-  let isSame = true;
-  for (let i = 0; i < a.length; i++) isSame &&= a[i] === b[i]; // Lets hope JIT won't optimize away.
-  return isSame;
-}
-
-export * as fc from "fast-check";

From 8b32b82a780e0b8a4bf678fd556c85a8526a4c22 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sat, 17 Oct 2026 01:38:02 +0000
Subject: [PATCH 06/87] build: each module imports its packages, with no
 deps.js

deps.js and dev_deps.js re-exported the packages, as deps.ts in Deno. Now each module imports its packages, and package.json lists them. The modules that use HTMLRewriter import it: crypt used the global that deps.js set.

Node.js has the same functions for four packages, so they go away: @std/path is node:path, @std/encoding is Buffer, the MD5 of @std/crypto is createHash of node:crypto (with no WebAssembly, which Workers block), and nobody used @std/http. The tests import node:assert/strict and fast-check. The helpers of deps.js go to their users: toLocaleISOString to lib/time.js, config_dir to cmd/config.

The tests give the same result as before (68 of 93 pass). In wrangler pages dev, PUT, GET and the list of memory and of crypt over memory work, and rclone 1.75.1 decodes the name that crypt wrote.
---
 CONTRIBUTING.md                 |  2 +-
 backend/alias/main.js           |  2 +-
 backend/alias/main_test.js      |  4 +-
 backend/chunker/main.js         | 19 +++++--
 backend/chunker/main_bench.js   |  4 +-
 backend/chunker/main_test.js    | 59 +++++++++++---------
 backend/crypt/PathCipher.js     |  3 +-
 backend/crypt/eme_test.js       | 35 ++++++------
 backend/crypt/main.js           |  5 +-
 backend/crypt/main_test.js      | 39 +++++++++-----
 backend/crypt/secretbox.js      |  2 +-
 backend/crypt/secretbox_test.js |  5 +-
 backend/drive/auth.js           |  4 +-
 backend/drive/main.js           |  2 +-
 backend/drive/main_test.js      |  2 +-
 backend/http/main.js            |  4 +-
 backend/http/main_test.js       |  6 +--
 backend/local/main.js           |  4 +-
 backend/local/main_test.js      | 63 +++++++++++++---------
 backend/memory/main.js          |  4 +-
 backend/memory/main_test.js     | 34 ++++++++----
 cmd/backend/main_test.js        |  2 +-
 cmd/cat/main_test.js            |  2 +-
 cmd/config/main.js              | 22 +++++++-
 cmd/config/main_test.js         | 43 +++++++--------
 cmd/copy/main_test.js           |  2 +-
 cmd/copyurl/main.js             |  2 +-
 cmd/copyurl/main_test.js        |  2 +-
 cmd/ls/main_test.js             |  2 +-
 cmd/lsd/main_test.js            |  2 +-
 cmd/lsf/main_test.js            |  2 +-
 cmd/lsjson/main.js              |  4 +-
 cmd/lsjson/main_test.js         | 24 ++++-----
 cmd/lsl/main_test.js            |  2 +-
 cmd/obscure/main_test.js        |  5 +-
 cmd/rcat/main_test.js           |  2 +-
 lib/streams/progress.js         |  3 +-
 lib/time.js                     | 20 +++++++
 main_test.js                    | 58 ++++++++++----------
 package-lock.json               | 96 ---------------------------------
 package.json                    |  4 --
 41 files changed, 309 insertions(+), 292 deletions(-)
 create mode 100644 lib/time.js

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 87c3abc..65d79d8 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -17,7 +17,7 @@ fs.
 - Uses `backend/local/main.js` as reference, or the boilerplate below:
 
 ```ts
-import {} from "../../deps.js";
+import { join } from "node:path";
 
 function router(request: Request) {
   const { method, url } = request;
diff --git a/backend/alias/main.js b/backend/alias/main.js
index 5794266..6ead225 100644
--- a/backend/alias/main.js
+++ b/backend/alias/main.js
@@ -19,7 +19,7 @@
  * allowed as a remote. To alias the current directory use `.` instead.
  */
 
-import { join } from "../../deps.js";
+import { join } from "node:path";
 import { fetch } from "../../mod.js";
 
 /**
diff --git a/backend/alias/main_test.js b/backend/alias/main_test.js
index b9d5d7c..f4ae74c 100644
--- a/backend/alias/main_test.js
+++ b/backend/alias/main_test.js
@@ -1,8 +1,8 @@
 import { test } from "node:test";
 import process from "node:process";
 import { readdir } from "node:fs/promises";
-import { join } from "../../deps.js";
-import { assert } from "../../dev_deps.js";
+import { join } from "node:path";
+import assert from "node:assert/strict";
 
 import backend from "./main.js";
 
diff --git a/backend/chunker/main.js b/backend/chunker/main.js
index 4b90dd7..4494ecb 100644
--- a/backend/chunker/main.js
+++ b/backend/chunker/main.js
@@ -99,7 +99,7 @@
  * to missing chunk errors (especially missing last chunk) than format with
  * metadata enabled.
  */
-import { crypto, encodeHex } from "../../deps.js";
+import { createHash } from "node:crypto";
 import { Chunker } from "../../lib/streams/chunker.js";
 import { fetch } from "../../mod.js";
 
@@ -246,7 +246,7 @@ async function chunker(request) {
     let fileSize = 0;
 
     const streams = metaFormat === "none" ? [request.body] : request.body.tee();
-    const digestStream = streams[1] && crypto.subtle.digest("MD5", streams[1]);
+    const digestStream = streams[1] && md5(streams[1]);
 
     /**
      * @type {Uint8Array}
@@ -303,7 +303,7 @@ async function chunker(request) {
               ver: METADATA_VERSION,
               size: fileSize,
               nchunks: chunkIndex - startFrom,
-              md5: encodeHex(await digestStream),
+              md5: await digestStream,
             };
             // Adds metadata.
             await fetch(`${remote}/${fileName}`, {
@@ -385,3 +385,16 @@ async function upload(url, init) {
 export default {
   fetch: chunker,
 };
+
+/**
+ * Gives the MD5 of the stream, in hexadecimal.
+ * @param {ReadableStream<Uint8Array>} stream
+ * @returns {Promise<string>}
+ */
+async function md5(stream) {
+  const hash = createHash("md5");
+  for await (const chunk of stream) {
+    hash.update(chunk);
+  }
+  return hash.digest("hex");
+}
diff --git a/backend/chunker/main_bench.js b/backend/chunker/main_bench.js
index f4ef1c2..12947f1 100644
--- a/backend/chunker/main_bench.js
+++ b/backend/chunker/main_bench.js
@@ -4,13 +4,13 @@
  * `rclone` must be in the PATH. Run with `node backend/chunker/main_bench.js`.
  */
 import { spawn } from "node:child_process";
+import { randomBytes } from "node:crypto";
 import { once } from "node:events";
 import { Writable } from "node:stream";
-import { mkBuffer } from "../../deps.js";
 import { bench } from "../../lib/bench.js";
 import backend from "./main.js";
 
-const buffer = mkBuffer(1024 * 1024 * 10); // 10M
+const buffer = randomBytes(1024 * 1024 * 10); // 10M
 const file = new File([buffer], "10M.bin", {
   type: "application/octet-stream",
 });
diff --git a/backend/chunker/main_test.js b/backend/chunker/main_test.js
index f3e7ce2..0981406 100644
--- a/backend/chunker/main_test.js
+++ b/backend/chunker/main_test.js
@@ -1,14 +1,23 @@
 import { test } from "node:test";
-import { crypto, encodeHex, mkBuffer } from "../../deps.js";
-import { assert, assertEquals, equalBytes } from "../../dev_deps.js";
+import { Buffer } from "node:buffer";
+import { createHash, randomBytes } from "node:crypto";
+import assert from "node:assert/strict";
 import memory from "../memory/main.js";
 import backend from "./main.js";
 
-const buffer = mkBuffer(1024 * 1024 * 10); // 10M
+/**
+ * Tells if the two arrays have the same bytes.
+ * @param {Uint8Array} a
+ * @param {Uint8Array} b
+ * @returns {boolean}
+ */
+const sameBytes = (a, b) => Buffer.compare(a, b) === 0;
+
+const buffer = new Uint8Array(randomBytes(1024 * 1024 * 10)); // 10M
 const file = new File([buffer], "10M.bin", {
   type: "application/octet-stream",
 });
-const MD5 = encodeHex(await crypto.subtle.digest("MD5", buffer));
+const MD5 = createHash("md5").update(buffer).digest("hex");
 
 let chunkSize = 1024 * 1024 * 4; // 4M
 
@@ -48,16 +57,16 @@ test("PUT", async (t) => {
       const chunkName = `${
         encodeURIComponent(file.name)
       }.rclone_chunk.00${startFrom}`;
-      assertEquals(link, `<${chunkName}>`, `should have ${chunkName}`);
+      assert.deepEqual(link, `<${chunkName}>`, `should have ${chunkName}`);
 
       request = new Request(new URL(`/${chunkName}`, "memory:/"));
       response = await memory.fetch(request);
       const chunk = await response.arrayBuffer();
 
       if (startFrom < chunks) {
-        assertEquals(chunk.byteLength, chunkSize);
+        assert.deepEqual(chunk.byteLength, chunkSize);
       } else {
-        assertEquals(chunk.byteLength, file.size % chunkSize);
+        assert.deepEqual(chunk.byteLength, file.size % chunkSize);
       }
     }
   });
@@ -99,7 +108,7 @@ test("PUT", async (t) => {
       } else {
         chunkName = `${encodeURIComponent(file.name)}.part${startFrom}`;
       }
-      assertEquals(
+      assert.deepEqual(
         link,
         `<${chunkName}>`,
         `chunk ${startFrom} should have name of ${chunkName}, not ${link}`,
@@ -110,9 +119,9 @@ test("PUT", async (t) => {
       const chunk = await response.arrayBuffer();
 
       if (startFrom < chunks - 1) {
-        assertEquals(chunk.byteLength, chunkSize);
+        assert.deepEqual(chunk.byteLength, chunkSize);
       } else {
-        assertEquals(chunk.byteLength, file.size % chunkSize);
+        assert.deepEqual(chunk.byteLength, file.size % chunkSize);
       }
     }
   });
@@ -142,10 +151,10 @@ test("PUT", async (t) => {
     request = new Request(new URL(`/${file.name}`, "memory:/"));
     response = await memory.fetch(request);
     const metadata = await response.json();
-    assertEquals(metadata.ver, 1);
-    assertEquals(metadata.size, file.size);
-    assertEquals(metadata.nchunks, Math.ceil(file.size / chunkSize));
-    assertEquals(metadata.md5, MD5);
+    assert.deepEqual(metadata.ver, 1);
+    assert.deepEqual(metadata.size, file.size);
+    assert.deepEqual(metadata.nchunks, Math.ceil(file.size / chunkSize));
+    assert.deepEqual(metadata.md5, MD5);
   });
 
   await cleanup();
@@ -168,11 +177,11 @@ test("PUT", async (t) => {
     const links = response.headers.get("Link")?.split(/,\s*/);
     const chunks = Math.ceil(file.size / chunkSize);
 
-    assertEquals(links.length, chunks);
+    assert.deepEqual(links.length, chunks);
 
     request = new Request(new URL(`/${file.name}`, "memory:/"));
     response = await memory.fetch(request);
-    assertEquals(response.status, 404);
+    assert.deepEqual(response.status, 404);
   });
 
   await cleanup();
@@ -196,8 +205,8 @@ test("PUT", async (t) => {
     response = await memory.fetch(request);
     const links = response.headers.get("Link")?.split(/,\s*/);
 
-    assertEquals(links.length, 1, "should only have 1 file");
-    assertEquals(
+    assert.deepEqual(links.length, 1, "should only have 1 file");
+    assert.deepEqual(
       links[0],
       `<${encodeURIComponent(file.name)}>`,
       "should have the original file name",
@@ -207,7 +216,7 @@ test("PUT", async (t) => {
     response = await memory.fetch(request);
     const body = await response.arrayBuffer();
     assert(
-      equalBytes(new Uint8Array(body), buffer),
+      sameBytes(new Uint8Array(body), buffer),
       "should be the original file",
     );
   });
@@ -230,7 +239,7 @@ test("GET", async (t) => {
     request = new Request(url);
     response = await backend.fetch(request);
     const body = await response.arrayBuffer();
-    assert(equalBytes(new Uint8Array(body), buffer));
+    assert(sameBytes(new Uint8Array(body), buffer));
   });
 
   await cleanup();
@@ -249,7 +258,7 @@ test("GET", async (t) => {
     response = await backend.fetch(request);
     const body = await response.arrayBuffer();
     assert(
-      equalBytes(new Uint8Array(body), buffer),
+      sameBytes(new Uint8Array(body), buffer),
       "should return original file",
     );
   });
@@ -270,7 +279,7 @@ test("GET", async (t) => {
     response = await backend.fetch(request);
     const body = await response.arrayBuffer();
     assert(
-      equalBytes(new Uint8Array(body), buffer),
+      sameBytes(new Uint8Array(body), buffer),
       "should return original file",
     );
   });
@@ -291,7 +300,7 @@ test("GET", async (t) => {
     response = await fetch(request);
     const body = await response.arrayBuffer();
     assert(
-      equalBytes(new Uint8Array(body), buffer),
+      sameBytes(new Uint8Array(body), buffer),
       "should return original file",
     );
   });
@@ -313,7 +322,7 @@ test("GET", async (t) => {
     request = new Request(url);
     response = await backend.fetch(request);
     let body = await response.json();
-    assertEquals(body, json, "should return original file");
+    assert.deepEqual(body, json, "should return original file");
 
     await cleanup();
 
@@ -328,7 +337,7 @@ test("GET", async (t) => {
     request = new Request(url);
     response = await backend.fetch(request);
     body = await response.json();
-    assertEquals(body, json, "should return original file");
+    assert.deepEqual(body, json, "should return original file");
   });
 });
 
diff --git a/backend/crypt/PathCipher.js b/backend/crypt/PathCipher.js
index 66e6fa6..55f26ef 100644
--- a/backend/crypt/PathCipher.js
+++ b/backend/crypt/PathCipher.js
@@ -1,4 +1,5 @@
-import { decodeBase32, encodeBase32 } from "../../deps.js";
+import decodeBase32 from "base32-decode";
+import encodeBase32 from "base32-encode";
 import { aes256 } from "./aes.js";
 import * as EME from "./eme.js";
 import { pad, Padding, unpad } from "./padding.js";
diff --git a/backend/crypt/eme_test.js b/backend/crypt/eme_test.js
index b4aba11..0cd6546 100644
--- a/backend/crypt/eme_test.js
+++ b/backend/crypt/eme_test.js
@@ -1,11 +1,7 @@
 import { test } from "node:test";
 import { aes256 } from "./aes.js";
-import {
-  assertEquals,
-  assertNotEquals,
-  assertThrows,
-  fc,
-} from "../../dev_deps.js";
+import assert from "node:assert/strict";
+import fc from "fast-check";
 
 import { decrypt, encrypt } from "./eme.js";
 
@@ -105,8 +101,8 @@ test("the vectors of rfjakob/eme", () => {
   const tweak = new Uint8Array(16);
   for (const [size, expected] of Object.entries(VECTORS)) {
     const zeros = new Uint8Array(Number(size));
-    assertEquals(encrypt(cipher, tweak, zeros), expected);
-    assertEquals(decrypt(cipher, tweak, expected), zeros);
+    assert.deepEqual(encrypt(cipher, tweak, zeros), expected);
+    assert.deepEqual(decrypt(cipher, tweak, expected), zeros);
   }
 });
 
@@ -121,8 +117,8 @@ test("decrypt gives the data that encrypt took", () => {
     fc.property(KEY, TWEAK, DATA, (key, tweak, data) => {
       const cipher = aes256(key);
       const encrypted = encrypt(cipher, tweak, data);
-      assertEquals(encrypted.length, data.length);
-      assertEquals(decrypt(cipher, tweak, encrypted), data);
+      assert.deepEqual(encrypted.length, data.length);
+      assert.deepEqual(decrypt(cipher, tweak, encrypted), data);
     }),
   );
 });
@@ -136,13 +132,13 @@ test("a change of one bit of the input or of the tweak changes each block", () =
       const changed = data.slice();
       changed[(bit >> 3) % data.length] ^= 1 << (bit & 7);
       blocks(encrypt(cipher, tweak, changed)).forEach((block, j) =>
-        assertNotEquals(block, before[j])
+        assert.notDeepEqual(block, before[j])
       );
 
       const otherTweak = tweak.slice();
       otherTweak[(bit >> 3) % 16] ^= 1 << (bit & 7);
       blocks(encrypt(cipher, otherTweak, data)).forEach((block, j) =>
-        assertNotEquals(block, before[j])
+        assert.notDeepEqual(block, before[j])
       );
     }),
   );
@@ -155,9 +151,12 @@ test("encrypt and decrypt do not change their input, also a Buffer", () => {
     const tweak = make(16);
     const data = make(64).fill(7);
     const encrypted = encrypt(cipher, tweak, data);
-    assertEquals(decrypt(cipher, tweak, encrypted), new Uint8Array(64).fill(7));
-    assertEquals(new Uint8Array(tweak), new Uint8Array(16));
-    assertEquals(new Uint8Array(data), new Uint8Array(64).fill(7));
+    assert.deepEqual(
+      decrypt(cipher, tweak, encrypted),
+      new Uint8Array(64).fill(7),
+    );
+    assert.deepEqual(new Uint8Array(tweak), new Uint8Array(16));
+    assert.deepEqual(new Uint8Array(data), new Uint8Array(64).fill(7));
   }
 });
 
@@ -165,16 +164,16 @@ test("the tweak is 16 bytes, and the data are 1 to 128 blocks", () => {
   const cipher = aes256(new Uint8Array(32));
   const tweak = new Uint8Array(16);
   for (const f of [encrypt, decrypt]) {
-    assertThrows(() => f(cipher, new Uint8Array(15), new Uint8Array(16)), {
+    assert.throws(() => f(cipher, new Uint8Array(15), new Uint8Array(16)), {
       name: "TypeError",
       message: "EME: the tweak must be 16 bytes.",
     });
-    assertThrows(() => f(cipher, tweak, [0, 0]), {
+    assert.throws(() => f(cipher, tweak, [0, 0]), {
       name: "TypeError",
       message: "EME: the data must be a Uint8Array.",
     });
     for (const size of [0, 15, 17, 2064]) {
-      assertThrows(() => f(cipher, tweak, new Uint8Array(size)), {
+      assert.throws(() => f(cipher, tweak, new Uint8Array(size)), {
         name: "RangeError",
         message:
           `EME: the data must be 1 to 128 blocks of 16 bytes, not ${size} bytes.`,
diff --git a/backend/crypt/main.js b/backend/crypt/main.js
index 3b43a22..e119bb2 100644
--- a/backend/crypt/main.js
+++ b/backend/crypt/main.js
@@ -93,7 +93,10 @@
  * - 1049120 bytes total (a 0.05% overhead). This is the overhead for big files.
  */
 
-import { contentType, extname, scrypt } from "../../deps.js";
+import { extname } from "node:path";
+import { scryptAsync as scrypt } from "@noble/hashes/scrypt";
+import { HTMLRewriter } from "@sntran/html-rewriter";
+import { contentType } from "@std/media-types";
 import { fetch } from "../../mod.js";
 import { reveal } from "../../cmd/obscure/main.js";
 import PathCipher from "./PathCipher.js";
diff --git a/backend/crypt/main_test.js b/backend/crypt/main_test.js
index 7a84d68..e1b1d02 100644
--- a/backend/crypt/main_test.js
+++ b/backend/crypt/main_test.js
@@ -1,10 +1,21 @@
 import { test } from "node:test";
 import { readFile } from "node:fs/promises";
-import { contentType, extname, join } from "../../deps.js";
-import { assert, assertEquals, equalBytes, fc } from "../../dev_deps.js";
+import { Buffer } from "node:buffer";
+import { extname, join } from "node:path";
+import { contentType } from "@std/media-types";
+import assert from "node:assert/strict";
+import fc from "fast-check";
 
 import { decode, default as crypt, encode } from "./main.js";
 
+/**
+ * Tells if the two arrays have the same bytes.
+ * @param {Uint8Array} a
+ * @param {Uint8Array} b
+ * @returns {boolean}
+ */
+const sameBytes = (a, b) => Buffer.compare(a, b) === 0;
+
 const PASSWORD = "UmyLSdRHfew6aual28-ggx78qHqSfQ";
 const SALT = "Cj3gLa5PVwc2aot0QpKiOZ3YEzs3Sw";
 
@@ -36,7 +47,7 @@ test("decode", async () => {
 
   for await (const originalFilename of Object.keys(CRYPT)) {
     const decoded = await getText(encode(options, originalFilename));
-    assertEquals(decoded, CRYPT[originalFilename]);
+    assert.deepEqual(decoded, CRYPT[originalFilename]);
   }
 });
 
@@ -65,7 +76,7 @@ test("encode", async () => {
   const ciphertexts = await getText(encode(options, ...plaintexts));
   // Decodes all ciphertexts into plaintexts separated by newlines.
   const decoded = await getText(decode(options, ...ciphertexts.split("\n")));
-  assertEquals(decoded, plaintexts.join("\n"));
+  assert.deepEqual(decoded, plaintexts.join("\n"));
 });
 
 test("GET", async (t) => {
@@ -86,7 +97,7 @@ test("GET", async (t) => {
       response = await crypt.fetch(request);
 
       const decryptedFile = new Uint8Array(await response.arrayBuffer());
-      assert(equalBytes(decryptedFile, originalFile));
+      assert(sameBytes(decryptedFile, originalFile));
     }
   });
 
@@ -104,10 +115,10 @@ test("GET", async (t) => {
       response = await crypt.fetch(request);
 
       const size = Number(response.headers.get("Content-Length"));
-      assertEquals(size, originalFile.byteLength);
+      assert.deepEqual(size, originalFile.byteLength);
 
       const type = response.headers.get("Content-Type");
-      assertEquals(type, contentType(extname(originalFilename)));
+      assert.deepEqual(type, contentType(extname(originalFilename)));
 
       response.body?.cancel();
     }
@@ -132,10 +143,10 @@ test("PUT", async () => {
 
     // Asserts file does not exist in the original remote.
     response = await fetch(join(remote, originalFilename));
-    assertEquals(response.status, 404);
+    assert.deepEqual(response.status, 404);
 
     response = await fetch(join(remote, encryptedFilename));
-    assertEquals(response.status, 404);
+    assert.deepEqual(response.status, 404);
 
     // Uploads the file to the crypt remote.
     request = new Request(url, {
@@ -146,21 +157,21 @@ test("PUT", async () => {
 
     // Asserts original file does not exist in the original remote.
     response = await fetch(join(remote, originalFilename));
-    assertEquals(response.status, 404);
+    assert.deepEqual(response.status, 404);
 
     // Asserts encrypted file exists in the original remote.
     response = await fetch(join(remote, encryptedFilename));
-    assertEquals(response.status, 200);
+    assert.deepEqual(response.status, 200);
     const encryptedBuffer = new Uint8Array(await response.arrayBuffer());
-    assert(!equalBytes(encryptedBuffer, originalFile));
+    assert(!sameBytes(encryptedBuffer, originalFile));
 
     const magic = encryptedBuffer.subarray(0, 8);
-    assertEquals(magic, MAGIC, "should have magic header");
+    assert.deepEqual(magic, MAGIC, "should have magic header");
 
     // Gets the new file from the crypt remote.
     request = new Request(url);
     response = await crypt.fetch(request);
     const decryptedFile = new Uint8Array(await response.arrayBuffer());
-    assert(equalBytes(decryptedFile, originalFile));
+    assert(sameBytes(decryptedFile, originalFile));
   }
 });
diff --git a/backend/crypt/secretbox.js b/backend/crypt/secretbox.js
index 5fdde0d..e4acf67 100644
--- a/backend/crypt/secretbox.js
+++ b/backend/crypt/secretbox.js
@@ -1,7 +1,7 @@
 /**
  * @module crypt/secretbox
  */
-import { xsalsa20poly1305 } from "../../deps.js";
+import { xsalsa20poly1305 } from "@noble/ciphers/salsa";
 
 /**
  * Options for secretbox
diff --git a/backend/crypt/secretbox_test.js b/backend/crypt/secretbox_test.js
index 004b26a..1863ce0 100644
--- a/backend/crypt/secretbox_test.js
+++ b/backend/crypt/secretbox_test.js
@@ -1,5 +1,6 @@
 import { test } from "node:test";
-import { assertEquals, fc } from "../../dev_deps.js";
+import assert from "node:assert/strict";
+import fc from "fast-check";
 
 import { DecryptionStream, EncryptionStream } from "./secretbox.js";
 
@@ -17,7 +18,7 @@ test("decrypt/crypt", () => {
         const result = new Uint8Array(
           await new Response(decryptionStream).arrayBuffer(),
         );
-        assertEquals(result, content);
+        assert.deepEqual(result, content);
       },
     ),
   );
diff --git a/backend/drive/auth.js b/backend/drive/auth.js
index eef0ae9..4d0c086 100644
--- a/backend/drive/auth.js
+++ b/backend/drive/auth.js
@@ -1,4 +1,4 @@
-import { encodeBase64Url } from "../../deps.js";
+import { Buffer } from "node:buffer";
 
 import { reveal } from "../../cmd/obscure/main.js";
 
@@ -170,7 +170,7 @@ async function createJWT(serviceAccount, scopes) {
     key,
     encoder.encode(jwt),
   );
-  const signatureEncoded = encodeBase64Url(new Uint8Array(signature));
+  const signatureEncoded = Buffer.from(signature).toString("base64url");
 
   return `${jwt}.${signatureEncoded}`;
 }
diff --git a/backend/drive/main.js b/backend/drive/main.js
index 1747f43..ff9b2f3 100644
--- a/backend/drive/main.js
+++ b/backend/drive/main.js
@@ -1,4 +1,4 @@
-import { formatBytes } from "../../deps.js";
+import { format as formatBytes } from "@std/fmt/bytes";
 
 import { auth } from "./auth.js";
 import { list } from "./list.js";
diff --git a/backend/drive/main_test.js b/backend/drive/main_test.js
index 435db8a..9041d47 100644
--- a/backend/drive/main_test.js
+++ b/backend/drive/main_test.js
@@ -1,5 +1,5 @@
 import { test } from "node:test";
-import { assert } from "../../dev_deps.js";
+import assert from "node:assert/strict";
 import backend from "./main.js";
 
 test("GET", () => {
diff --git a/backend/http/main.js b/backend/http/main.js
index 96f1938..b5bcb01 100644
--- a/backend/http/main.js
+++ b/backend/http/main.js
@@ -24,7 +24,9 @@
  * To just download a single file it is easier to use [copyurl](../../cmd/copyurl/main.js).
  */
 
-import { formatBytes, HTMLRewriter, toLocaleISOString } from "../../deps.js";
+import { HTMLRewriter } from "@sntran/html-rewriter";
+import { format as formatBytes } from "@std/fmt/bytes";
+import { toLocaleISOString } from "../../lib/time.js";
 
 export const options = {
   boolean: [
diff --git a/backend/http/main_test.js b/backend/http/main_test.js
index 4974790..13f09cd 100644
--- a/backend/http/main_test.js
+++ b/backend/http/main_test.js
@@ -1,12 +1,12 @@
 import { test } from "node:test";
-import { assertEquals } from "../../dev_deps.js";
+import assert from "node:assert/strict";
 import backend from "./main.js";
 
 test("GET", async (t) => {
   await t.test("error without url searchParam", async () => {
     const url = new URL("/", "file:");
     const response = await backend.fetch(new Request(url));
-    assertEquals(response.status, 400);
+    assert.deepEqual(response.status, 400);
   });
 
   await t.test("a file", async () => {
@@ -22,7 +22,7 @@ test("GET", async (t) => {
     // Then compares with result from the backend
     response = await backend.fetch(new Request(url));
     const actual = await response.text();
-    assertEquals(
+    assert.deepEqual(
       actual,
       expected,
       "should be the same as fetching the remote file directly",
diff --git a/backend/local/main.js b/backend/local/main.js
index 6ca9171..cab77f7 100644
--- a/backend/local/main.js
+++ b/backend/local/main.js
@@ -1,5 +1,7 @@
 import process from "node:process";
-import { contentType, extname, formatBytes, join } from "../../deps.js";
+import { extname, join } from "node:path";
+import { format as formatBytes } from "@std/fmt/bytes";
+import { contentType } from "@std/media-types";
 
 /**
  * Serves a local remote
diff --git a/backend/local/main_test.js b/backend/local/main_test.js
index 966f892..9f7adf6 100644
--- a/backend/local/main_test.js
+++ b/backend/local/main_test.js
@@ -1,13 +1,9 @@
 import { test } from "node:test";
 import process from "node:process";
 import { readdir, readFile, stat } from "node:fs/promises";
-import { contentType, extname, join } from "../../deps.js";
-import {
-  assert,
-  assertEquals,
-  assertHeader,
-  assertRejects,
-} from "../../dev_deps.js";
+import { extname, join } from "node:path";
+import { contentType } from "@std/media-types";
+import assert from "node:assert/strict";
 
 import backend from "./main.js";
 
@@ -65,15 +61,21 @@ test("GET", async (t) => {
       const response = await fetch(request);
       const { headers, body } = response;
 
-      assertHeader(headers, "Content-Type", contentType(extname(name)) || "");
-      assertHeader(headers, "Content-Length", `${file.size}`);
-      assertHeader(headers, "Last-Modified", file.mtime?.toUTCString() || "");
+      assert.equal(
+        headers.get("Content-Type"),
+        contentType(extname(name)) || "",
+      );
+      assert.equal(headers.get("Content-Length"), `${file.size}`);
+      assert.equal(
+        headers.get("Last-Modified"),
+        file.mtime?.toUTCString() || "",
+      );
 
       assert(
         body instanceof ReadableStream,
         "should have body as a ReadableStream",
       );
-      assertEquals(
+      assert.deepEqual(
         await response.text(),
         await readFile(path, "utf8"),
         "should have the same content",
@@ -103,10 +105,10 @@ test("PUT", async (t) => {
     });
     const { status, headers } = await fetch(request);
 
-    assertEquals(status, 201, "should respond with 201 Created");
-    assertHeader(headers, "Content-Location", `/${newFile}`);
+    assert.deepEqual(status, 201, "should respond with 201 Created");
+    assert.equal(headers.get("Content-Location"), `/${newFile}`);
 
-    assertEquals(
+    assert.deepEqual(
       await readFile(targetFile, "utf8"),
       body,
       "should have the same content",
@@ -114,7 +116,11 @@ test("PUT", async (t) => {
 
     // Also checks the content with a GET request.
     const response = await fetch(new Request(url));
-    assertEquals(await response.text(), body, "should have the same content");
+    assert.deepEqual(
+      await response.text(),
+      body,
+      "should have the same content",
+    );
   });
 
   await t.test("a new folder", async () => {
@@ -131,8 +137,8 @@ test("PUT", async (t) => {
     });
     const { status, headers } = await fetch(request);
 
-    assertEquals(status, 201, "should respond with 201 Created");
-    assertHeader(headers, "Content-Location", `/${newFolder}`);
+    assert.deepEqual(status, 201, "should respond with 201 Created");
+    assert.equal(headers.get("Content-Location"), `/${newFolder}`);
 
     const stats = await stat(targetFolder);
     assert(stats.isDirectory, "should be a directory");
@@ -155,10 +161,13 @@ test("PUT", async (t) => {
     });
     const { status, headers } = await fetch(request);
 
-    assertEquals(status, 201, "should respond with 201 Created");
-    assertHeader(headers, "Content-Location", `/${join(newFolder, newFile)}`);
+    assert.deepEqual(status, 201, "should respond with 201 Created");
+    assert.equal(
+      headers.get("Content-Location"),
+      `/${join(newFolder, newFile)}`,
+    );
 
-    assertEquals(
+    assert.deepEqual(
       await readFile(targetFile, "utf8"),
       body,
       "should have the same content",
@@ -166,7 +175,11 @@ test("PUT", async (t) => {
 
     // Also checks the content with a GET request.
     const response = await fetch(new Request(url));
-    assertEquals(await response.text(), body, "should have the same content");
+    assert.deepEqual(
+      await response.text(),
+      body,
+      "should have the same content",
+    );
   });
 });
 
@@ -179,9 +192,9 @@ test("DELETE", async (t) => {
       method: "DELETE",
     });
     const { status } = await fetch(request);
-    assertEquals(status, 204, "should respond with 204 No Content");
+    assert.deepEqual(status, 204, "should respond with 204 No Content");
 
-    assertRejects(() => {
+    assert.rejects(() => {
       return stat(targetFile);
     });
   });
@@ -194,9 +207,9 @@ test("DELETE", async (t) => {
       method: "DELETE",
     });
     const { status } = await fetch(request);
-    assertEquals(status, 204, "should respond with 204 No Content");
+    assert.deepEqual(status, 204, "should respond with 204 No Content");
 
-    assertRejects(() => {
+    assert.rejects(() => {
       return stat(targetFolder);
     });
   });
diff --git a/backend/memory/main.js b/backend/memory/main.js
index 60c051c..a18b952 100644
--- a/backend/memory/main.js
+++ b/backend/memory/main.js
@@ -7,7 +7,9 @@
  * Because it has no parameters you can just use it with the `:memory:` remote
  * name.
  */
-import { contentType, extname, formatBytes } from "../../deps.js";
+import { extname } from "node:path";
+import { format as formatBytes } from "@std/fmt/bytes";
+import { contentType } from "@std/media-types";
 
 /**
  * @type {Map<string, File | null>}
diff --git a/backend/memory/main_test.js b/backend/memory/main_test.js
index e357f07..9a46165 100644
--- a/backend/memory/main_test.js
+++ b/backend/memory/main_test.js
@@ -1,6 +1,6 @@
 import { test } from "node:test";
-import { join } from "../../deps.js";
-import { assert, assertEquals, assertHeader } from "../../dev_deps.js";
+import { join } from "node:path";
+import assert from "node:assert/strict";
 
 import backend from "./main.js";
 
@@ -64,8 +64,8 @@ test("PUT", async (t) => {
       });
       const { status, headers } = await fetch(request);
 
-      assertEquals(status, 201, "should respond with 201 Created");
-      assertHeader(headers, "Content-Location", fixture);
+      assert.deepEqual(status, 201, "should respond with 201 Created");
+      assert.equal(headers.get("Content-Location"), fixture);
     }
   });
 });
@@ -108,7 +108,7 @@ test("GET", async (t) => {
       const url = new URL(fixture, "memory:/");
       const response = await fetch(new Request(url));
       const responseText = await response.text();
-      assertEquals(responseText, fixture, "should have the same content");
+      assert.deepEqual(responseText, fixture, "should have the same content");
     }
   });
 });
@@ -123,10 +123,18 @@ test("DELETE", async (t) => {
           method: "DELETE",
         }),
       );
-      assertEquals(response.status, 204, "should respond with 204 No Content");
+      assert.deepEqual(
+        response.status,
+        204,
+        "should respond with 204 No Content",
+      );
 
       response = await fetch(new Request(url));
-      assertEquals(response.status, 404, "should respond with 404 Not Found");
+      assert.deepEqual(
+        response.status,
+        404,
+        "should respond with 404 Not Found",
+      );
     }
   });
 
@@ -138,12 +146,20 @@ test("DELETE", async (t) => {
         method: "DELETE",
       }),
     );
-    assertEquals(response.status, 204, "should respond with 204 No Content");
+    assert.deepEqual(
+      response.status,
+      204,
+      "should respond with 204 No Content",
+    );
 
     for await (const fixture of descendants(pathname)) {
       const url = new URL(fixture, "memory:/");
       const response = await fetch(new Request(url));
-      assertEquals(response.status, 404, "should respond with 404 Not Found");
+      assert.deepEqual(
+        response.status,
+        404,
+        "should respond with 404 Not Found",
+      );
     }
   });
 });
diff --git a/cmd/backend/main_test.js b/cmd/backend/main_test.js
index 15ee5e6..f2aee2c 100644
--- a/cmd/backend/main_test.js
+++ b/cmd/backend/main_test.js
@@ -1,5 +1,5 @@
 import { test } from "node:test";
-import { assert } from "../../dev_deps.js";
+import assert from "node:assert/strict";
 import { backend } from "./main.js";
 
 test("backend", () => {
diff --git a/cmd/cat/main_test.js b/cmd/cat/main_test.js
index 1d15a05..02994f8 100644
--- a/cmd/cat/main_test.js
+++ b/cmd/cat/main_test.js
@@ -1,5 +1,5 @@
 import { test } from "node:test";
-import { assert } from "../../dev_deps.js";
+import assert from "node:assert/strict";
 import { cat } from "./main.js";
 
 test("cat", () => {
diff --git a/cmd/config/main.js b/cmd/config/main.js
index 015c261..9c9af68 100644
--- a/cmd/config/main.js
+++ b/cmd/config/main.js
@@ -1,6 +1,7 @@
 import { env } from "node:process";
 
-import { config_dir, INI, join } from "../../deps.js";
+import { join } from "node:path";
+import * as INI from "@std/ini";
 
 const NAME_REGEX = /^[\w.][\w.\s-]*$/;
 
@@ -144,3 +145,22 @@ export async function config(subcommand, name, options, init) {
       return new Response();
   }
 }
+
+/**
+ * Retrieves the configuration directory for current platform.
+ * @returns {string | null}
+ */
+export function config_dir() {
+  let dir = env["XDG_CONFIG_HOME"];
+  if (!dir) {
+    dir = env["APPDATA"]; // Windows
+  }
+  if (!dir) {
+    dir = env["HOME"];
+    if (dir) {
+      dir += "/.config";
+    }
+  }
+
+  return dir;
+}
diff --git a/cmd/config/main_test.js b/cmd/config/main_test.js
index 93c3193..2d1adbd 100644
--- a/cmd/config/main_test.js
+++ b/cmd/config/main_test.js
@@ -1,9 +1,10 @@
 import { test } from "node:test";
 import { readFile, unlink, writeFile } from "node:fs/promises";
-import { config_dir, join } from "../../deps.js";
-import { assert, assertEquals, fc } from "../../dev_deps.js";
+import { join } from "node:path";
+import assert from "node:assert/strict";
+import fc from "fast-check";
 
-import { config as configure } from "./main.js";
+import { config as configure, config_dir } from "./main.js";
 
 test("config", async (t) => {
   let command = "file";
@@ -11,7 +12,7 @@ test("config", async (t) => {
     const configDir = config_dir();
     let path = await configure(command).then((res) => res.text());
 
-    assertEquals(
+    assert.deepEqual(
       path,
       join(configDir, "rclone", "rclone.conf"),
       "should default to config directory",
@@ -19,7 +20,7 @@ test("config", async (t) => {
 
     await writeFile("rclone.conf", new Uint8Array());
     path = await configure(command).then((res) => res.text());
-    assertEquals(
+    assert.deepEqual(
       path,
       "rclone.conf",
       "should use rclone.conf at current directory first",
@@ -29,7 +30,7 @@ test("config", async (t) => {
   command = "create";
   await t.test(command, async () => {
     let config = await readFile("rclone.conf", { encoding: "utf8" });
-    assertEquals(config, "", "initial empty config");
+    assert.deepEqual(config, "", "initial empty config");
 
     await fc.assert(
       fc.asyncProperty(fc.string(), async (name) => {
@@ -51,12 +52,12 @@ test("config", async (t) => {
     });
 
     config = await readFile("rclone.conf", { encoding: "utf8" });
-    assertEquals(
+    assert.deepEqual(
       config,
       "[source]\ntype = local",
       "should have the new remote added",
     );
-    assertEquals(
+    assert.deepEqual(
       await response.text(),
       config,
       "should return the new remote in response",
@@ -68,12 +69,12 @@ test("config", async (t) => {
     });
 
     config = await readFile("rclone.conf", { encoding: "utf8" });
-    assertEquals(
+    assert.deepEqual(
       config,
       "[source]\ntype = local\n\n[target]\ntype = local",
       "should have both remotes",
     );
-    assertEquals(
+    assert.deepEqual(
       await response.text(),
       `[target]\ntype = local`,
       "should have only the new remote in response",
@@ -84,28 +85,28 @@ test("config", async (t) => {
   await t.test(command, async () => {
     const config = await readFile("rclone.conf", { encoding: "utf8" });
     let response = await configure(command);
-    assertEquals(
+    assert.deepEqual(
       await response.text(),
       config,
       "should return the full config when name is not specified",
     );
 
     response = await configure(command, "source");
-    assertEquals(
+    assert.deepEqual(
       await response.text(),
       "[source]\ntype = local",
       "should return only remote specified by name",
     );
 
     response = await configure(command, "target");
-    assertEquals(
+    assert.deepEqual(
       await response.text(),
       "[target]\ntype = local",
       "should return only remote specified by name",
     );
 
     response = await configure(command, "404");
-    assertEquals(
+    assert.deepEqual(
       response.status,
       404,
       "should return 404 when remote not found",
@@ -129,19 +130,19 @@ test("config", async (t) => {
     const remote = `[target]\ntype = alias\nremote = source:`;
 
     const config = await readFile("rclone.conf", { encoding: "utf8" });
-    assertEquals(
+    assert.deepEqual(
       config,
       `[source]\ntype = local\n\n${remote}`,
       "should have the remote updated",
     );
-    assertEquals(
+    assert.deepEqual(
       await response.text(),
       remote,
       "should return the updated remote in response",
     );
 
     response = await configure(command, "404", {});
-    assertEquals(
+    assert.deepEqual(
       response.status,
       404,
       "should return 404 when remote not found",
@@ -151,7 +152,7 @@ test("config", async (t) => {
   command = "dump";
   await t.test(command, async () => {
     const response = await configure(command);
-    assertEquals(await response.json(), {
+    assert.deepEqual(await response.json(), {
       source: {
         type: "local",
       },
@@ -166,19 +167,19 @@ test("config", async (t) => {
   await t.test(command, async () => {
     let response = await configure(command, "target");
     const config = await readFile("rclone.conf", { encoding: "utf8" });
-    assertEquals(
+    assert.deepEqual(
       config,
       "[source]\ntype = local",
       "should have the remote deleted",
     );
-    assertEquals(
+    assert.deepEqual(
       await response.text(),
       "",
       "should not return the deleted remote in response",
     );
 
     response = await configure(command, "404");
-    assertEquals(
+    assert.deepEqual(
       response.status,
       200,
       "should still return 200 when remote not found",
diff --git a/cmd/copy/main_test.js b/cmd/copy/main_test.js
index 55c2303..cbfba36 100644
--- a/cmd/copy/main_test.js
+++ b/cmd/copy/main_test.js
@@ -1,5 +1,5 @@
 import { test } from "node:test";
-import { assert } from "../../dev_deps.js";
+import assert from "node:assert/strict";
 import { copy } from "./main.js";
 
 test("copy", () => {
diff --git a/cmd/copyurl/main.js b/cmd/copyurl/main.js
index 5dc594b..bd4f7e9 100644
--- a/cmd/copyurl/main.js
+++ b/cmd/copyurl/main.js
@@ -1,4 +1,4 @@
-import { basename, resolve } from "../../deps.js";
+import { basename, resolve } from "node:path";
 
 import { fetch } from "../../mod.js";
 
diff --git a/cmd/copyurl/main_test.js b/cmd/copyurl/main_test.js
index 92bc62b..298ee45 100644
--- a/cmd/copyurl/main_test.js
+++ b/cmd/copyurl/main_test.js
@@ -1,5 +1,5 @@
 import { test } from "node:test";
-import { assert } from "../../dev_deps.js";
+import assert from "node:assert/strict";
 import { copyurl } from "./main.js";
 
 test("copyurl", () => {
diff --git a/cmd/ls/main_test.js b/cmd/ls/main_test.js
index d751cc7..7effdd4 100644
--- a/cmd/ls/main_test.js
+++ b/cmd/ls/main_test.js
@@ -1,5 +1,5 @@
 import { test } from "node:test";
-import { assert } from "../../dev_deps.js";
+import assert from "node:assert/strict";
 import { ls } from "./main.js";
 
 test("ls", () => {
diff --git a/cmd/lsd/main_test.js b/cmd/lsd/main_test.js
index 90e0ff0..7cb45d4 100644
--- a/cmd/lsd/main_test.js
+++ b/cmd/lsd/main_test.js
@@ -1,5 +1,5 @@
 import { test } from "node:test";
-import { assert } from "../../dev_deps.js";
+import assert from "node:assert/strict";
 import { lsd } from "./main.js";
 
 test("lsd", () => {
diff --git a/cmd/lsf/main_test.js b/cmd/lsf/main_test.js
index 28bf17d..cd9a63d 100644
--- a/cmd/lsf/main_test.js
+++ b/cmd/lsf/main_test.js
@@ -1,5 +1,5 @@
 import { test } from "node:test";
-import { assert } from "../../dev_deps.js";
+import assert from "node:assert/strict";
 import { lsf } from "./main.js";
 
 test("lsf", () => {
diff --git a/cmd/lsjson/main.js b/cmd/lsjson/main.js
index cc336d7..7f70b72 100644
--- a/cmd/lsjson/main.js
+++ b/cmd/lsjson/main.js
@@ -1,4 +1,6 @@
-import { basename, HTMLRewriter, toLocaleISOString } from "../../deps.js";
+import { basename } from "node:path";
+import { HTMLRewriter } from "@sntran/html-rewriter";
+import { toLocaleISOString } from "../../lib/time.js";
 
 import { fetch } from "../../mod.js";
 
diff --git a/cmd/lsjson/main_test.js b/cmd/lsjson/main_test.js
index a125098..599f398 100644
--- a/cmd/lsjson/main_test.js
+++ b/cmd/lsjson/main_test.js
@@ -1,5 +1,5 @@
 import { test } from "node:test";
-import { assert, assertEquals } from "../../dev_deps.js";
+import assert from "node:assert/strict";
 import { lsjson } from "./main.js";
 
 const encoder = new TextEncoder();
@@ -55,44 +55,44 @@ test(`lsjson("${pathname}")`, async (t) => {
     const text = await response.clone().text();
     const lines = text.trim().split("\n");
 
-    assertEquals(lines.shift(), "[");
+    assert.deepEqual(lines.shift(), "[");
 
     for (const child of tree[pathname]) {
       const line = lines.shift().replace(/,$/, "");
       const file = JSON.parse(line);
-      assertEquals(file.Name, child.replace("/", ""));
+      assert.deepEqual(file.Name, child.replace("/", ""));
     }
 
-    assertEquals(lines[0], "]");
+    assert.deepEqual(lines[0], "]");
   });
 
   await t.test("Path field is same as Name", async () => {
     const result = await response.clone().json();
     for (const file of result) {
-      assertEquals(file.Path, file.Name);
+      assert.deepEqual(file.Path, file.Name);
     }
   });
 
   await t.test("each object is a chunk in body stream", async () => {
     const reader = response.body.getReader();
     let result = await reader.read();
-    assertEquals(result.done, false);
-    assertEquals(decoder.decode(result.value).trim(), "[");
+    assert.deepEqual(result.done, false);
+    assert.deepEqual(decoder.decode(result.value).trim(), "[");
 
     for (const child of tree[pathname]) {
       result = await reader?.read();
-      assertEquals(result.done, false);
+      assert.deepEqual(result.done, false);
       const line = decoder.decode(result.value).trim().replace(/,$/, "");
       const file = JSON.parse(line);
-      assertEquals(file.Name, child.replace("/", ""));
+      assert.deepEqual(file.Name, child.replace("/", ""));
     }
 
     result = await reader?.read();
-    assertEquals(result.done, false);
-    assertEquals(decoder.decode(result.value).trim(), "]");
+    assert.deepEqual(result.done, false);
+    assert.deepEqual(decoder.decode(result.value).trim(), "]");
 
     result = await reader?.read();
-    assertEquals(result.done, true);
+    assert.deepEqual(result.done, true);
   });
 });
 
diff --git a/cmd/lsl/main_test.js b/cmd/lsl/main_test.js
index 16454dc..f619fda 100644
--- a/cmd/lsl/main_test.js
+++ b/cmd/lsl/main_test.js
@@ -1,5 +1,5 @@
 import { test } from "node:test";
-import { assert } from "../../dev_deps.js";
+import assert from "node:assert/strict";
 import { lsl } from "./main.js";
 
 test("lsl", () => {
diff --git a/cmd/obscure/main_test.js b/cmd/obscure/main_test.js
index 180e355..8a38ea6 100644
--- a/cmd/obscure/main_test.js
+++ b/cmd/obscure/main_test.js
@@ -1,5 +1,6 @@
 import { test } from "node:test";
-import { assertEquals, fc } from "../../dev_deps.js";
+import assert from "node:assert/strict";
+import fc from "fast-check";
 import { obscure, reveal } from "./main.js";
 
 /**
@@ -9,7 +10,7 @@ import { obscure, reveal } from "./main.js";
  */
 async function assertResponse(response, expected) {
   response = await response;
-  assertEquals(await response.text(), expected);
+  assert.deepEqual(await response.text(), expected);
 }
 
 test("reveal", () => {
diff --git a/cmd/rcat/main_test.js b/cmd/rcat/main_test.js
index 2f92719..6244f39 100644
--- a/cmd/rcat/main_test.js
+++ b/cmd/rcat/main_test.js
@@ -1,5 +1,5 @@
 import { test } from "node:test";
-import { assert } from "../../dev_deps.js";
+import assert from "node:assert/strict";
 import { rcat } from "./main.js";
 
 test("rcat", () => {
diff --git a/lib/streams/progress.js b/lib/streams/progress.js
index 39095ee..1b8d5fe 100644
--- a/lib/streams/progress.js
+++ b/lib/streams/progress.js
@@ -1,4 +1,5 @@
-import { formatBytes, formatDuration } from "../../deps.js";
+import { format as formatBytes } from "@std/fmt/bytes";
+import { format as formatDuration } from "@std/fmt/duration";
 
 export class Progress extends TransformStream {
   completed = 0;
diff --git a/lib/time.js b/lib/time.js
new file mode 100644
index 0000000..80320bb
--- /dev/null
+++ b/lib/time.js
@@ -0,0 +1,20 @@
+/**
+ * Converts a date string to a locale ISO string.
+ * @param {string | null} value
+ * @returns {string}
+ */
+export function toLocaleISOString(value) {
+  if (!value) return undefined;
+
+  let date = new Date(value);
+  const off = date.getTimezoneOffset() * -1;
+  const del = date.getMilliseconds() ? "Z" : "."; // have milliseconds ?
+  date = new Date(date.getTime() + off * 60000); // add or subtract time zone
+  return date
+    .toISOString()
+    .split(del)[0] +
+    (off < 0 ? "-" : "+") +
+    ("0" + Math.abs(Math.floor(off / 60))).substring(-2) +
+    ":" +
+    ("0" + Math.abs(off % 60)).substring(-2);
+}
diff --git a/main_test.js b/main_test.js
index a14c261..eb2d909 100644
--- a/main_test.js
+++ b/main_test.js
@@ -2,7 +2,7 @@ import { test } from "node:test";
 import process from "node:process";
 import { unlink, writeFile } from "node:fs/promises";
 import { serve } from "@sntran/serve";
-import { assert, assertEquals } from "./dev_deps.js";
+import assert from "node:assert/strict";
 
 import { config } from "./mod.js";
 
@@ -39,16 +39,16 @@ test("fetch", async (t) => {
       });
       const { status, headers } = response;
 
-      assertEquals(status, 200);
-      assertEquals(headers.get("Content-Type"), "message/http");
+      assert.deepEqual(status, 200);
+      assert.deepEqual(headers.get("Content-Type"), "message/http");
 
-      assertEquals(headers.get("Via"), "local/1.1");
+      assert.deepEqual(headers.get("Via"), "local/1.1");
 
       const body = await response.text();
       const [, _method, url] = body.match(/^(TRACE) (.*) HTTP\/1.1$/m) || [];
       const { pathname } = new URL(url, "file:");
 
-      assertEquals(pathname, cwd);
+      assert.deepEqual(pathname, cwd);
     });
 
     // Sets up
@@ -65,20 +65,20 @@ test("fetch", async (t) => {
       const { status, headers } = await fetch(":local:", {
         method: "TRACE",
       });
-      assertEquals(status, 200);
-      assertEquals(headers.get("Content-Type"), "message/http");
+      assert.deepEqual(status, 200);
+      assert.deepEqual(headers.get("Content-Type"), "message/http");
 
-      assertEquals(headers.get("Via"), "local/1.1");
+      assert.deepEqual(headers.get("Via"), "local/1.1");
     });
 
     await t.test("name:", async () => {
       const { status, headers } = await fetch("source:", {
         method: "TRACE",
       });
-      assertEquals(status, 200);
-      assertEquals(headers.get("Content-Type"), "message/http");
+      assert.deepEqual(status, 200);
+      assert.deepEqual(headers.get("Content-Type"), "message/http");
 
-      assertEquals(headers.get("Via"), "local/1.1 source");
+      assert.deepEqual(headers.get("Via"), "local/1.1 source");
     });
 
     /** Connection string */
@@ -91,17 +91,17 @@ test("fetch", async (t) => {
         });
         const { status, headers } = response;
 
-        assertEquals(status, 200);
-        assertEquals(headers.get("Content-Type"), "message/http");
+        assert.deepEqual(status, 200);
+        assert.deepEqual(headers.get("Content-Type"), "message/http");
 
-        assertEquals(headers.get("Via"), "alias/1.1 target");
+        assert.deepEqual(headers.get("Via"), "alias/1.1 target");
 
         const body = await response.text();
         const [, _method, url] = body.match(/^(TRACE) (.*) HTTP\/1.1$/m) || [];
         const { pathname, searchParams } = new URL(url, "file:");
 
-        assertEquals(pathname, "/");
-        assertEquals(searchParams.get("remote"), `source:`);
+        assert.deepEqual(pathname, "/");
+        assert.deepEqual(searchParams.get("remote"), `source:`);
       });
 
       await t.test(
@@ -116,8 +116,8 @@ test("fetch", async (t) => {
             [];
           const { searchParams } = new URL(url, "file:");
 
-          assertEquals(searchParams.get("remote"), `source:`);
-          assertEquals(searchParams.get("skip_links"), `true`);
+          assert.deepEqual(searchParams.get("remote"), `source:`);
+          assert.deepEqual(searchParams.get("skip_links"), `true`);
         },
       );
 
@@ -133,7 +133,7 @@ test("fetch", async (t) => {
             [];
           const { searchParams } = new URL(url, "file:");
 
-          assertEquals(searchParams.get("remote"), `/tmp/1`);
+          assert.deepEqual(searchParams.get("remote"), `/tmp/1`);
           assert(
             !searchParams.has("alias_remote"),
             "should not have param prefixed with backend type",
@@ -153,7 +153,7 @@ test("fetch", async (t) => {
             [];
           const { searchParams } = new URL(url, "file:");
 
-          assertEquals(searchParams.get("remote"), `/tmp/2`);
+          assert.deepEqual(searchParams.get("remote"), `/tmp/2`);
           assert(
             !searchParams.has("config_target_remote"),
             "should not have param prefixed with remote name",
@@ -169,18 +169,18 @@ test("fetch", async (t) => {
           });
           const { status, headers } = response;
 
-          assertEquals(status, 200);
-          assertEquals(headers.get("Content-Type"), "message/http");
+          assert.deepEqual(status, 200);
+          assert.deepEqual(headers.get("Content-Type"), "message/http");
 
-          assertEquals(headers.get("Via"), "alias/1.1 target");
+          assert.deepEqual(headers.get("Via"), "alias/1.1 target");
 
           const body = await response.text();
           const [, _method, url] = body.match(/^(TRACE) (.*) HTTP\/1.1$/m) ||
             [];
           const { pathname, searchParams } = new URL(url, "file:");
 
-          assertEquals(pathname, "/");
-          assertEquals(searchParams.get("remote"), `'/tmp/3'`);
+          assert.deepEqual(pathname, "/");
+          assert.deepEqual(searchParams.get("remote"), `'/tmp/3'`);
         },
       );
 
@@ -195,8 +195,8 @@ test("fetch", async (t) => {
         const [, _method, url] = body.match(/^(TRACE) (.*) HTTP\/1.1$/m) || [];
         const { pathname, searchParams } = new URL(url, "file:");
 
-        assertEquals(pathname, "/");
-        assertEquals(searchParams.get("remote"), `'${cwd}'`);
+        assert.deepEqual(pathname, "/");
+        assert.deepEqual(searchParams.get("remote"), `'${cwd}'`);
       });
 
       await t.test(
@@ -213,8 +213,8 @@ test("fetch", async (t) => {
             [];
           const { pathname, searchParams } = new URL(url, "file:");
 
-          assertEquals(pathname, "/");
-          assertEquals(searchParams.get("remote"), `':local:${cwd}'`);
+          assert.deepEqual(pathname, "/");
+          assert.deepEqual(searchParams.get("remote"), `':local:${cwd}'`);
         },
       );
     });
diff --git a/package-lock.json b/package-lock.json
index 3709f10..401b78a 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -13,13 +13,9 @@
         "@noble/hashes": "^1.4.0",
         "@sntran/html-rewriter": "^0.2.0",
         "@sntran/serve": "^0.0.1",
-        "@std/crypto": "npm:@jsr/std__crypto@^1.0.0-rc.1",
-        "@std/encoding": "npm:@jsr/std__encoding@^1.0.0-rc.2",
         "@std/fmt": "npm:@jsr/std__fmt@^0.225.4",
-        "@std/http": "npm:@jsr/std__http@^0.224.5",
         "@std/ini": "npm:@jsr/std__ini@^0.225.1",
         "@std/media-types": "npm:@jsr/std__media-types@^1.0.0-rc.1",
-        "@std/path": "npm:@jsr/std__path@^1.0.0-rc.2",
         "base32-decode": "^1.0.0",
         "base32-encode": "^2.0.0"
       },
@@ -30,67 +26,9 @@
         "fast-check": "^3.19.0"
       },
       "engines": {
-        "deno": ">=1.44.4",
         "node": ">=22.2.0"
       }
     },
-    "node_modules/@jsr/std__async": {
-      "version": "1.0.0-rc.2",
-      "resolved": "https://npm.jsr.io/~/11/@jsr/std__async/1.0.0-rc.2.tgz",
-      "integrity": "sha512-mW3WDco4WkcsVhuwWRRRMSOW2odyXb1O80TMnfFjJZbxmlVXZKZmR9RkJvSQv8BcxopdZ3JCigkHNEmtRFsTXQ=="
-    },
-    "node_modules/@jsr/std__bytes": {
-      "version": "1.0.0-rc.3",
-      "resolved": "https://npm.jsr.io/~/11/@jsr/std__bytes/1.0.0-rc.3.tgz",
-      "integrity": "sha512-4cHQrAO+8e6YcJVNHiPvkX9LVPhy4ugiatYUZnZ5kO1JG2dZia6wu9dYEsL6pInUQuBx9tFcPIowc0YmeNP+CQ=="
-    },
-    "node_modules/@jsr/std__cli": {
-      "version": "0.224.7",
-      "resolved": "https://npm.jsr.io/~/11/@jsr/std__cli/0.224.7.tgz",
-      "integrity": "sha512-SSE7AMT/nqTUKeQXB+PZcmD6L5IjsOFDQdm88Ik2o6P4gS+gXewLMPZJu/X/gaOH5ux2C4xZ26Dgp3vCAIuB4g=="
-    },
-    "node_modules/@jsr/std__encoding": {
-      "version": "1.0.0-rc.2",
-      "resolved": "https://npm.jsr.io/~/11/@jsr/std__encoding/1.0.0-rc.2.tgz",
-      "integrity": "sha512-ISvxD+exWVg/aESN3G1Tr0oszHRgUEEK1JjiRcuyCtd1uqSGXXMAoswYlYvPwA6mxZ7FQbFSZEbP3tN2J+fIUQ=="
-    },
-    "node_modules/@jsr/std__fmt": {
-      "version": "0.225.4",
-      "resolved": "https://npm.jsr.io/~/11/@jsr/std__fmt/0.225.4.tgz",
-      "integrity": "sha512-lb8QcV3YnAu3GsrG7wd51Fb56RxOBp4szMRS/TCLnQptmF0Rd0v8ksQeTHmGkuD6MY/V8gEy/Sj0qulRvR9lqQ=="
-    },
-    "node_modules/@jsr/std__io": {
-      "version": "0.224.2",
-      "resolved": "https://npm.jsr.io/~/11/@jsr/std__io/0.224.2.tgz",
-      "integrity": "sha512-7IbtJWWM13TaXkZR3jL0LLkAbEaublLR6WSMZuzg58IACDGnzcmxKlI57KjEBTuawX4u6x7g8f6zRleuRpSXVA==",
-      "dependencies": {
-        "@jsr/std__bytes": "^1.0.0-rc.3"
-      }
-    },
-    "node_modules/@jsr/std__media-types": {
-      "version": "1.0.0-rc.1",
-      "resolved": "https://npm.jsr.io/~/11/@jsr/std__media-types/1.0.0-rc.1.tgz",
-      "integrity": "sha512-0UdhqMLempJi8rHXJ4xSsRs79gMIm+X8/jAcBxUa9sdbsRALM148t/c2JIRWN4S58LQVBRHNK3WYd/YgR4fLNA=="
-    },
-    "node_modules/@jsr/std__net": {
-      "version": "0.224.3",
-      "resolved": "https://npm.jsr.io/~/11/@jsr/std__net/0.224.3.tgz",
-      "integrity": "sha512-67B6bpkMjNSWtEPLy/k4OpuCb65w+L0mf9Amp1E2uUs4nt31vZZazW8IUykE9+1sv0tDVxa8nFZ2p9VwdiLXaA=="
-    },
-    "node_modules/@jsr/std__path": {
-      "version": "1.0.0-rc.2",
-      "resolved": "https://npm.jsr.io/~/11/@jsr/std__path/1.0.0-rc.2.tgz",
-      "integrity": "sha512-qUHfVMqAtMGPFmdkOfmkCONqgpe4UFVAaD+wL6ZdlQxtvQiNxHQWsje+djri+0095s/kkoBOPH4CpYxBq+zh3A=="
-    },
-    "node_modules/@jsr/std__streams": {
-      "version": "0.224.5",
-      "resolved": "https://npm.jsr.io/~/11/@jsr/std__streams/0.224.5.tgz",
-      "integrity": "sha512-LWs0LfBcyj4VzE3ff1cwoEyJ3AkoIT3CQubxeA0YQr3KEC/c6xB9Rq9nVit8gZ8RgtbMDlyfPtN1MkwTgPFj+g==",
-      "dependencies": {
-        "@jsr/std__bytes": "^1.0.0-rc.3",
-        "@jsr/std__io": "^0.224.1"
-      }
-    },
     "node_modules/@noble/ciphers": {
       "version": "0.5.3",
       "resolved": "https://registry.npmjs.org/@noble/ciphers/-/ciphers-0.5.3.tgz",
@@ -123,40 +61,12 @@
       "resolved": "https://registry.npmjs.org/@sntran/serve/-/serve-0.0.1.tgz",
       "integrity": "sha512-yejSB/mTWeRg7fK++lLZcz5Av407HZ7VN4l84FxxpCoERpGRL1fP43wNeRC4xeup7xPtnHXsjinxz6xEByglNA=="
     },
-    "node_modules/@std/crypto": {
-      "name": "@jsr/std__crypto",
-      "version": "1.0.0-rc.1",
-      "resolved": "https://npm.jsr.io/~/11/@jsr/std__crypto/1.0.0-rc.1.tgz",
-      "integrity": "sha512-HdqxgBx468H2ePsUUEYh4dyABELe1qxt4r2qK4UAR4gBrLxPRMBmAkZD0E7n/kUYA7+LTtLZ7OOhjZoQ9PPgrQ=="
-    },
-    "node_modules/@std/encoding": {
-      "name": "@jsr/std__encoding",
-      "version": "1.0.0-rc.2",
-      "resolved": "https://npm.jsr.io/~/11/@jsr/std__encoding/1.0.0-rc.2.tgz",
-      "integrity": "sha512-ISvxD+exWVg/aESN3G1Tr0oszHRgUEEK1JjiRcuyCtd1uqSGXXMAoswYlYvPwA6mxZ7FQbFSZEbP3tN2J+fIUQ=="
-    },
     "node_modules/@std/fmt": {
       "name": "@jsr/std__fmt",
       "version": "0.225.4",
       "resolved": "https://npm.jsr.io/~/11/@jsr/std__fmt/0.225.4.tgz",
       "integrity": "sha512-lb8QcV3YnAu3GsrG7wd51Fb56RxOBp4szMRS/TCLnQptmF0Rd0v8ksQeTHmGkuD6MY/V8gEy/Sj0qulRvR9lqQ=="
     },
-    "node_modules/@std/http": {
-      "name": "@jsr/std__http",
-      "version": "0.224.5",
-      "resolved": "https://npm.jsr.io/~/11/@jsr/std__http/0.224.5.tgz",
-      "integrity": "sha512-PomDgsxwBoCkqTCG7e1Sz4QCAgNFhEGf71GWNercppQlgKtzp6zxsDgcJ4+vrqHIq5W8L1eqJWiceNkUUkMZjQ==",
-      "dependencies": {
-        "@jsr/std__async": "^1.0.0-rc.1",
-        "@jsr/std__cli": "^0.224.7",
-        "@jsr/std__encoding": "1.0.0-rc.2",
-        "@jsr/std__fmt": "^0.225.4",
-        "@jsr/std__media-types": "^1.0.0-rc.1",
-        "@jsr/std__net": "^0.224.3",
-        "@jsr/std__path": "1.0.0-rc.2",
-        "@jsr/std__streams": "^0.224.5"
-      }
-    },
     "node_modules/@std/ini": {
       "name": "@jsr/std__ini",
       "version": "0.225.1",
@@ -169,12 +79,6 @@
       "resolved": "https://npm.jsr.io/~/11/@jsr/std__media-types/1.0.0-rc.1.tgz",
       "integrity": "sha512-0UdhqMLempJi8rHXJ4xSsRs79gMIm+X8/jAcBxUa9sdbsRALM148t/c2JIRWN4S58LQVBRHNK3WYd/YgR4fLNA=="
     },
-    "node_modules/@std/path": {
-      "name": "@jsr/std__path",
-      "version": "1.0.0-rc.2",
-      "resolved": "https://npm.jsr.io/~/11/@jsr/std__path/1.0.0-rc.2.tgz",
-      "integrity": "sha512-qUHfVMqAtMGPFmdkOfmkCONqgpe4UFVAaD+wL6ZdlQxtvQiNxHQWsje+djri+0095s/kkoBOPH4CpYxBq+zh3A=="
-    },
     "node_modules/base32-decode": {
       "version": "1.0.0",
       "resolved": "https://registry.npmjs.org/base32-decode/-/base32-decode-1.0.0.tgz",
diff --git a/package.json b/package.json
index a399405..2b168fd 100644
--- a/package.json
+++ b/package.json
@@ -31,13 +31,9 @@
     "@noble/hashes": "^1.4.0",
     "@sntran/html-rewriter": "^0.2.0",
     "@sntran/serve": "^0.0.1",
-    "@std/crypto": "npm:@jsr/std__crypto@^1.0.0-rc.1",
-    "@std/encoding": "npm:@jsr/std__encoding@^1.0.0-rc.2",
     "@std/fmt": "npm:@jsr/std__fmt@^0.225.4",
-    "@std/http": "npm:@jsr/std__http@^0.224.5",
     "@std/ini": "npm:@jsr/std__ini@^0.225.1",
     "@std/media-types": "npm:@jsr/std__media-types@^1.0.0-rc.1",
-    "@std/path": "npm:@jsr/std__path@^1.0.0-rc.2",
     "base32-decode": "^1.0.0",
     "base32-encode": "^2.0.0"
   },

From 49f284b73de5defd870be63fea93ec3acdd3ae6c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sat, 17 Oct 2026 01:40:44 +0000
Subject: [PATCH 07/87] build: compatibility date 2026-09-01

The date was 2024-06-28. 2026-09-01 is also the date of mkfifo.com, and workerd 1.20260926 has it. At this date nodejs_compat is on by default; the flag stays, so that the file tells it. In wrangler pages dev at this date, with no flag, PUT, GET and the list of memory and of crypt over memory work. workerd still refuses a null IV for AES-ECB, so aes.js keeps the empty IV.
---
 wrangler.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/wrangler.toml b/wrangler.toml
index 2d7af32..f8c3453 100644
--- a/wrangler.toml
+++ b/wrangler.toml
@@ -1,3 +1,3 @@
 name = "denoclr"
-compatibility_date = "2024-06-28"
+compatibility_date = "2026-09-01"
 compatibility_flags = [ "nodejs_compat" ]

From fb45d86ae6bbea84d7db9a5b9e7f984ffed6d6a6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sat, 17 Oct 2026 01:55:56 +0000
Subject: [PATCH 08/87] refactor: own code in place of @std/fmt, @std/ini and
 @std/media-types

These three packages came from JSR through npm:@jsr aliases and the .npmrc of this repository, so a different project could not install rfetch. Now small modules of rfetch do the work, with the APIs of the web and of Node.js, and .npmrc goes away:

- lib/format.js: formatBytes and formatDuration give the text of @std/fmt for the options of rfetch (no difference in 160,103 cases), but with KiB in place of kiB, the symbol of IEC, as rclone writes it.
- lib/ini.js: parse and stringify in the format of the configuration file of rclone: [name], key = value, and an empty line between sections. @std/ini 0.225 did not use the options section and whitespace that cmd/config gave it. Two sections with the same name become one, as in rclone, and a name such as __proto__ does not change the prototype.
- lib/mime.js: mimeType as MimeTypeFromName of rclone: the table of Go, the types that rclone adds, and .txt. An unknown extension gives application/octet-stream, as in rclone, in place of an empty Content-Type.

The new tests of lib pass.
---
 .npmrc                     |  1 -
 backend/crypt/main.js      |  7 ++--
 backend/crypt/main_test.js |  6 +--
 backend/drive/main.js      |  2 +-
 backend/http/main.js       |  2 +-
 backend/local/main.js      |  8 ++--
 backend/local/main_test.js | 12 +++---
 backend/memory/main.js     |  9 ++--
 cmd/config/main.js         |  7 +---
 lib/format.js              | 84 +++++++++++++++++++++++++++++++++++++
 lib/format_test.js         | 34 +++++++++++++++
 lib/ini.js                 | 86 ++++++++++++++++++++++++++++++++++++++
 lib/ini_test.js            | 62 +++++++++++++++++++++++++++
 lib/mime.js                | 75 +++++++++++++++++++++++++++++++++
 lib/mime_test.js           | 19 +++++++++
 lib/streams/progress.js    |  7 ++--
 package-lock.json          | 21 ----------
 package.json               |  3 --
 18 files changed, 385 insertions(+), 60 deletions(-)
 delete mode 100644 .npmrc
 create mode 100644 lib/format.js
 create mode 100644 lib/format_test.js
 create mode 100644 lib/ini.js
 create mode 100644 lib/ini_test.js
 create mode 100644 lib/mime.js
 create mode 100644 lib/mime_test.js

diff --git a/.npmrc b/.npmrc
deleted file mode 100644
index 41583e3..0000000
--- a/.npmrc
+++ /dev/null
@@ -1 +0,0 @@
-@jsr:registry=https://npm.jsr.io
diff --git a/backend/crypt/main.js b/backend/crypt/main.js
index e119bb2..b12f192 100644
--- a/backend/crypt/main.js
+++ b/backend/crypt/main.js
@@ -93,10 +93,9 @@
  * - 1049120 bytes total (a 0.05% overhead). This is the overhead for big files.
  */
 
-import { extname } from "node:path";
 import { scryptAsync as scrypt } from "@noble/hashes/scrypt";
 import { HTMLRewriter } from "@sntran/html-rewriter";
-import { contentType } from "@std/media-types";
+import { mimeType } from "../../lib/mime.js";
 import { fetch } from "../../mod.js";
 import { reveal } from "../../cmd/obscure/main.js";
 import PathCipher from "./PathCipher.js";
@@ -186,7 +185,7 @@ async function crypt(request) {
   let { status, statusText, headers, body } = response;
   headers = new Headers(headers);
 
-  const mimetype = contentType(extname(pathname)) || "";
+  const mimetype = mimeType(pathname);
   if (mimetype) {
     headers.set("Content-Type", mimetype);
   }
@@ -217,7 +216,7 @@ async function crypt(request) {
           }
 
           if (type) {
-            type = contentType(extname(basename)) || type;
+            type = mimeType(basename);
             element.setAttribute("type", type);
           }
         },
diff --git a/backend/crypt/main_test.js b/backend/crypt/main_test.js
index e1b1d02..a4d5b73 100644
--- a/backend/crypt/main_test.js
+++ b/backend/crypt/main_test.js
@@ -1,8 +1,8 @@
 import { test } from "node:test";
 import { readFile } from "node:fs/promises";
 import { Buffer } from "node:buffer";
-import { extname, join } from "node:path";
-import { contentType } from "@std/media-types";
+import { join } from "node:path";
+import { mimeType } from "../../lib/mime.js";
 import assert from "node:assert/strict";
 import fc from "fast-check";
 
@@ -118,7 +118,7 @@ test("GET", async (t) => {
       assert.deepEqual(size, originalFile.byteLength);
 
       const type = response.headers.get("Content-Type");
-      assert.deepEqual(type, contentType(extname(originalFilename)));
+      assert.deepEqual(type, mimeType(originalFilename));
 
       response.body?.cancel();
     }
diff --git a/backend/drive/main.js b/backend/drive/main.js
index ff9b2f3..ed5bd2d 100644
--- a/backend/drive/main.js
+++ b/backend/drive/main.js
@@ -1,4 +1,4 @@
-import { format as formatBytes } from "@std/fmt/bytes";
+import { formatBytes } from "../../lib/format.js";
 
 import { auth } from "./auth.js";
 import { list } from "./list.js";
diff --git a/backend/http/main.js b/backend/http/main.js
index b5bcb01..cd7d4b9 100644
--- a/backend/http/main.js
+++ b/backend/http/main.js
@@ -25,7 +25,7 @@
  */
 
 import { HTMLRewriter } from "@sntran/html-rewriter";
-import { format as formatBytes } from "@std/fmt/bytes";
+import { formatBytes } from "../../lib/format.js";
 import { toLocaleISOString } from "../../lib/time.js";
 
 export const options = {
diff --git a/backend/local/main.js b/backend/local/main.js
index cab77f7..1258a3c 100644
--- a/backend/local/main.js
+++ b/backend/local/main.js
@@ -1,7 +1,7 @@
 import process from "node:process";
-import { extname, join } from "node:path";
-import { format as formatBytes } from "@std/fmt/bytes";
-import { contentType } from "@std/media-types";
+import { join } from "node:path";
+import { formatBytes } from "../../lib/format.js";
+import { mimeType } from "../../lib/mime.js";
 
 /**
  * Serves a local remote
@@ -112,7 +112,7 @@ async function local(request) {
 
       headers.set("Content-Type", "text/html;charset=utf-8");
     } else {
-      headers.append("Content-Type", contentType(extname(pathname)) || "");
+      headers.append("Content-Type", mimeType(pathname));
       headers.append("Content-Length", stats.size.toString());
 
       if (method === "GET") {
diff --git a/backend/local/main_test.js b/backend/local/main_test.js
index 9f7adf6..99aaa86 100644
--- a/backend/local/main_test.js
+++ b/backend/local/main_test.js
@@ -1,8 +1,8 @@
 import { test } from "node:test";
 import process from "node:process";
 import { readdir, readFile, stat } from "node:fs/promises";
-import { extname, join } from "node:path";
-import { contentType } from "@std/media-types";
+import { join } from "node:path";
+import { mimeType } from "../../lib/mime.js";
 import assert from "node:assert/strict";
 
 import backend from "./main.js";
@@ -63,7 +63,7 @@ test("GET", async (t) => {
 
       assert.equal(
         headers.get("Content-Type"),
-        contentType(extname(name)) || "",
+        mimeType(name),
       );
       assert.equal(headers.get("Content-Length"), `${file.size}`);
       assert.equal(
@@ -97,8 +97,7 @@ test("PUT", async (t) => {
     const request = new Request(url, {
       method: "PUT",
       headers: {
-        "Content-Type": contentType(extname(newFile)) ||
-          "application/octet-stream",
+        "Content-Type": mimeType(newFile),
         "Content-Length": `${encoder.encode(body).byteLength}`,
       },
       body,
@@ -153,8 +152,7 @@ test("PUT", async (t) => {
     const request = new Request(url, {
       method: "PUT",
       headers: {
-        "Content-Type": contentType(extname(newFile)) ||
-          "application/octet-stream",
+        "Content-Type": mimeType(newFile),
         "Content-Length": `${encoder.encode(body).byteLength}`,
       },
       body,
diff --git a/backend/memory/main.js b/backend/memory/main.js
index a18b952..4b60962 100644
--- a/backend/memory/main.js
+++ b/backend/memory/main.js
@@ -7,9 +7,8 @@
  * Because it has no parameters you can just use it with the `:memory:` remote
  * name.
  */
-import { extname } from "node:path";
-import { format as formatBytes } from "@std/fmt/bytes";
-import { contentType } from "@std/media-types";
+import { formatBytes } from "../../lib/format.js";
+import { mimeType } from "../../lib/mime.js";
 
 /**
  * @type {Map<string, File | null>}
@@ -87,9 +86,7 @@ async function memory(request) {
                 filePath += "/";
               }
 
-              const type = isDirectory
-                ? ""
-                : contentType(extname(pathname)) || "";
+              const type = isDirectory ? "" : mimeType(pathname);
               const size = Number(isDirectory ? "-1" : value.size);
               const lastModified = value?.lastModified
                 ? new Date(value?.lastModified)
diff --git a/cmd/config/main.js b/cmd/config/main.js
index 9c9af68..05762e9 100644
--- a/cmd/config/main.js
+++ b/cmd/config/main.js
@@ -1,7 +1,7 @@
 import { env } from "node:process";
 
 import { join } from "node:path";
-import * as INI from "@std/ini";
+import * as INI from "../../lib/ini.js";
 
 const NAME_REGEX = /^[\w.][\w.\s-]*$/;
 
@@ -65,10 +65,7 @@ export async function config(subcommand, name, options, init) {
    * @type {Object}
    */
   let config = INI.parse(ini);
-  const encodeOptions = {
-    section: "",
-    whitespace: true,
-  };
+  const encodeOptions = { section: "" };
 
   switch (subcommand) {
     case "create": { // Create a new remote with name, type and options.
diff --git a/lib/format.js b/lib/format.js
new file mode 100644
index 0000000..85e48be
--- /dev/null
+++ b/lib/format.js
@@ -0,0 +1,84 @@
+/**
+ * Formats of numbers for people: a size in bytes and a duration.
+ *
+ * They give the same text as `format` of `@std/fmt/bytes` and of
+ * `@std/fmt/duration` for the options that rfetch uses, but with `KiB` in
+ * place of `kiB`: the symbol of IEC 80000-13, as rclone writes it.
+ */
+
+/** The first letters of the units above the byte. */
+const PREFIXES = "kMGTPEZY";
+
+/**
+ * Formats a size in bytes, for example `1.5 kB`, or `1.46 KiB` with `binary`.
+ * The number has 3 significant digits, and a size of less than 1 byte has no
+ * unit prefix.
+ * @param {number} bytes
+ * @param {{ binary?: boolean, locale?: boolean }} [options] `binary` uses
+ *   units of 1024 (KiB, MiB, ...) in place of 1000 (kB, MB, ...). `locale`
+ *   writes the number in the format of the locale of the runtime.
+ * @returns {string}
+ */
+export function formatBytes(bytes, { binary = false, locale = false } = {}) {
+  if (!Number.isFinite(bytes)) {
+    throw new TypeError(
+      `Expected a finite number, got ${typeof bytes}: ${bytes}`,
+    );
+  }
+  const sign = bytes < 0 ? "-" : "";
+  let value = Math.abs(bytes);
+  const text = (number) => locale ? number.toLocaleString() : number.toString();
+  if (value < 1) {
+    return `${sign}${text(value)} B`;
+  }
+
+  const exponent = Math.min(
+    Math.floor(
+      binary ? Math.log(value) / Math.log(1024) : Math.log10(value) / 3,
+    ),
+    PREFIXES.length,
+  );
+  value /= Math.pow(binary ? 1024 : 1000, exponent);
+  const number = text(Number(value.toPrecision(3)));
+  return `${sign}${number} ${unit(exponent, binary)}`;
+}
+
+/**
+ * Gives the unit of a power of 1000 or of 1024: B, kB, MB, ... or B, KiB,
+ * MiB, ...
+ * @param {number} exponent
+ * @param {boolean} binary
+ * @returns {string}
+ */
+function unit(exponent, binary) {
+  if (exponent === 0) {
+    return "B";
+  }
+  const prefix = PREFIXES[exponent - 1];
+  return binary ? `${prefix === "k" ? "K" : prefix}iB` : `${prefix}B`;
+}
+
+/**
+ * Formats a duration in milliseconds with the units that are not zero, from
+ * days to nanoseconds, for example `1m 5s 300ms`.
+ * @param {number} milliseconds
+ * @returns {string}
+ */
+export function formatDuration(milliseconds) {
+  const ms = Math.abs(milliseconds);
+  // The digits of the microseconds and of the nanoseconds.
+  const fraction = ms.toFixed(7).slice(-7, -1);
+  const parts = [
+    [Math.trunc(ms / 86400000), "d"],
+    [Math.trunc(ms / 3600000) % 24, "h"],
+    [Math.trunc(ms / 60000) % 60, "m"],
+    [Math.trunc(ms / 1000) % 60, "s"],
+    [Math.trunc(ms) % 1000, "ms"],
+    [Number(fraction.slice(0, 3)), "µs"],
+    [Number(fraction.slice(3, 6)), "ns"],
+  ];
+  return parts.filter(([value]) => value).map(([value, unit]) =>
+    `${value}${unit}`
+  )
+    .join(" ");
+}
diff --git a/lib/format_test.js b/lib/format_test.js
new file mode 100644
index 0000000..7dd5d78
--- /dev/null
+++ b/lib/format_test.js
@@ -0,0 +1,34 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+
+import { formatBytes, formatDuration } from "./format.js";
+
+// The texts of `format` of @std/fmt 0.225, which these functions replace.
+test("formatBytes", () => {
+  const cases = [
+    [0, {}, "0 B"],
+    [0.5, {}, "0.5 B"],
+    [999, {}, "999 B"],
+    [1000, {}, "1 kB"],
+    [1536, {}, "1.54 kB"],
+    [1536, { binary: true }, "1.5 KiB"],
+    [1048576, { binary: true }, "1 MiB"],
+    [123456789, {}, "123 MB"],
+    [2 ** 40, { binary: true }, "1 TiB"],
+    [1e30, {}, "1000000 YB"],
+    [-1536, { binary: true }, "-1.5 KiB"],
+    [1234567, { locale: true }, `${(1.23).toLocaleString()} MB`],
+  ];
+  for (const [bytes, options, text] of cases) {
+    assert.equal(formatBytes(bytes, options), text, `${bytes}`);
+  }
+  assert.throws(() => formatBytes(Infinity), TypeError);
+});
+
+test("formatDuration", () => {
+  assert.equal(formatDuration(0), "");
+  assert.equal(formatDuration(61000), "1m 1s");
+  assert.equal(formatDuration(90061001.5), "1d 1h 1m 1s 1ms 500µs");
+  assert.equal(formatDuration(0.000001), "1ns");
+  assert.equal(formatDuration(-3600000), "1h");
+});
diff --git a/lib/ini.js b/lib/ini.js
new file mode 100644
index 0000000..55a8517
--- /dev/null
+++ b/lib/ini.js
@@ -0,0 +1,86 @@
+/**
+ * The INI format of the configuration file of rclone:
+ *
+ * ```ini
+ * [remote]
+ * type = s3
+ * provider = Cloudflare
+ *
+ * [secret]
+ * type = crypt
+ * remote = remote:bucket
+ * ```
+ *
+ * A `[name]` line starts a section, and each `key = value` line is a string
+ * in the current section. A line that starts with `#` or `;` is a comment.
+ */
+
+/**
+ * Reads the text of a configuration file. The keys before the first section
+ * are at the top level. Two sections with the same name become one, as in
+ * rclone.
+ * @param {string} text
+ * @returns {Record<string, string | Record<string, string>>}
+ */
+export function parse(text) {
+  /** @type {Map<string, string | Map<string, string>>} */
+  const config = new Map();
+  let section = config;
+  for (const [index, line] of text.split(/\r?\n/).entries()) {
+    const content = line.trim();
+    if (content === "" || content.startsWith("#") || content.startsWith(";")) {
+      continue;
+    }
+    const name = /^\[(.*)\]$/.exec(content)?.[1];
+    if (name !== undefined) {
+      if (!(config.get(name) instanceof Map)) {
+        config.set(name, new Map());
+      }
+      section = config.get(name);
+      continue;
+    }
+    const equal = content.indexOf("=");
+    if (equal === -1) {
+      throw new SyntaxError(`INI: line ${index + 1} has no "=": ${content}`);
+    }
+    section.set(
+      content.slice(0, equal).trim(),
+      content.slice(equal + 1).trim(),
+    );
+  }
+  // Object.fromEntries makes own properties, so a name such as "__proto__"
+  // does not change the prototype.
+  return Object.fromEntries(
+    [...config].map((
+      [key, value],
+    ) => [key, value instanceof Map ? Object.fromEntries(value) : value]),
+  );
+}
+
+/**
+ * Writes a configuration file: first the keys at the top level, then each
+ * section, with an empty line between the sections, as rclone writes them.
+ * A key with no value (undefined or null) is not written.
+ * @param {Record<string, unknown>} config
+ * @param {{ section?: string }} [options] With a `section`, `config` is the
+ *   keys of that one section.
+ * @returns {string}
+ */
+export function stringify(config, { section } = {}) {
+  if (section) {
+    return stringify({ [section]: config });
+  }
+  const isSection = (value) => typeof value === "object" && value !== null;
+  const lines = (entries) =>
+    entries
+      .filter(([, value]) => value !== undefined && value !== null)
+      .map(([key, value]) => `${key} = ${value}`);
+
+  const entries = Object.entries(config);
+  const blocks = [lines(entries.filter(([, value]) => !isSection(value)))];
+  for (const [name, keys] of entries.filter(([, value]) => isSection(value))) {
+    blocks.push([`[${name}]`, ...lines(Object.entries(keys))]);
+  }
+  return blocks.filter((block) => block.length).map((block) => block.join("\n"))
+    .join("\n\n");
+}
diff --git a/lib/ini_test.js b/lib/ini_test.js
new file mode 100644
index 0000000..7f89e00
--- /dev/null
+++ b/lib/ini_test.js
@@ -0,0 +1,62 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import fc from "fast-check";
+
+import { parse, stringify } from "./ini.js";
+
+test("parse", () => {
+  assert.deepEqual(parse(""), {});
+  assert.deepEqual(
+    parse(
+      "top = 1\n[a]\ntype = s3\n  spaced key  =   a value  \nurl=https://x/?a=b\n" +
+        "; a comment\n# a comment\n\n[b c]\nempty =\n",
+    ),
+    {
+      top: "1",
+      a: { type: "s3", "spaced key": "a value", url: "https://x/?a=b" },
+      "b c": { empty: "" },
+    },
+  );
+  // Two sections with the same name become one, as in rclone.
+  assert.deepEqual(parse("[a]\nx = 1\n[a]\ny = 2\r\n"), {
+    a: { x: "1", y: "2" },
+  });
+  assert.throws(() => parse("[a]\nno equal sign"), {
+    name: "SyntaxError",
+    message: 'INI: line 2 has no "=": no equal sign',
+  });
+});
+
+test("parse does not change the prototype", () => {
+  const config = parse("[__proto__]\npolluted = yes\n");
+  assert.deepEqual(Object.keys(config), ["__proto__"]);
+  assert.equal({}.polluted, undefined);
+});
+
+test("stringify writes the format of rclone", () => {
+  const config = { a: { type: "s3", key: "v=1" }, b: { type: "local" } };
+  assert.equal(
+    stringify(config),
+    "[a]\ntype = s3\nkey = v=1\n\n[b]\ntype = local",
+  );
+  assert.equal(stringify(config, { section: "" }), stringify(config));
+  assert.equal(stringify(config.b, { section: "b" }), "[b]\ntype = local");
+  assert.equal(stringify({ top: "1", a: { x: "2" } }), "top = 1\n\n[a]\nx = 2");
+  assert.equal(stringify({ a: { x: undefined, y: null, z: 0 } }), "[a]\nz = 0");
+  assert.equal(stringify({}), "");
+});
+
+test("parse reads what stringify writes", () => {
+  const word = fc.stringMatching(/^[\w.][\w. -]*[\w.]$/);
+  const value = fc.stringMatching(/^\S(.*\S)?$/).filter((v) =>
+    !/[\r\n]/.test(v)
+  );
+  fc.assert(
+    fc.property(
+      fc.dictionary(word, fc.dictionary(word, value), { minKeys: 1 }),
+      (config) => {
+        assert.deepEqual(parse(stringify(config)), config);
+      },
+    ),
+  );
+});
diff --git a/lib/mime.js b/lib/mime.js
new file mode 100644
index 0000000..64f387e
--- /dev/null
+++ b/lib/mime.js
@@ -0,0 +1,75 @@
+/**
+ * The media type of a file from its name, as `MimeTypeFromName` of rclone:
+ * the built-in table of the `mime` package of Go, the types that rclone adds
+ * (fs/mimetype.go of rclone 1.75.1), and `text/plain` for `.txt`, as the
+ * `mime.types` file of most systems gives it.
+ */
+
+/** The types for each extension, in lowercase. */
+const TYPES = {
+  // The built-in table of Go.
+  ".avif": "image/avif",
+  ".css": "text/css; charset=utf-8",
+  ".gif": "image/gif",
+  ".htm": "text/html; charset=utf-8",
+  ".html": "text/html; charset=utf-8",
+  ".jpeg": "image/jpeg",
+  ".jpg": "image/jpeg",
+  ".js": "text/javascript; charset=utf-8",
+  ".json": "application/json",
+  ".mjs": "text/javascript; charset=utf-8",
+  ".pdf": "application/pdf",
+  ".png": "image/png",
+  ".svg": "image/svg+xml",
+  ".wasm": "application/wasm",
+  ".webp": "image/webp",
+  ".xml": "text/xml; charset=utf-8",
+  // The types that rclone adds.
+  ".flac": "audio/flac",
+  ".mpga": "audio/mpeg",
+  ".mpega": "audio/mpeg",
+  ".mp2": "audio/mpeg",
+  ".mp3": "audio/mpeg",
+  ".m4a": "audio/mpeg",
+  ".oga": "audio/ogg",
+  ".ogg": "audio/ogg",
+  ".opus": "audio/ogg",
+  ".spx": "audio/ogg",
+  ".wav": "audio/x-wav",
+  ".tiff": "image/tiff",
+  ".tif": "image/tiff",
+  ".dif": "video/dv",
+  ".dv": "video/dv",
+  ".fli": "video/fli",
+  ".mpeg": "video/mpeg",
+  ".mpg": "video/mpeg",
+  ".mpe": "video/mpeg",
+  ".ts": "video/MP2T",
+  ".mp4": "video/mp4",
+  ".qt": "video/quicktime",
+  ".mov": "video/quicktime",
+  ".ogv": "video/ogg",
+  ".webm": "video/webm",
+  ".avi": "video/x-msvideo",
+  ".mpv": "video/x-matroska",
+  ".mkv": "video/x-matroska",
+  ".srt": "application/x-subrip",
+  // The type of most systems.
+  ".txt": "text/plain; charset=utf-8",
+};
+
+/**
+ * Gives the media type of a file from the extension of its name, or
+ * `application/octet-stream` for an unknown extension. The extension can be
+ * in each case: `A.PNG` is an image.
+ * @param {string} name A name or a path of a file.
+ * @returns {string}
+ */
+export function mimeType(name) {
+  const base = name.slice(name.lastIndexOf("/") + 1);
+  const dot = base.lastIndexOf(".");
+  const extension = dot === -1 ? "" : base.slice(dot).toLowerCase();
+  return Object.hasOwn(TYPES, extension)
+    ? TYPES[extension]
+    : "application/octet-stream";
+}
diff --git a/lib/mime_test.js b/lib/mime_test.js
new file mode 100644
index 0000000..0f38593
--- /dev/null
+++ b/lib/mime_test.js
@@ -0,0 +1,19 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+
+import { mimeType } from "./mime.js";
+
+test("mimeType", () => {
+  // The table of Go, the additions of rclone, and .txt.
+  assert.equal(mimeType("index.html"), "text/html; charset=utf-8");
+  assert.equal(mimeType("photo.JPG"), "image/jpeg");
+  assert.equal(mimeType("a/b.c/song.mp3"), "audio/mpeg");
+  assert.equal(mimeType("movie.mkv"), "video/x-matroska");
+  assert.equal(mimeType("hello.txt"), "text/plain; charset=utf-8");
+  // An unknown extension, no extension, and a dot in a folder only.
+  for (
+    const name of ["1MB.bin", "README", "a.b/c", "toString", ".constructor"]
+  ) {
+    assert.equal(mimeType(name), "application/octet-stream", name);
+  }
+});
diff --git a/lib/streams/progress.js b/lib/streams/progress.js
index 1b8d5fe..8b4a078 100644
--- a/lib/streams/progress.js
+++ b/lib/streams/progress.js
@@ -1,5 +1,4 @@
-import { format as formatBytes } from "@std/fmt/bytes";
-import { format as formatDuration } from "@std/fmt/duration";
+import { formatBytes, formatDuration } from "../format.js";
 
 export class Progress extends TransformStream {
   completed = 0;
@@ -49,7 +48,7 @@ export class Progress extends TransformStream {
   }
 
   get etah() {
-    return formatDuration(this.eta * 1000, { ignoreZero: true });
+    return formatDuration(this.eta * 1000);
   }
 
   get rateh() {
@@ -57,7 +56,7 @@ export class Progress extends TransformStream {
   }
 
   get timeh() {
-    return formatDuration(this.time * 1000, { ignoreZero: true });
+    return formatDuration(this.time * 1000);
   }
 
   get totalh() {
diff --git a/package-lock.json b/package-lock.json
index 401b78a..244f5db 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -13,9 +13,6 @@
         "@noble/hashes": "^1.4.0",
         "@sntran/html-rewriter": "^0.2.0",
         "@sntran/serve": "^0.0.1",
-        "@std/fmt": "npm:@jsr/std__fmt@^0.225.4",
-        "@std/ini": "npm:@jsr/std__ini@^0.225.1",
-        "@std/media-types": "npm:@jsr/std__media-types@^1.0.0-rc.1",
         "base32-decode": "^1.0.0",
         "base32-encode": "^2.0.0"
       },
@@ -61,24 +58,6 @@
       "resolved": "https://registry.npmjs.org/@sntran/serve/-/serve-0.0.1.tgz",
       "integrity": "sha512-yejSB/mTWeRg7fK++lLZcz5Av407HZ7VN4l84FxxpCoERpGRL1fP43wNeRC4xeup7xPtnHXsjinxz6xEByglNA=="
     },
-    "node_modules/@std/fmt": {
-      "name": "@jsr/std__fmt",
-      "version": "0.225.4",
-      "resolved": "https://npm.jsr.io/~/11/@jsr/std__fmt/0.225.4.tgz",
-      "integrity": "sha512-lb8QcV3YnAu3GsrG7wd51Fb56RxOBp4szMRS/TCLnQptmF0Rd0v8ksQeTHmGkuD6MY/V8gEy/Sj0qulRvR9lqQ=="
-    },
-    "node_modules/@std/ini": {
-      "name": "@jsr/std__ini",
-      "version": "0.225.1",
-      "resolved": "https://npm.jsr.io/~/11/@jsr/std__ini/0.225.1.tgz",
-      "integrity": "sha512-K23bS0WRbZ2riDg9jQMnaJW4uW/KaQpFJZRmv8cGDL+7JhmMkI+yC3wm8zGxctggPR1+pxIXH0WmK44CbGkORQ=="
-    },
-    "node_modules/@std/media-types": {
-      "name": "@jsr/std__media-types",
-      "version": "1.0.0-rc.1",
-      "resolved": "https://npm.jsr.io/~/11/@jsr/std__media-types/1.0.0-rc.1.tgz",
-      "integrity": "sha512-0UdhqMLempJi8rHXJ4xSsRs79gMIm+X8/jAcBxUa9sdbsRALM148t/c2JIRWN4S58LQVBRHNK3WYd/YgR4fLNA=="
-    },
     "node_modules/base32-decode": {
       "version": "1.0.0",
       "resolved": "https://registry.npmjs.org/base32-decode/-/base32-decode-1.0.0.tgz",
diff --git a/package.json b/package.json
index 2b168fd..4224964 100644
--- a/package.json
+++ b/package.json
@@ -31,9 +31,6 @@
     "@noble/hashes": "^1.4.0",
     "@sntran/html-rewriter": "^0.2.0",
     "@sntran/serve": "^0.0.1",
-    "@std/fmt": "npm:@jsr/std__fmt@^0.225.4",
-    "@std/ini": "npm:@jsr/std__ini@^0.225.1",
-    "@std/media-types": "npm:@jsr/std__media-types@^1.0.0-rc.1",
     "base32-decode": "^1.0.0",
     "base32-encode": "^2.0.0"
   },

From 4eda7400ae6b7e79ece6e1212ca5afa34d75473d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sat, 17 Oct 2026 01:55:56 +0000
Subject: [PATCH 09/87] fix(config): the default file of rclone when no file
 exists

With no configuration file, config file gave an empty path, and create wrote nowhere. Now the file is the default file of rclone, CONFIG_DIR/rclone/rclone.conf, as the test expects. With the new INI module, the 7 tests of cmd/config pass.
---
 cmd/config/main.js | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/cmd/config/main.js b/cmd/config/main.js
index 05762e9..ef9fc66 100644
--- a/cmd/config/main.js
+++ b/cmd/config/main.js
@@ -41,7 +41,6 @@ const NAME_REGEX = /^[\w.][\w.\s-]*$/;
 export async function config(subcommand, name, options, init) {
   const { readFile, writeFile } = await import("node:fs/promises");
 
-  let file = "", ini = "";
   // Order as specified at https://rclone.org/docs/#config-config-file.
   const PATHS = [
     "rfetch.conf",
@@ -51,6 +50,8 @@ export async function config(subcommand, name, options, init) {
     join(config_dir(), "rclone", "rclone.conf"),
     join(env["HOME"], ".rclone.conf"),
   ];
+  // With no file, the file is the default file of rclone.
+  let file = PATHS[4], ini = "";
   for await (const path of PATHS) {
     try {
       ini = await readFile(path, { encoding: "utf8" });

From 48f4bda0009ce00b450c4cda87326963fa1da6e1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sat, 17 Oct 2026 01:56:50 +0000
Subject: [PATCH 10/87] build: wrangler.toml is the configuration of the Pages
 project rfetch

pages_build_output_dir makes this file the configuration of the deploys from Git and of wrangler pages dev, in place of the settings of the dashboard. The output is the repository root, with _worker.js. The name is rfetch: denoclr was the earlier name, rcloned in reverse, with Deno in it.
---
 wrangler.toml | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/wrangler.toml b/wrangler.toml
index f8c3453..6f96998 100644
--- a/wrangler.toml
+++ b/wrangler.toml
@@ -1,3 +1,7 @@
-name = "denoclr"
+name = "rfetch"
+# This file is the configuration of the Pages project: the deploys from Git
+# and `wrangler pages dev` read it. The repository root, with _worker.js, is
+# the output of the build.
+pages_build_output_dir = "."
 compatibility_date = "2026-09-01"
 compatibility_flags = [ "nodejs_compat" ]

From 4ca38535b7d86d4b1c78dbcd4a2aab763811f6f1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sat, 17 Oct 2026 02:11:45 +0000
Subject: [PATCH 11/87] feat(lib): decodePath and escapeHTML for the backends

decodePath gives the path of a URL with no percent-encoding. It gives null for a path that can go out of the root, for example /..%2Fsecret.txt, which the URL parser keeps.

escapeHTML puts a character reference in place of each character that has a meaning in HTML.
---
 lib/html.js      | 19 ++++++++++++++
 lib/html_test.js | 17 +++++++++++++
 lib/path.js      | 36 +++++++++++++++++++++++++++
 lib/path_test.js | 64 ++++++++++++++++++++++++++++++++++++++++++++++++
 4 files changed, 136 insertions(+)
 create mode 100644 lib/html.js
 create mode 100644 lib/html_test.js
 create mode 100644 lib/path.js
 create mode 100644 lib/path_test.js

diff --git a/lib/html.js b/lib/html.js
new file mode 100644
index 0000000..0eb6bd4
--- /dev/null
+++ b/lib/html.js
@@ -0,0 +1,19 @@
+/** The characters that have a meaning in HTML, and their references. */
+const REFERENCES = {
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&#39;",
+};
+
+/**
+ * Puts a character reference in place of each character of the text that has
+ * a meaning in HTML. The result is safe as the text of an element, and as the
+ * value of an attribute in quotes.
+ * @param {string} text
+ * @returns {string}
+ */
+export function escapeHTML(text) {
+  return String(text).replace(/[&<>"']/g, (character) => REFERENCES[character]);
+}
diff --git a/lib/html_test.js b/lib/html_test.js
new file mode 100644
index 0000000..cc1cb19
--- /dev/null
+++ b/lib/html_test.js
@@ -0,0 +1,17 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+
+import { escapeHTML } from "./html.js";
+
+test("escapeHTML", async (t) => {
+  await t.test("puts a reference for each character of HTML", () => {
+    assert.equal(
+      escapeHTML(`<a href="x">Tom & Jerry's</a>`),
+      "&lt;a href=&quot;x&quot;&gt;Tom &amp; Jerry&#39;s&lt;/a&gt;",
+    );
+  });
+
+  await t.test("does not change other text", () => {
+    assert.equal(escapeHTML("Hello, 世界 ≠ ?+#"), "Hello, 世界 ≠ ?+#");
+  });
+});
diff --git a/lib/path.js b/lib/path.js
new file mode 100644
index 0000000..16c04bf
--- /dev/null
+++ b/lib/path.js
@@ -0,0 +1,36 @@
+/**
+ * Gives the path of a URL with no percent-encoding, for a backend to use as
+ * the path of a file or a folder. The path keeps its `/` at the start, and at
+ * the end for a folder.
+ *
+ * It gives null when the path is not safe: when a name has bad
+ * percent-encoding, or when a name is empty, is `.` or `..`, or has a `/` or a
+ * NUL character after the decoding. The URL parser removes the segments `.`
+ * and `..`, but it keeps `..%2F`, which becomes `../` after the decoding. Thus
+ * a backend that uses only the result of this function cannot go out of its
+ * root folder.
+ * @param {string} pathname The path of a URL, for example `/a%20b/c.txt`.
+ * @returns {string | null} The path, for example `/a b/c.txt`, or null.
+ */
+export function decodePath(pathname) {
+  if (!pathname.startsWith("/")) return null;
+
+  const names = pathname.slice(1).split("/");
+  // The path of a folder ends with "/", thus its last name is empty.
+  const last = names.length - 1;
+  for (let i = 0; i < names.length; i++) {
+    let name;
+    try {
+      name = decodeURIComponent(names[i]);
+    } catch {
+      return null;
+    }
+    if (name === "" && i === last) continue;
+    if (name === "" || name === "." || name === ".." || /[/\0]/.test(name)) {
+      return null;
+    }
+    names[i] = name;
+  }
+
+  return `/${names.join("/")}`;
+}
diff --git a/lib/path_test.js b/lib/path_test.js
new file mode 100644
index 0000000..5889dd7
--- /dev/null
+++ b/lib/path_test.js
@@ -0,0 +1,64 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import fc from "fast-check";
+
+import { decodePath } from "./path.js";
+
+test("decodePath", async (t) => {
+  await t.test("removes the percent-encoding of each name", () => {
+    assert.equal(decodePath("/"), "/");
+    assert.equal(decodePath("/a%20b/c.txt"), "/a b/c.txt");
+    assert.equal(decodePath("/a%20b/"), "/a b/");
+    assert.equal(decodePath("/%E4%B8%96%E7%95%8C"), "/世界");
+    assert.equal(decodePath("/a%3Fb%23c"), "/a?b#c");
+    assert.equal(decodePath("/test%2546.txt"), "/test%46.txt");
+  });
+
+  await t.test("gives the same name for each encoding of it", () => {
+    fc.assert(
+      fc.property(fc.string({ minLength: 1 }), (name) => {
+        fc.pre(!/[/\0]/.test(name) && name !== "." && name !== "..");
+        let encoded;
+        try {
+          encoded = encodeURIComponent(name);
+        } catch {
+          fc.pre(false); // A string with a lone surrogate has no encoding.
+        }
+        assert.equal(decodePath(`/${encoded}`), `/${name}`);
+        assert.equal(decodePath(`/${encoded}/`), `/${name}/`);
+      }),
+    );
+  });
+
+  await t.test("refuses a path that can go out of the root", () => {
+    for (
+      const pathname of [
+        "/..%2Fsecret.txt",
+        "/a/..%2F..%2Fsecret.txt",
+        "/%2E%2E%2Fsecret.txt",
+        "/..%2F",
+        "/%2E%2E",
+        "/.",
+        "/a/%2E/b",
+      ]
+    ) {
+      assert.equal(decodePath(pathname), null, pathname);
+    }
+  });
+
+  await t.test("refuses a path with a name that is not valid", () => {
+    for (
+      const pathname of [
+        "",
+        "a",
+        "//",
+        "/a//b",
+        "/a%2Fb",
+        "/a%00b",
+        "/%E0%A4%A",
+      ]
+    ) {
+      assert.equal(decodePath(pathname), null, pathname);
+    }
+  });
+});

From b95bcf4bbd704e0600627d6362d52f14f2cff28e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sat, 17 Oct 2026 02:11:45 +0000
Subject: [PATCH 12/87] test: a shared test suite for the backends, as fstests
 of rclone

backendSuite(name, backend) runs the same tests on each backend, in a new folder that it deletes at the end:

- 404 for a file or a folder that does not exist;
- PUT and DELETE of files and folders;
- the names of the test FsEncoding of rclone;
- a file of 0 bytes, and the two files of fstests;
- the list of each folder;
- the bytes and the headers of GET and HEAD.

remote() is a client of a backend in the same process. parseListing reads the HTML list of a folder.
---
 lib/testing/listing.js |  79 ++++++++++
 lib/testing/remote.js  |  68 ++++++++
 lib/testing/suite.js   | 343 +++++++++++++++++++++++++++++++++++++++++
 3 files changed, 490 insertions(+)
 create mode 100644 lib/testing/listing.js
 create mode 100644 lib/testing/remote.js
 create mode 100644 lib/testing/suite.js

diff --git a/lib/testing/listing.js b/lib/testing/listing.js
new file mode 100644
index 0000000..19fd68f
--- /dev/null
+++ b/lib/testing/listing.js
@@ -0,0 +1,79 @@
+import { HTMLRewriter } from "@sntran/html-rewriter";
+
+/**
+ * An entry of the list of a folder, with the names of `rclone lsjson`.
+ * @typedef {Object} Entry
+ * @property {string} Name The name, with no percent-encoding.
+ * @property {boolean} IsDir
+ * @property {number} Size The value of `<data>`, or -1 when there is none.
+ * @property {string} MimeType The `type` of the link, or "".
+ * @property {string} ModTime The `datetime` of `<time>`, or "".
+ */
+
+/**
+ * Reads the list of a folder from its HTML: the rows of a `<table>`, as
+ * CONTRIBUTING.md tells. In each row, `<a href>` is the link to the file or
+ * the folder, with a `/` at the end for a folder, `type` is the media type,
+ * `<data value>` is the size in bytes, and `<time datetime>` is the time of
+ * the last change.
+ *
+ * Only a link to a file or a folder directly in the folder makes an entry.
+ * Thus the row of the parent folder (`../`) is not an entry, and a name that
+ * has no percent-encoding for `?`, `#` or `/` gives a wrong entry.
+ * @param {Response} response
+ * @param {URL} base The URL of the folder.
+ * @returns {Promise<Entry[]>}
+ */
+export async function parseListing(response, base) {
+  /** @type {Entry[]} */
+  const entries = [];
+  /** @type {Entry | null} */
+  let entry = null;
+
+  await new HTMLRewriter()
+    .on("tr", {
+      element(element) {
+        entry = null;
+        element.onEndTag(() => {
+          if (entry) entries.push(entry);
+        });
+      },
+    })
+    .on("tr a[href]", {
+      element(element) {
+        const { origin, pathname } = new URL(
+          element.getAttribute("href"),
+          base,
+        );
+        if (origin !== base.origin || !pathname.startsWith(base.pathname)) {
+          return;
+        }
+        const rest = pathname.slice(base.pathname.length);
+        const isDir = rest.endsWith("/");
+        const name = isDir ? rest.slice(0, -1) : rest;
+        if (name === "" || name.includes("/")) return;
+
+        entry = {
+          Name: decodeURIComponent(name),
+          IsDir: isDir,
+          Size: -1,
+          MimeType: element.getAttribute("type") || "",
+          ModTime: "",
+        };
+      },
+    })
+    .on("tr data[value]", {
+      element(element) {
+        if (entry) entry.Size = Number(element.getAttribute("value"));
+      },
+    })
+    .on("tr time[datetime]", {
+      element(element) {
+        if (entry) entry.ModTime = element.getAttribute("datetime");
+      },
+    })
+    .transform(response)
+    .arrayBuffer();
+
+  return entries;
+}
diff --git a/lib/testing/remote.js b/lib/testing/remote.js
new file mode 100644
index 0000000..6f0b742
--- /dev/null
+++ b/lib/testing/remote.js
@@ -0,0 +1,68 @@
+import { parseListing } from "./listing.js";
+
+/** The origin of the URLs of the requests. A backend reads only the path. */
+const ORIGIN = "http://rfetch.test";
+
+/**
+ * A client of a backend in the same process, for the tests. A path is plain
+ * text, with `/` between the names and at the end of a folder. The client
+ * puts the percent-encoding in each name, and the parameters of the backend
+ * in the query.
+ * @param {{ fetch: (request: Request) => Response | Promise<Response> }} backend
+ * @param {{ params?: Record<string, string>, root?: string }} [options] `root`
+ *   is a folder, for example `/rfetch-test-abc/`, under which all paths go.
+ */
+export function remote(backend, { params = {}, root = "/" } = {}) {
+  /**
+   * Gives the URL of the path under the root.
+   * @param {string} path
+   * @returns {URL}
+   */
+  function url(path) {
+    const encoded = `${root}${path}`.split("/").map(encodeURIComponent)
+      .join("/");
+    const url = new URL(encoded, ORIGIN);
+    for (const [name, value] of Object.entries(params)) {
+      url.searchParams.set(name, value);
+    }
+    return url;
+  }
+
+  /**
+   * Sends a request to the backend.
+   * @param {string} path
+   * @param {RequestInit} [init]
+   * @returns {Promise<Response>}
+   */
+  async function send(path, init = {}) {
+    return await backend.fetch(
+      new Request(url(path), { duplex: "half", ...init }),
+    );
+  }
+
+  return {
+    url,
+    send,
+    /** @param {string} path @param {BodyInit} [body] @param {HeadersInit} [headers] */
+    put: (path, body = new Uint8Array(0), headers = {}) =>
+      send(path, { method: "PUT", body, headers }),
+    /** @param {string} path @param {HeadersInit} [headers] */
+    get: (path, headers = {}) => send(path, { headers }),
+    /** @param {string} path */
+    head: (path) => send(path, { method: "HEAD" }),
+    /** @param {string} path */
+    delete: (path) => send(path, { method: "DELETE" }),
+    /**
+     * Gives the entries of a folder, or throws with the status.
+     * @param {string} path A folder, with `/` at the end, or "" for the root.
+     */
+    async list(path) {
+      const response = await send(path);
+      if (!response.ok) {
+        await response.body?.cancel();
+        throw new Error(`GET ${JSON.stringify(path)} gave ${response.status}`);
+      }
+      return await parseListing(response, url(path));
+    },
+  };
+}
diff --git a/lib/testing/suite.js b/lib/testing/suite.js
new file mode 100644
index 0000000..3cde24e
--- /dev/null
+++ b/lib/testing/suite.js
@@ -0,0 +1,343 @@
+/**
+ * The tests that each backend must pass, as `fstests` of rclone
+ * (fstest/fstests/fstests.go). A test file of a backend calls
+ * `backendSuite(name, backend)` once. The tests run in order, and each test
+ * uses the files of the tests before it.
+ *
+ * The tests use a new folder `/rfetch-test-RANDOM/` and remove it at the end.
+ * They do not touch other files of the backend.
+ */
+import { after, describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { randomBytes } from "node:crypto";
+
+import { mimeType } from "../mime.js";
+import { remote } from "./remote.js";
+
+/**
+ * The names of `FsEncoding` of rclone that can be one name in the path of a
+ * URL. The names `.` and `..`, the names with a `/`, the name with all the
+ * control characters and the name with bad UTF-8 are not here: a URL or a
+ * string of JavaScript cannot have them as one name.
+ */
+const NAMES = [
+  " leading space",
+  "~leading tilde",
+  "\rleading CR",
+  "\nleading LF",
+  "\tleading HT",
+  "\vleading VT",
+  ".leading dot",
+  "trailing space ",
+  "trailing CR\r",
+  "trailing LF\n",
+  "trailing HT\t",
+  "trailing VT\v",
+  "trailing dot.",
+  "test%46.txt",
+  "!\"#$%&'()*+,-.:;<=>?@[\\]^_`{|}~",
+  "êé",
+  "Hello, 世界",
+];
+
+/** The two files of `fstests`: one at the root, and one in folders with hard names. */
+const FILE1 = "file name.txt";
+const FILE2 = `hello? sausage/êé/Hello, 世界/ " ' @ < > & ? + ≠/z.txt`;
+
+/**
+ * Runs the tests of a backend.
+ * @param {string} name The name of the backend, for the report.
+ * @param {{ fetch: (request: Request) => Response | Promise<Response> }} backend
+ * @param {{ params?: Record<string, string> }} [options] `params` go in the
+ *   query of each request, for example the options of the backend.
+ */
+export function backendSuite(name, backend, { params = {} } = {}) {
+  const root = `/rfetch-test-${randomBytes(6).toString("hex")}/`;
+  const fs = remote(backend, { params, root });
+
+  describe(`backend ${name}`, () => {
+    after(async () => {
+      // Removes what a test that failed did not remove.
+      const response = await fs.delete("");
+      await response.body?.cancel();
+    });
+
+    it("gives 404 for a folder that does not exist", async () => {
+      await expect(fs.get(""), 404);
+    });
+
+    it("makes a folder with PUT", async () => {
+      await put("", new Uint8Array(0));
+
+      const response = await fs.get("");
+      assert.equal(response.status, 200);
+      assert.match(response.headers.get("Content-Type"), /^text\/html\b/);
+      await response.body?.cancel();
+      assert.deepEqual(await fs.list(""), [], "a new folder is empty");
+    });
+
+    it("gives 404 for a file or a folder that does not exist", async () => {
+      await expect(fs.get("missing.txt"), 404);
+      await expect(fs.head("missing.txt"), 404);
+      await expect(fs.delete("missing.txt"), 404);
+      await expect(fs.get("missing/"), 404);
+      await expect(fs.delete("missing/"), 404);
+      await expect(fs.get("missing/missing.txt"), 404);
+    });
+
+    it("puts and gets a file of 0 bytes", async () => {
+      const start = Date.now();
+      await put("zero.txt", new Uint8Array(0));
+      const end = Date.now();
+
+      await assertFile("zero.txt", new Uint8Array(0), start, end);
+      await expect(fs.delete("zero.txt"), 204);
+      assert.deepEqual(await fs.list(""), []);
+    });
+
+    describe("names", () => {
+      for (const name of NAMES) {
+        it(`keeps the name ${JSON.stringify(name)}`, async () => {
+          // The name is a folder and a file in it.
+          const path = `${name}/${name}`;
+          const content = random(64);
+          const start = Date.now();
+          await put(path, content);
+          const end = Date.now();
+
+          assertEntries(await fs.list(""), [folder(name)]);
+          assertEntries(await fs.list(`${name}/`), [
+            file(name, content.length),
+          ]);
+          await assertFile(path, content, start, end);
+
+          await expect(fs.delete(`${name}/`), 204);
+          assertEntries(await fs.list(""), []);
+        });
+      }
+    });
+
+    describe("files", () => {
+      const files = [
+        { path: FILE1, content: random(100), start: 0, end: 0 },
+        // A file of more than one read of 64 KiB.
+        { path: FILE2, content: random(200 * 1024 + 1), start: 0, end: 0 },
+      ];
+      const [file1, file2] = files;
+
+      it("puts the files", async () => {
+        for (const file of files) {
+          file.start = Date.now();
+          await put(file.path, file.content);
+          file.end = Date.now();
+        }
+      });
+
+      it("lists each folder", async () => {
+        assertEntries(await fs.list(""), [
+          file(FILE1, file1.content.length),
+          folder("hello? sausage"),
+        ]);
+
+        // Each folder above z.txt has one folder, then z.txt.
+        const names = FILE2.split("/");
+        for (let i = 1; i < names.length; i++) {
+          const path = `${names.slice(0, i).join("/")}/`;
+          const name = names[i];
+          const entry = i < names.length - 1
+            ? folder(name)
+            : file(name, file2.content.length);
+          assertEntries(await fs.list(path), [entry]);
+        }
+      });
+
+      it("gets each file, with its headers", async () => {
+        for (const { path, content, start, end } of files) {
+          await assertFile(path, content, start, end);
+        }
+      });
+
+      it("gives the headers and no body for HEAD", async () => {
+        for (const { path, content } of files) {
+          const response = await fs.head(path);
+          assert.equal(response.status, 200, `HEAD ${JSON.stringify(path)}`);
+          assert.equal(response.body, null, "HEAD gives no body");
+          assert.equal(response.headers.get("Content-Type"), mimeType(path));
+          assert.equal(
+            response.headers.get("Content-Length"),
+            `${content.length}`,
+          );
+          assert.ok(response.headers.get("Last-Modified"));
+        }
+
+        const response = await fs.head("");
+        assert.equal(response.status, 200, "HEAD of a folder");
+        assert.equal(response.body, null, "HEAD gives no body");
+        assert.match(response.headers.get("Content-Type"), /^text\/html\b/);
+      });
+
+      it("puts a file over a file", async () => {
+        file1.content = random(200);
+        file1.start = Date.now();
+        const response = await fs.put(file1.path, file1.content);
+        file1.end = Date.now();
+        assert.ok(
+          response.ok,
+          `PUT over a file gave ${response.status}, not 2xx`,
+        );
+        await response.body?.cancel();
+
+        await assertFile(file1.path, file1.content, file1.start, file1.end);
+        assertEntries(await fs.list(""), [
+          file(FILE1, file1.content.length),
+          folder("hello? sausage"),
+        ]);
+      });
+
+      it("deletes a file", async () => {
+        await expect(fs.delete(file2.path), 204);
+        await expect(fs.get(file2.path), 404);
+        const parent = file2.path.slice(0, file2.path.lastIndexOf("/") + 1);
+        assertEntries(await fs.list(parent), []);
+      });
+
+      it("deletes a folder and all that is in it", async () => {
+        await put("hello? sausage/êé/a.txt", random(10));
+        await expect(fs.delete("hello? sausage/"), 204);
+        await expect(fs.get("hello? sausage/"), 404);
+        await expect(fs.get("hello? sausage/êé/"), 404);
+        await expect(fs.get("hello? sausage/êé/a.txt"), 404);
+        assertEntries(await fs.list(""), [file(FILE1, file1.content.length)]);
+      });
+    });
+
+    it("deletes the root folder of the tests", async () => {
+      await expect(fs.delete(""), 204);
+      await expect(fs.get(""), 404);
+      await expect(fs.get(FILE1), 404);
+    });
+  });
+
+  /**
+   * Puts a file, or a folder for a path with a `/` at the end, and makes
+   * sure that the answer is 201 with the location of the path.
+   * @param {string} path
+   * @param {Uint8Array} content
+   */
+  async function put(path, content) {
+    const response = await fs.put(path, content);
+    await response.body?.cancel();
+    assert.equal(response.status, 201, `PUT ${JSON.stringify(path)}`);
+
+    const location = response.headers.get("Content-Location");
+    assert.ok(location, `PUT ${JSON.stringify(path)} gave no Content-Location`);
+    const url = fs.url(path);
+    assert.equal(
+      decodeURIComponent(new URL(location, url).pathname),
+      decodeURIComponent(url.pathname),
+      "Content-Location is the path of the file",
+    );
+  }
+
+  /**
+   * Gets a file and makes sure that its content and its headers are correct,
+   * and that the list of its folder has the same size, type and time.
+   * @param {string} path
+   * @param {Uint8Array} content
+   * @param {number} start The time before the PUT, in milliseconds.
+   * @param {number} end The time after the PUT, in milliseconds.
+   */
+  async function assertFile(path, content, start, end) {
+    const what = `GET ${JSON.stringify(path)}`;
+    const response = await fs.get(path);
+    assert.equal(response.status, 200, what);
+
+    const { headers } = response;
+    assert.equal(headers.get("Content-Type"), mimeType(path), what);
+    assert.equal(headers.get("Content-Length"), `${content.length}`, what);
+    const lastModified = Date.parse(headers.get("Last-Modified"));
+    assertTime(lastModified, start, end, `Last-Modified of ${what}`);
+
+    const bytes = new Uint8Array(await response.arrayBuffer());
+    assert.equal(bytes.length, content.length, `the size of ${what}`);
+    assert.ok(
+      Buffer.from(bytes).equals(content),
+      `the bytes of ${what} are not the bytes of the PUT`,
+    );
+
+    const slash = path.lastIndexOf("/") + 1;
+    const name = path.slice(slash);
+    const entry = (await fs.list(path.slice(0, slash)))
+      .find((entry) => entry.Name === name);
+    assert.ok(entry, `the list of the folder has no ${JSON.stringify(name)}`);
+    assert.equal(entry.Size, content.length, `the size of ${name} in the list`);
+    assert.equal(entry.MimeType, mimeType(name), `the type of ${name}`);
+    const modTime = Date.parse(entry.ModTime);
+    assertTime(modTime, start, end, `the time of ${name} in the list`);
+    assert.ok(
+      Math.abs(modTime - lastModified) < 1000,
+      "the time in the list is the time of Last-Modified",
+    );
+  }
+}
+
+/**
+ * Sends a request, and makes sure that the answer has the status.
+ * @param {Promise<Response>} request
+ * @param {number} status
+ */
+async function expect(request, status) {
+  const response = await request;
+  await response.body?.cancel();
+  assert.equal(response.status, status);
+}
+
+/**
+ * Makes sure that the entries of a list are the expected entries, in any
+ * order. A folder has only its name. A file has its name and its size.
+ * @param {import("./listing.js").Entry[]} entries
+ * @param {Array<{ Name: string, IsDir: boolean, Size?: number }>} expected
+ */
+function assertEntries(entries, expected) {
+  const actual = entries.map(({ Name, IsDir, Size }) =>
+    IsDir ? { Name, IsDir } : { Name, IsDir, Size }
+  );
+  assert.deepEqual(sort(actual), sort(expected));
+}
+
+/**
+ * The time of a file must be between the times before and after its PUT.
+ * Some backends keep the time to the second, thus the time can be one
+ * second before.
+ * @param {number} time
+ * @param {number} start
+ * @param {number} end
+ * @param {string} what
+ */
+function assertTime(time, start, end, what) {
+  assert.ok(
+    time >= start - 1000 && time <= end + 1000,
+    `${what} is ${new Date(time).toISOString()}, not between ` +
+      `${new Date(start).toISOString()} and ${new Date(end).toISOString()}`,
+  );
+}
+
+/** @param {string} Name */
+function folder(Name) {
+  return { Name, IsDir: true };
+}
+
+/** @param {string} Name @param {number} Size */
+function file(Name, Size) {
+  return { Name, IsDir: false, Size };
+}
+
+/** @template {{ Name: string }} T @param {T[]} entries */
+function sort(entries) {
+  return entries.toSorted((a, b) => a.Name < b.Name ? -1 : +(a.Name > b.Name));
+}
+
+/** @param {number} size */
+function random(size) {
+  return new Uint8Array(randomBytes(size));
+}

From 8a1e57bbc17fc99435df4d0dc955d58ae71608df Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sat, 17 Oct 2026 02:11:45 +0000
Subject: [PATCH 13/87] fix(memory): pass the shared test suite

The memory backend now:

- removes the percent-encoding of the path, and gives 400 for a path that is not safe;
- writes each name with percent-encoding in the link, and with escapes in the HTML;
- gives the type of each file in the list, not the type of the folder;
- gives Content-Type, Content-Length and Last-Modified for GET and HEAD of a file;
- gives 404 for HEAD and DELETE of a path that does not exist, and 405 for other methods;
- finds the files of a folder with no regular expression, which failed for a name with ( or [;
- gives the size of a file of 0 bytes in the list.

The tests of the memory backend are now the shared suite.
---
 backend/memory/main.js      | 266 ++++++++++++++++++------------------
 backend/memory/main_test.js | 165 +---------------------
 2 files changed, 135 insertions(+), 296 deletions(-)

diff --git a/backend/memory/main.js b/backend/memory/main.js
index 4b60962..7259a36 100644
--- a/backend/memory/main.js
+++ b/backend/memory/main.js
@@ -8,9 +8,13 @@
  * name.
  */
 import { formatBytes } from "../../lib/format.js";
+import { escapeHTML } from "../../lib/html.js";
 import { mimeType } from "../../lib/mime.js";
+import { decodePath } from "../../lib/path.js";
 
 /**
+ * The files and the folders, by their path with no percent-encoding. The path
+ * of a folder ends with `/`, and a folder has no value.
  * @type {Map<string, File | null>}
  */
 const cache = new Map();
@@ -25,158 +29,71 @@ cache.set("/", null);
 async function memory(request) {
   const { method, url } = request;
   const { pathname, searchParams } = new URL(url);
+  const path = decodePath(pathname);
+
+  if (path === null) {
+    return new Response(null, { status: 400 });
+  }
 
   const headers = new Headers();
   let status = 200, body = null;
 
-  if (method === "GET") {
-    // Retrieves file content.
-    for (const [key, value] of cache) {
-      if (key === pathname) {
-        // File.
-        if (value !== null) {
-          body = value.stream();
-          break;
-        }
-
-        const regex = new RegExp(pathname + "([^/]+/?)");
-        /**
-         * @type {string[]}
-         */
-        const children = [];
-        for (const key of cache.keys()) {
-          const [, child] = key.match(regex) || [];
-          if (child) {
-            if (!children.includes(child)) {
-              children.push(child);
-            }
-          }
-        }
-
-        children.sort((a, b) => a.localeCompare(b));
-
-        // Folder listing
-        body = new ReadableStream({
-          start(controller) {
-            controller.enqueue(`
-              <table cellpadding="4">
-              <thead>
-                <tr>
-                  <th></th>
-                  <th>Name</th>
-                  <th>Size</th>
-                  <th>Modified</th>
-                </tr>
-              </thead>
-              <tbody>
-                <tr>
-                  <td>📁</td>
-                  <td><a href="../?${searchParams}">Go up</a></td>
-                  <td>—</td>
-                  <td>—</td>
-                </tr>
-            `);
-
-            for (const name of children) {
-              const value = cache.get(pathname + name);
-              const isDirectory = value === null;
-
-              let filePath = name;
-              if (isDirectory) {
-                filePath += "/";
-              }
-
-              const type = isDirectory ? "" : mimeType(pathname);
-              const size = Number(isDirectory ? "-1" : value.size);
-              const lastModified = value?.lastModified
-                ? new Date(value?.lastModified)
-                : "";
-
-              controller.enqueue(`<tr>
-                <td>${isDirectory ? "📁" : "📄"}</td>
-                <td>
-                  <a
-                    href="${filePath}?${searchParams}"
-                    type="${type}"
-                  >${name}</a>
-                </td>
-                <td>
-                  ${
-                size
-                  ? `<data
-                        value="${size}"
-                      >${formatBytes(size, { locale: true })}</data>`
-                  : "—"
-              }
-                </td>
-                <td>${
-                lastModified
-                  ? `<time
-                      datetime="${lastModified.toISOString()}"
-                    >${lastModified.toLocaleString()}</time>`
-                  : "-"
-              }
-                </td>
-              </tr>`);
-            }
-
-            controller.enqueue("</tbody></table>");
-            controller.close();
-          },
-        }).pipeThrough(new TextEncoderStream());
-
-        headers.set("Content-Type", "text/html;charset=utf-8");
-
-        break;
-      }
+  if (method === "HEAD" || method === "GET") {
+    if (!cache.has(path)) {
+      return new Response(null, { status: 404 });
     }
 
-    if (!body) {
-      status = 404;
+    const file = cache.get(path);
+    if (file) {
+      headers.set("Content-Type", file.type || mimeType(path));
+      headers.set("Content-Length", `${file.size}`);
+      headers.set("Last-Modified", new Date(file.lastModified).toUTCString());
+      if (method === "GET") {
+        body = file.stream();
+      }
+    } else {
+      headers.set("Content-Type", "text/html;charset=utf-8");
+      if (method === "GET") {
+        body = listing(path, searchParams);
+      }
     }
-  }
-
-  if (method === "PUT") {
-    const folders = pathname.split("/").slice(1, -1);
-    // Creates ancestor folders, recursively.
-    let href = "/";
-    for (const segment of folders) {
-      href += `${segment}/`;
-      cache.set(`${href}`, null);
+  } else if (method === "PUT") {
+    // Creates the parent folders, then the folder or the file.
+    const names = path.split("/").slice(1, -1);
+    let folder = "/";
+    for (const name of names) {
+      folder += `${name}/`;
+      cache.set(folder, null);
     }
 
-    // Folder ending with trailing slash.
-    if (pathname.endsWith("/")) {
-      // Nothing, as we already created it.
-    } else {
-      // Creates file.
-      const file = new File([await request.arrayBuffer()], pathname, {
-        type: request.headers.get("Content-Type") || "",
+    if (!path.endsWith("/")) {
+      const name = path.slice(path.lastIndexOf("/") + 1);
+      const file = new File([await request.arrayBuffer()], name, {
+        type: request.headers.get("Content-Type") || mimeType(name),
         lastModified: Date.now(),
       });
-      cache.set(pathname, file);
+      cache.set(path, file);
     }
 
     status = 201;
     headers.append("Content-Location", pathname);
-  }
+  } else if (method === "DELETE") {
+    if (!cache.has(path)) {
+      return new Response(null, { status: 404 });
+    }
 
-  if (method === "DELETE") {
-    // Folder ending with trailing slash.
-    if (pathname.endsWith("/")) {
-      // Deletes files in that folder.
-      for (const key of cache.keys()) {
-        if (key.startsWith(pathname)) {
-          cache.delete(key);
-        }
+    // Deletes the file, or the folder and all in it.
+    for (const key of cache.keys()) {
+      if (key === path || (path.endsWith("/") && key.startsWith(path))) {
+        cache.delete(key);
       }
-      // Deletes the folder itself
-      cache.delete(pathname);
-    } else {
-      // Deletes file.
-      cache.delete(pathname);
     }
+    // The root folder stays.
+    cache.set("/", null);
     status = 204;
+  } else {
+    status = 405;
+    headers.set("Allow", "GET, HEAD, PUT, DELETE");
   }
 
   return new Response(body, {
@@ -185,6 +102,89 @@ async function memory(request) {
   });
 }
 
+/**
+ * Gives the HTML list of the files and the folders in a folder.
+ * @param {string} path The path of the folder, with `/` at the end.
+ * @param {URLSearchParams} searchParams The query, for each link.
+ * @returns {ReadableStream<Uint8Array>}
+ */
+function listing(path, searchParams) {
+  // The children are the paths in the folder with no other "/" than a "/" at
+  // the end for a folder.
+  /** @type {string[]} */
+  const children = [];
+  for (const key of cache.keys()) {
+    if (key === path || !key.startsWith(path)) continue;
+    const child = key.slice(path.length);
+    const slash = child.indexOf("/");
+    if (slash === -1 || slash === child.length - 1) {
+      children.push(child);
+    }
+  }
+  children.sort((a, b) => a.localeCompare(b));
+
+  const query = escapeHTML(`${searchParams}`);
+
+  return new ReadableStream({
+    start(controller) {
+      controller.enqueue(`
+        <table cellpadding="4">
+        <thead>
+          <tr>
+            <th></th>
+            <th>Name</th>
+            <th>Size</th>
+            <th>Modified</th>
+          </tr>
+        </thead>
+        <tbody>
+          <tr>
+            <td>📁</td>
+            <td><a href="../?${query}">Go up</a></td>
+            <td>—</td>
+            <td>—</td>
+          </tr>
+      `);
+
+      for (const child of children) {
+        const file = cache.get(path + child);
+        const isDirectory = file === null;
+        const name = isDirectory ? child.slice(0, -1) : child;
+        const href = `${encodeURIComponent(name)}${isDirectory ? "/" : ""}`;
+        const type = isDirectory ? "" : file.type || mimeType(name);
+        const lastModified = isDirectory ? null : new Date(file.lastModified);
+
+        controller.enqueue(`<tr>
+          <td>${isDirectory ? "📁" : "📄"}</td>
+          <td>
+            <a
+              href="${href}?${query}"
+              type="${escapeHTML(type)}"
+            >${escapeHTML(child)}</a>
+          </td>
+          <td>${
+          isDirectory ? "—" : `<data
+              value="${file.size}"
+            >${formatBytes(file.size, { locale: true })}</data>`
+        }
+          </td>
+          <td>${
+          lastModified
+            ? `<time
+                datetime="${lastModified.toISOString()}"
+              >${lastModified.toLocaleString()}</time>`
+            : "-"
+        }
+          </td>
+        </tr>`);
+      }
+
+      controller.enqueue("</tbody></table>");
+      controller.close();
+    },
+  }).pipeThrough(new TextEncoderStream());
+}
+
 export default {
   fetch: memory,
 };
diff --git a/backend/memory/main_test.js b/backend/memory/main_test.js
index 9a46165..0a352ed 100644
--- a/backend/memory/main_test.js
+++ b/backend/memory/main_test.js
@@ -1,165 +1,4 @@
-import { test } from "node:test";
-import { join } from "node:path";
-import assert from "node:assert/strict";
-
+import { backendSuite } from "../../lib/testing/suite.js";
 import backend from "./main.js";
 
-const fetch = backend.fetch;
-
-const encoder = new TextEncoder();
-
-const tree = {
-  "/": ["A/", "B/", "C/", "a", "b", "c"],
-  "/A/": ["a", "b", "c"],
-  "/B/": ["a", "c"],
-  "/C/": [],
-};
-
-/**
- * Returns an array of descendants from `root` to the leaf nodes.
- *
- * Example:
- *
- * ```ts
- * descendants("/");
- * // ["/A/a", "/A/b", "/B/a", "/B/c", "/C/", "/a", "/b"]
- * ```
- *
- * @param {string} [root="/"] The node to retrieve the descendants from.
- * @returns {string[]} flat array of descendants with full path from `root`.
- */
-function descendants(root = "/") {
-  /**
-   * @type {string[]}
-   */
-  const results = [];
-  /**
-   * @type {string[]}
-   */
-  const children = tree[root] || [];
-  children.forEach((child) => {
-    const path = join(root, child);
-    const grandChildren = descendants(path);
-    if (!grandChildren.length) {
-      grandChildren.push(path);
-    }
-    results.push(...grandChildren);
-  });
-
-  return results;
-}
-
-test("PUT", async (t) => {
-  await t.test("a new file or folder", async () => {
-    for (const fixture of descendants("/")) {
-      const url = new URL(fixture, "memory:/");
-      // Sends the PUT request with the body.
-      const request = new Request(url, {
-        method: "PUT",
-        headers: {
-          "Content-Type": "text/plain",
-          "Content-Length": `${encoder.encode(fixture).byteLength}`,
-        },
-        body: fixture,
-      });
-      const { status, headers } = await fetch(request);
-
-      assert.deepEqual(status, 201, "should respond with 201 Created");
-      assert.equal(headers.get("Content-Location"), fixture);
-    }
-  });
-});
-
-test("GET", async (t) => {
-  await t.test("folder", async () => {
-    const pathname = "/"; // Root folder
-    let url = new URL(pathname, "memory:/");
-    let response = await fetch(new Request(url));
-    assert(response.headers.get("Content-Type")?.includes("text/html"));
-    const html = await response.text();
-
-    for (const child of tree[pathname]) {
-      assert(
-        html.includes(` href="${child}`),
-        `should have link to ${child}`,
-      );
-
-      if (child.endsWith("/")) {
-        const childPathname = pathname + child;
-
-        url = new URL(childPathname, "memory:/");
-        response = await fetch(new Request(url));
-        assert(response.headers.get("Content-Type")?.includes("text/html"));
-        const childHtml = await response.text();
-
-        for (const grandchild of tree[childPathname]) {
-          assert(
-            childHtml.includes(` href="${grandchild}`),
-            `should have link to ${grandchild}`,
-          );
-        }
-      }
-    }
-  });
-
-  await t.test("file", async () => {
-    const pathname = "/A/"; // Folder with only files
-    for (const fixture of descendants(pathname)) {
-      const url = new URL(fixture, "memory:/");
-      const response = await fetch(new Request(url));
-      const responseText = await response.text();
-      assert.deepEqual(responseText, fixture, "should have the same content");
-    }
-  });
-});
-
-test("DELETE", async (t) => {
-  await t.test("file", async () => {
-    const pathname = "/B/"; // Folder with only files
-    for await (const fixture of descendants(pathname)) {
-      const url = new URL(`${pathname}${fixture}`, "memory:/");
-      let response = await fetch(
-        new Request(url, {
-          method: "DELETE",
-        }),
-      );
-      assert.deepEqual(
-        response.status,
-        204,
-        "should respond with 204 No Content",
-      );
-
-      response = await fetch(new Request(url));
-      assert.deepEqual(
-        response.status,
-        404,
-        "should respond with 404 Not Found",
-      );
-    }
-  });
-
-  await t.test("folder", async () => {
-    const pathname = "/A/"; // Folder with many files
-    const url = new URL(pathname, "memory:/");
-    const response = await fetch(
-      new Request(url, {
-        method: "DELETE",
-      }),
-    );
-    assert.deepEqual(
-      response.status,
-      204,
-      "should respond with 204 No Content",
-    );
-
-    for await (const fixture of descendants(pathname)) {
-      const url = new URL(fixture, "memory:/");
-      const response = await fetch(new Request(url));
-      assert.deepEqual(
-        response.status,
-        404,
-        "should respond with 404 Not Found",
-      );
-    }
-  });
-});
+backendSuite("memory", backend);

From e6e94aac13f8899b94ff183ea2a1fe51725049d1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sat, 17 Oct 2026 02:11:45 +0000
Subject: [PATCH 14/87] fix(local): pass the shared test suite, and stay in the
 root folder

The local backend now:

- removes the percent-encoding of the path, and gives 400 for a path that can go out of the current folder, for example /..%2Fsecret.txt;
- gives 403 for DELETE /. Before, DELETE / deleted the current folder and all that is in it;
- gives 404 for a path that does not exist, in place of an error;
- creates the parent folders for PUT of a file, and accepts a PUT with no body;
- writes each name with percent-encoding in the link, and with escapes in the HTML, and gives the type of each file.

The tests use a new temporary folder as the current folder. They run the shared suite, and tests for the root folder.
---
 backend/local/main.js      | 117 ++++++++++-------
 backend/local/main_test.js | 250 ++++++++-----------------------------
 2 files changed, 124 insertions(+), 243 deletions(-)

diff --git a/backend/local/main.js b/backend/local/main.js
index 1258a3c..4f05bda 100644
--- a/backend/local/main.js
+++ b/backend/local/main.js
@@ -1,29 +1,42 @@
 import process from "node:process";
-import { join } from "node:path";
+import { dirname, isAbsolute, join, relative, sep } from "node:path";
 import { formatBytes } from "../../lib/format.js";
+import { escapeHTML } from "../../lib/html.js";
 import { mimeType } from "../../lib/mime.js";
+import { decodePath } from "../../lib/path.js";
 
 /**
- * Serves a local remote
+ * Serves a local remote: the files and the folders in the current folder.
  * @param {Request} request
  * @returns {Promise<Response>}
  */
 async function local(request) {
   const { method, url } = request;
   const { pathname, searchParams } = new URL(url);
-  const absolutePath = join(process.cwd?.() || ".", pathname);
+  const root = process.cwd?.() || ".";
+  const path = decodePath(pathname);
+  const absolutePath = path === null ? null : join(root, path);
+
+  // A path must not go out of the root, also on Windows, where `\` is a
+  // separator too.
+  if (absolutePath === null || isOutside(root, absolutePath)) {
+    return new Response(null, { status: 400 });
+  }
 
   // Have to use dynamic import here because `fs/promises` is not available in
   // Worker environments.
   const { mkdir, open, readdir, rm, stat } = await import("node:fs/promises");
 
-  let stats;
+  /** @type {import("node:fs").Stats | null} */
+  const stats = await stat(absolutePath).catch(() => null);
 
   const headers = new Headers();
   let status = 200, body = null;
 
   if (method === "HEAD" || method === "GET") {
-    stats = await stat(absolutePath);
+    if (!stats) {
+      return new Response(null, { status: 404 });
+    }
 
     if (stats.isDirectory()) {
       /**
@@ -33,6 +46,8 @@ async function local(request) {
       files.sort((a, b) => a.name.localeCompare(b.name));
 
       if (method === "GET") {
+        const query = escapeHTML(`${searchParams}`);
+
         body = new ReadableStream({
           async start(controller) {
             controller.enqueue(`
@@ -58,38 +73,34 @@ async function local(request) {
               <tbody>
                 <tr>
                   <td>📁</td>
-                  <td><a href="../?${searchParams}">Go up</a></td>
+                  <td><a href="../?${query}">Go up</a></td>
                   <td>—</td>
                   <td>—</td>
                 </tr>
               `);
 
-            for await (const file of files) {
+            for (const file of files) {
               const name = file.name;
-              let filePath = file.name;
               const isDirectory = file.isDirectory();
-              if (isDirectory) {
-                filePath += "/";
-              }
+              const href = `${encodeURIComponent(name)}${
+                isDirectory ? "/" : ""
+              }`;
 
-              const { size, mtime } = await stat(
-                join(absolutePath, filePath),
-              );
+              const { size, mtime } = await stat(join(absolutePath, name));
 
               controller.enqueue(`<tr>
                 <td>${isDirectory ? "📁" : "📄"}</td>
                 <td>
                   <a
-                    href="${filePath}?${searchParams}"
-                    type=""
-                  >${name}</a>
+                    href="${href}?${query}"
+                    type="${isDirectory ? "" : escapeHTML(mimeType(name))}"
+                  >${escapeHTML(name)}</a>
                 </td>
-                <td>
-                  <data
+                <td>${
+                isDirectory ? "—" : `<data
                     value="${size}"
-                  >${
-                size ? formatBytes(Number(size), { locale: true }) : "—"
-              }</data>
+                  >${formatBytes(Number(size), { locale: true })}</data>`
+              }
                 </td>
                 <td>${
                 mtime
@@ -99,8 +110,6 @@ async function local(request) {
                   : "-"
               }
                 </td>
-
-                </td>
               </tr>`);
             }
 
@@ -112,7 +121,7 @@ async function local(request) {
 
       headers.set("Content-Type", "text/html;charset=utf-8");
     } else {
-      headers.append("Content-Type", mimeType(pathname));
+      headers.append("Content-Type", mimeType(path));
       headers.append("Content-Length", stats.size.toString());
 
       if (method === "GET") {
@@ -122,14 +131,15 @@ async function local(request) {
           async pull(controller) {
             const chunk = new Uint8Array(64 * 1024);
             const { bytesRead } = await file.read(chunk, 0);
-            controller.enqueue(chunk.slice(0, bytesRead));
             if (bytesRead === 0) {
               controller.close();
-              file.close();
+              await file.close();
+              return;
             }
+            controller.enqueue(chunk.subarray(0, bytesRead));
           },
-          cancel() {
-            file.close();
+          async cancel() {
+            await file.close();
           },
         });
       }
@@ -137,34 +147,38 @@ async function local(request) {
 
     const mtime = stats.mtime?.toUTCString();
     if (mtime) headers.append("Last-Modified", mtime);
-  }
-
-  /** `PUT` upserts a file at `pathname`. */
-  if (method === "PUT") {
+  } else if (method === "PUT") {
     // Folder ending with trailing slash.
-    if (pathname.endsWith("/")) {
+    if (path.endsWith("/")) {
       await mkdir(absolutePath, { recursive: true });
     } else {
+      await mkdir(dirname(absolutePath), { recursive: true });
       const file = await open(absolutePath, "w");
-      await request.body.pipeTo(
-        new WritableStream({
-          async write(chunk) {
-            await file.write(chunk);
-          },
-          async close() {
-            await file.close();
-          },
-        }),
-      );
+      try {
+        for await (const chunk of request.body ?? []) {
+          await file.write(chunk);
+        }
+      } finally {
+        await file.close();
+      }
     }
 
     status = 201;
     headers.append("Content-Location", pathname);
-  }
+  } else if (method === "DELETE") {
+    if (!stats) {
+      return new Response(null, { status: 404 });
+    }
+    // The root is the current folder, which must stay.
+    if (path === "/") {
+      return new Response(null, { status: 403 });
+    }
 
-  if (method === "DELETE") {
     await rm(absolutePath, { recursive: true });
     status = 204;
+  } else {
+    status = 405;
+    headers.set("Allow", "GET, HEAD, PUT, DELETE");
   }
 
   return new Response(body, {
@@ -173,6 +187,17 @@ async function local(request) {
   });
 }
 
+/**
+ * Tells if a path is out of the root folder.
+ * @param {string} root
+ * @param {string} path
+ * @returns {boolean}
+ */
+function isOutside(root, path) {
+  const rest = relative(root, path);
+  return rest === ".." || rest.startsWith(`..${sep}`) || isAbsolute(rest);
+}
+
 export default {
   fetch: local,
 };
diff --git a/backend/local/main_test.js b/backend/local/main_test.js
index 99aaa86..c63fd68 100644
--- a/backend/local/main_test.js
+++ b/backend/local/main_test.js
@@ -1,214 +1,70 @@
-import { test } from "node:test";
+import { after, describe, it } from "node:test";
+import assert from "node:assert/strict";
 import process from "node:process";
-import { readdir, readFile, stat } from "node:fs/promises";
+import {
+  mkdir,
+  mkdtemp,
+  readFile,
+  rm,
+  stat,
+  writeFile,
+} from "node:fs/promises";
+import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { mimeType } from "../../lib/mime.js";
-import assert from "node:assert/strict";
 
+import { backendSuite } from "../../lib/testing/suite.js";
 import backend from "./main.js";
 
-const fetch = backend.fetch;
+// The backend serves the current folder. The tests use a new folder as the
+// current folder, with a secret file next to it, out of the root of the
+// backend.
+const folder = await mkdtemp(join(tmpdir(), "rfetch-local-"));
+const root = join(folder, "root");
+await mkdir(root);
+await writeFile(join(folder, "secret.txt"), "secret");
+process.chdir(root);
 
-const encoder = new TextEncoder();
-const cwd = process.cwd();
+backendSuite("local", backend);
 
-test("GET", async (t) => {
-  const requestInit = {
-    method: "GET",
-  };
+describe("local", () => {
+  after(() => rm(folder, { recursive: true, force: true }));
 
   /**
-   * @type {string[]}
+   * @param {string} method
+   * @param {string} path
    */
-  const files = [];
-
-  await t.test("/", async () => {
-    const url = new URL("/", "local://");
-    const request = new Request(url, requestInit);
-    const response = await fetch(request);
-    const { headers, body } = response;
-
-    assert(body, "should have body");
-    assert(headers.get("Content-Type").includes("text/html"));
-    const html = await response.text();
-
-    const entries = await readdir(cwd, { withFileTypes: true });
-    for await (const entry of entries) {
-      let name = entry.name;
-      if (entry.isDirectory()) {
-        name += "/";
+  async function send(method, path) {
+    const response = await backend.fetch(
+      new Request(`http://rfetch.test${path}`, {
+        method,
+        body: method === "PUT" ? "evil" : null,
+      }),
+    );
+    await response.body?.cancel();
+    return response;
+  }
+
+  it("does not go out of its root folder", async () => {
+    const paths = [
+      "/..%2Fsecret.txt",
+      "/a/..%2F..%2Fsecret.txt",
+      "/%2E%2E%2Fsecret.txt",
+      "/..%2F",
+    ];
+    for (const path of paths) {
+      for (const method of ["GET", "HEAD", "PUT", "DELETE"]) {
+        const { status } = await send(method, path);
+        assert.equal(status, 400, `${method} ${path}`);
       }
-
-      assert(
-        html.includes(` href="${name}`),
-        "should have the link in the HTML",
-      );
-
-      files.push(name);
     }
-  });
-
-  await t.test("a file", async () => {
-    for await (const name of files) {
-      // Checking links for now
-      if (name.endsWith("/")) continue;
-
-      const path = join(cwd, name);
-      const file = await stat(path);
 
-      const url = new URL(`/${name}`, "local://");
-      const request = new Request(url, requestInit);
-      const response = await fetch(request);
-      const { headers, body } = response;
-
-      assert.equal(
-        headers.get("Content-Type"),
-        mimeType(name),
-      );
-      assert.equal(headers.get("Content-Length"), `${file.size}`);
-      assert.equal(
-        headers.get("Last-Modified"),
-        file.mtime?.toUTCString() || "",
-      );
-
-      assert(
-        body instanceof ReadableStream,
-        "should have body as a ReadableStream",
-      );
-      assert.deepEqual(
-        await response.text(),
-        await readFile(path, "utf8"),
-        "should have the same content",
-      );
-    }
+    assert.equal(await readFile(join(folder, "secret.txt"), "utf8"), "secret");
+    assert.ok((await stat(root)).isDirectory());
   });
-});
-
-const newFile = "dummy.file";
-const newFolder = "dummy.folder/"; // Must have trailing slash.
-
-test("PUT", async (t) => {
-  await t.test("a new file", async () => {
-    const targetFile = join(cwd, newFile);
-    const body = "Hello World";
-
-    const url = new URL(`/${newFile}`, "local://");
-    // Sends the PUT request with the body.
-    const request = new Request(url, {
-      method: "PUT",
-      headers: {
-        "Content-Type": mimeType(newFile),
-        "Content-Length": `${encoder.encode(body).byteLength}`,
-      },
-      body,
-    });
-    const { status, headers } = await fetch(request);
-
-    assert.deepEqual(status, 201, "should respond with 201 Created");
-    assert.equal(headers.get("Content-Location"), `/${newFile}`);
-
-    assert.deepEqual(
-      await readFile(targetFile, "utf8"),
-      body,
-      "should have the same content",
-    );
-
-    // Also checks the content with a GET request.
-    const response = await fetch(new Request(url));
-    assert.deepEqual(
-      await response.text(),
-      body,
-      "should have the same content",
-    );
-  });
-
-  await t.test("a new folder", async () => {
-    const targetFolder = join(cwd, newFolder);
-
-    const url = new URL(`/${newFolder}`, "local://");
-    // Sends the PUT request with no body.
-    const request = new Request(url, {
-      method: "PUT",
-      headers: {
-        "Content-Type": "text/directory",
-        "Content-Length": "0",
-      },
-    });
-    const { status, headers } = await fetch(request);
-
-    assert.deepEqual(status, 201, "should respond with 201 Created");
-    assert.equal(headers.get("Content-Location"), `/${newFolder}`);
-
-    const stats = await stat(targetFolder);
-    assert(stats.isDirectory, "should be a directory");
-  });
-
-  await t.test("a new nested file", async () => {
-    const targetFile = join(cwd, newFolder, newFile);
-    const body = "Hello Nested World";
-
-    const url = new URL(`/${join(newFolder, newFile)}`, "local://");
-    // Sends the PUT request with the body.
-    const request = new Request(url, {
-      method: "PUT",
-      headers: {
-        "Content-Type": mimeType(newFile),
-        "Content-Length": `${encoder.encode(body).byteLength}`,
-      },
-      body,
-    });
-    const { status, headers } = await fetch(request);
-
-    assert.deepEqual(status, 201, "should respond with 201 Created");
-    assert.equal(
-      headers.get("Content-Location"),
-      `/${join(newFolder, newFile)}`,
-    );
-
-    assert.deepEqual(
-      await readFile(targetFile, "utf8"),
-      body,
-      "should have the same content",
-    );
-
-    // Also checks the content with a GET request.
-    const response = await fetch(new Request(url));
-    assert.deepEqual(
-      await response.text(),
-      body,
-      "should have the same content",
-    );
-  });
-});
-
-test("DELETE", async (t) => {
-  await t.test("a file", async () => {
-    const targetFile = join(cwd, newFile);
-    const url = new URL(`/${newFile}`, "local://");
-    // Sends the PUT request with the body.
-    const request = new Request(url, {
-      method: "DELETE",
-    });
-    const { status } = await fetch(request);
-    assert.deepEqual(status, 204, "should respond with 204 No Content");
-
-    assert.rejects(() => {
-      return stat(targetFile);
-    });
-  });
-
-  await t.test("a folder", async () => {
-    const targetFolder = join(cwd, newFolder);
-    const url = new URL(`/${newFolder}`, "local://");
-    // Sends the PUT request with the body.
-    const request = new Request(url, {
-      method: "DELETE",
-    });
-    const { status } = await fetch(request);
-    assert.deepEqual(status, 204, "should respond with 204 No Content");
 
-    assert.rejects(() => {
-      return stat(targetFolder);
-    });
+  it("does not delete its root folder", async () => {
+    const { status } = await send("DELETE", "/");
+    assert.equal(status, 403);
+    assert.ok((await stat(root)).isDirectory());
   });
 });

From 565e17b53718dd228c331c9c531774000712f182 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sat, 17 Oct 2026 02:11:45 +0000
Subject: [PATCH 15/87] fix(lsjson): give the names with no percent-encoding

The links of a list have percent-encoding. Thus lsjson gave the name a%20b.txt for the file a b.txt.
---
 cmd/lsjson/main.js      |  3 ++-
 cmd/lsjson/main_test.js | 13 +++++++++++++
 2 files changed, 15 insertions(+), 1 deletion(-)

diff --git a/cmd/lsjson/main.js b/cmd/lsjson/main.js
index 7f70b72..894fe78 100644
--- a/cmd/lsjson/main.js
+++ b/cmd/lsjson/main.js
@@ -137,7 +137,8 @@ export async function lsjson(location, flags = {}) {
             return;
           }
 
-          const name = basename(pathname);
+          // The link has percent-encoding, and the name has none.
+          const name = decodeURIComponent(basename(pathname));
 
           // If listing a file, skip other files.
           if (filename && name !== filename) {
diff --git a/cmd/lsjson/main_test.js b/cmd/lsjson/main_test.js
index 599f398..ac1b834 100644
--- a/cmd/lsjson/main_test.js
+++ b/cmd/lsjson/main_test.js
@@ -132,3 +132,16 @@ test(`lsjson("${pathname}", { recursive: true })`, async (t) => {
     },
   );
 });
+
+test("lsjson gives the names with no percent-encoding", async () => {
+  const name = "a b?#%.txt";
+  await fetch(`:memory:/names/${encodeURIComponent(name)}`, {
+    method: "PUT",
+    body: "a",
+  });
+
+  const result = await lsjson(":memory:/names/").then((res) => res.json());
+  assert.deepEqual(result.map(({ Name, Path }) => ({ Name, Path })), [
+    { Name: name, Path: name },
+  ]);
+});

From 725d95025b271e39e6f41c8018898166b13a2362 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sat, 17 Oct 2026 02:11:45 +0000
Subject: [PATCH 16/87] docs: the contract of a backend and its shared tests

CONTRIBUTING.md tells the answers that a backend gives, how to use decodePath and escapeHTML, and how a backend runs the shared test suite.
---
 CONTRIBUTING.md | 70 +++++++++++++++++++++++++++++++++++++++++++++----
 1 file changed, 65 insertions(+), 5 deletions(-)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 65d79d8..7627de6 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -9,9 +9,8 @@ Choose a name. The docs here will use `remote` as an example.
 Note that in rfetch terminology a file system backend is called a remote or an
 fs.
 
-- Make the folder "backend/remote" with the files "main.js" and
-  "main_test.js" for the new backend. The tests use the test runner of
-  Node.js (`node:test`).
+- Make the folder "backend/remote" with the files "main.js" and "main_test.js"
+  for the new backend. The tests use the test runner of Node.js (`node:test`).
 - Implements a `fetch` default export function that handles "GET", "PUT" and
   "DELETE".
 - Uses `backend/local/main.js` as reference, or the boilerplate below:
@@ -66,14 +65,75 @@ export default {
 
 - `GET /folder/`: displays HTML page with folder content.
 - `GET /file`: fetches file.
+- `HEAD /folder/` and `HEAD /file`: the same headers as `GET`, with no body.
 - `PUT /folder/`: creates folder.
-- `PUT /file`: uploads file.
-- `DELETE /folder/`: deletes folder.
+- `PUT /file`: uploads file. `PUT` creates the parent folders that do not exist.
+- `DELETE /folder/`: deletes folder, and all the files and folders in it.
 - `DELETE /file`: deletes file.
 
+The answers:
+
+- `PUT` gives 201 with the path in `Content-Location`. `DELETE` gives 204.
+- A file or a folder that does not exist gives 404.
+- `GET` of a file gives the headers `Content-Type`, `Content-Length` and
+  `Last-Modified`.
+
+The path of a request has percent-encoding. Use `decodePath` of `lib/path.js` to
+get the path with no percent-encoding. It gives `null` for a path that is not
+safe, for example `/..%2Fsecret.txt`, which becomes `/../secret.txt` after the
+decoding. For `null`, give 400.
+
 For displaying folder content, any HTML can be used, but the listing itself
 should be in a `<table>`, whose each rows are for each file or folder inside.
 Each items should have a `<a>` whose `href` attribute points to the file or
 folder, and optionally a `type` attribute to tell the item's mime-type. A
 `<data>` element should be used for file size, and `<time>` for file
 modification time.
+
+- The `href` is the name with percent-encoding (`encodeURIComponent`), with a
+  `/` at the end for a folder.
+- The text of the link is the name with `escapeHTML` of `lib/html.js`. Do not
+  put a name in the HTML with no escape: a file with the name `<script>.txt`
+  must not add a script to the page.
+- `<data value>` is the size in bytes, for a file only.
+- `<time datetime>` is the time in ISO 8601.
+
+## Tests of a backend
+
+Each backend must pass the shared tests of `lib/testing/suite.js`. These tests
+are as the tests `fstests` of rclone, for the contract above. The file
+"main_test.js" of the backend calls the suite one time:
+
+```js
+import { backendSuite } from "../../lib/testing/suite.js";
+import backend from "./main.js";
+
+backendSuite("remote", backend);
+```
+
+A backend with options gives them in `params`, which go in the query of each
+request, for example
+`backendSuite("alias", alias, { params: { remote:
+":memory:" } })`.
+
+The suite creates the folder `/rfetch-test-RANDOM/`, does all its tests in it,
+and deletes it at the end. It tests:
+
+- 404 for a file or a folder that does not exist, with `GET`, `HEAD` and
+  `DELETE`.
+- `PUT` of a folder, and of a file in folders that do not exist.
+- The names of the test `FsEncoding` of rclone, for example names with a space
+  at the start or at the end, `%`, `?`, `#`, `<`, `&` and Unicode.
+- A file of 0 bytes, and a file of more than 64 KiB.
+- The list of each folder: the name, the type, the size and the time of each
+  file.
+- `GET` and `HEAD` of a file: the bytes, and the headers.
+- `PUT` over a file, `DELETE` of a file, and `DELETE` of a folder with all that
+  is in it.
+
+Put the tests for what only one backend does in the same file, after the suite.
+For example, the tests of the local backend make sure that a path cannot go out
+of the root folder.
+
+Run all the tests with `npm test`, or the tests of one backend with
+`node --test backend/remote`.

From 8028fa5c22576c616e5ebfb356c8fdca5fafdcec Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sat, 17 Oct 2026 02:27:15 +0000
Subject: [PATCH 17/87] feat(ini): read and write the file as rclone does, with
 a streaming parser

lib/ini.js now has the rules of goconfig v1.0.0, which rclone uses to read and write its configuration file:

- the white space of Go, and the byte order mark;
- ":" as the end of a key, as "=";
- keys and values in quotes;
- the keys before the first section in the section DEFAULT;
- numbers for the keys "-".

ParseStream is a TransformStream from the text, in chunks of any size, to an entry for each section and each key. parse(text) and read(stream) use the same reader of lines.

stringify puts a key or a value in quotes when rclone does not read it the same with no quotes. It throws a TypeError for what rclone cannot read back. rclone 1.75.1 itself writes the value a`b as "a`b" and the value "  a  " with no quotes, and then it reads back different values.

An error gives the number of the line, but not its text, which can have a password.

The property tests:

- parse reads what stringify writes, or stringify throws a TypeError;
- stringify writes each configuration that rclone makes, and each configuration that parse reads;
- read gives the result of parse for each split of the text;
- parse reads each file and each line as rclone 1.75.1 reads it, and rclone reads what stringify writes. These tests run when rclone is installed, or when RCLONE is its path.
---
 CONTRIBUTING.md |   4 +
 lib/ini.js      | 386 +++++++++++++++++++++++++++++++-----
 lib/ini_test.js | 508 +++++++++++++++++++++++++++++++++++++++++++-----
 3 files changed, 799 insertions(+), 99 deletions(-)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 7627de6..095d395 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -137,3 +137,7 @@ of the root folder.
 
 Run all the tests with `npm test`, or the tests of one backend with
 `node --test backend/remote`.
+
+Some tests compare rfetch with rclone, for example the tests of
+`lib/ini.js`. They run when `rclone` is in the `PATH`, or when the variable
+`RCLONE` is the path of rclone. Else they are skipped.
diff --git a/lib/ini.js b/lib/ini.js
index 55a8517..4dbdfeb 100644
--- a/lib/ini.js
+++ b/lib/ini.js
@@ -1,5 +1,7 @@
 /**
- * The INI format of the configuration file of rclone:
+ * The configuration file of rclone, in the INI format of the library goconfig
+ * v1.0.0 (github.com/unknwon/goconfig), which rclone uses to read and write
+ * the file:
  *
  * ```ini
  * [remote]
@@ -11,76 +13,356 @@
  * remote = remote:bucket
  * ```
  *
- * A `[name]` line starts a section, and each `key = value` line is a string
- * in the current section. A line that starts with `#` or `;` is a comment.
+ * The rules of goconfig:
+ *
+ * - A line ends with "\n". The white space at the two ends of a line goes
+ *   away, with the white space of Go: also U+0085 and U+00A0.
+ * - An empty line, and a line that starts with `#` or `;`, give nothing.
+ * - `[name]` starts a section. The keys before the first section go in the
+ *   section `DEFAULT`. Two sections with the same name become one.
+ * - `key = value` and `key: value` set a key. The first `=` or `:` is the
+ *   end of the key.
+ * - A key in quotes (`` `key` ``, `"key"` or `"""key"""`) keeps its white
+ *   space, and can have `=` and `:`.
+ * - A value in quotes (`` `value` `` or `"""value"""`) keeps its white space.
+ *   The value ends at the last quote of the line.
+ * - The key `-` gets a number in its section: `#1`, then `#2`, and so on.
+ */
+
+/** The section of the keys before the first section. */
+export const DEFAULT = "DEFAULT";
+
+/** The white space that `strings.TrimSpace` of Go removes. */
+const SPACE =
+  "[\\t\\n\\v\\f\\r \\u0085\\u00A0\\u1680\\u2000-\\u200A\\u2028\\u2029\\u202F\\u205F\\u3000]";
+const TRIM = new RegExp(`^${SPACE}+|${SPACE}+$`, "g");
+
+const encoder = new TextEncoder();
+
+/**
+ * An item of a configuration file: the start of a section, or a key and its
+ * value in a section.
+ * @typedef {{ section: string, key?: string, value?: string }} Entry
  */
 
 /**
- * Reads the text of a configuration file. The keys before the first section
- * are at the top level. Two sections with the same name become one, as in
- * rclone.
+ * A configuration: the keys of each section, in the order of the file.
+ * @typedef {Record<string, Record<string, string>>} Config
+ */
+
+/**
+ * Reads the text of a configuration file.
  * @param {string} text
- * @returns {Record<string, string | Record<string, string>>}
+ * @returns {Config}
+ * @throws {SyntaxError} For a line that goconfig does not accept.
  */
 export function parse(text) {
-  /** @type {Map<string, string | Map<string, string>>} */
-  const config = new Map();
-  let section = config;
-  for (const [index, line] of text.split(/\r?\n/).entries()) {
-    const content = line.trim();
-    if (content === "" || content.startsWith("#") || content.startsWith(";")) {
-      continue;
-    }
-    const name = /^\[(.*)\]$/.exec(content)?.[1];
-    if (name !== undefined) {
-      if (!(config.get(name) instanceof Map)) {
-        config.set(name, new Map());
-      }
-      section = config.get(name);
-      continue;
-    }
-    const equal = content.indexOf("=");
-    if (equal === -1) {
-      throw new SyntaxError(`INI: line ${index + 1} has no "=": ${content}`);
-    }
-    section.set(
-      content.slice(0, equal).trim(),
-      content.slice(equal + 1).trim(),
-    );
+  const lines = new LineReader();
+  const config = new ConfigBuilder();
+  for (const line of text.split("\n")) {
+    config.add(lines.read(line));
+  }
+  return config.value;
+}
+
+/**
+ * Reads a configuration file from a stream of text, for example the body of
+ * a response through a `TextDecoderStream`.
+ * @param {ReadableStream<string>} stream
+ * @returns {Promise<Config>}
+ */
+export async function read(stream) {
+  const config = new ConfigBuilder();
+  for await (const entry of stream.pipeThrough(new ParseStream())) {
+    config.add(entry);
+  }
+  return config.value;
+}
+
+/**
+ * A stream that reads the text of a configuration file, in chunks of any
+ * size, and gives an entry for each section and for each key, line by line.
+ * It keeps only the part of a line that has no "\n" yet. A line that goconfig
+ * does not accept makes an error of the stream.
+ * @extends {TransformStream<string, Entry>}
+ */
+export class ParseStream extends TransformStream {
+  constructor() {
+    const lines = new LineReader();
+    let rest = "";
+    super({
+      transform(chunk, controller) {
+        const parts = (rest + chunk).split("\n");
+        rest = parts.pop();
+        for (const part of parts) {
+          const entry = lines.read(part);
+          if (entry) controller.enqueue(entry);
+        }
+      },
+      flush(controller) {
+        const entry = lines.read(rest);
+        if (entry) controller.enqueue(entry);
+      },
+    });
   }
-  // Object.fromEntries makes own properties, so a name such as "__proto__"
-  // does not change the prototype.
-  return Object.fromEntries(
-    [...config].map((
-      [key, value],
-    ) => [key, value instanceof Map ? Object.fromEntries(value) : value]),
-  );
 }
 
 /**
- * Writes a configuration file: first the keys at the top level, then each
- * section, with an empty line between the sections, as rclone writes them.
- * A key with no value (undefined or null) is not written.
- * @param {Record<string, unknown>} config
+ * Writes a configuration file that rclone reads as the same configuration.
+ * The keys of the section `DEFAULT` come first with no `[DEFAULT]` line, when
+ * `DEFAULT` is the first section. Then each section comes, with an empty line
+ * between the sections, as rclone writes them. A key with no value
+ * (undefined or null) is not written.
+ *
+ * A key or a value goes in quotes when rclone does not read it the same with
+ * no quotes, for example a value with a space at the start. In some of these
+ * cases, rclone writes no quotes, or quotes that it cannot read back.
+ * @param {Record<string, Record<string, unknown>>} config
  * @param {{ section?: string }} [options] With a `section`, `config` is the
  *   keys of that one section.
  * @returns {string}
+ * @throws {TypeError} For a name, a key or a value that rclone cannot read
+ *   back the same: a line break in it, a section name that is empty or has
+ *   white space at the start or at the end, and the keys "", " " and "-".
  */
 export function stringify(config, { section } = {}) {
   if (section) {
     return stringify({ [section]: config });
   }
-  const isSection = (value) => typeof value === "object" && value !== null;
-  const lines = (entries) =>
-    entries
+
+  const blocks = [];
+  for (const [index, [name, keys]] of Object.entries(config).entries()) {
+    if (typeof keys !== "object" || keys === null) {
+      throw new TypeError(
+        `INI: the section ${JSON.stringify(name)} is not an object.`,
+      );
+    }
+    const lines = Object.entries(keys)
       .filter(([, value]) => value !== undefined && value !== null)
-      .map(([key, value]) => `${key} = ${value}`);
+      .map(([key, value]) => `${writeKey(key)} = ${writeValue(`${value}`)}`);
+
+    if (name === DEFAULT && index === 0 && lines.length) {
+      blocks.push(lines);
+    } else {
+      blocks.push([`[${writeSection(name)}]`, ...lines]);
+    }
+  }
+  return blocks.map((lines) => lines.join("\n")).join("\n\n");
+}
+
+/**
+ * Reads the lines of one file, one at a time, as `ConfigFile.read` of
+ * goconfig. It keeps the current section and the number of the line.
+ */
+class LineReader {
+  #section = DEFAULT;
+  /** The number of the next key `-` in the section. */
+  #count = 1;
+  #number = 0;
+
+  /**
+   * Reads one line, with no "\n".
+   * @param {string} text
+   * @returns {Entry | undefined}
+   */
+  read(text) {
+    this.#number++;
+    // goconfig removes the byte order mark at the start of the file.
+    if (this.#number === 1 && text.startsWith("")) {
+      text = text.slice(1);
+    }
+
+    const line = trim(text);
+    if (line === "" || line[0] === "#" || line[0] === ";") {
+      return;
+    }
+
+    if (line[0] === "[" && line.at(-1) === "]") {
+      this.#section = trim(line.slice(1, -1));
+      this.#count = 1;
+      // The section `[]` is the section DEFAULT, but it cannot have keys.
+      return { section: this.#section || DEFAULT };
+    }
+
+    if (this.#section === "") {
+      throw this.#error("has a key in a section with no name");
+    }
+
+    let key, end;
+    const quote = startsWithQuotes(line)
+      ? '"""'
+      : line[0] === '"' || line[0] === "`"
+      ? line[0]
+      : "";
+    if (quote) {
+      const close = line.indexOf(quote, quote.length);
+      if (close === -1) {
+        throw this.#error("has a key with no quote at the end");
+      }
+      key = line.slice(quote.length, close);
+      end = delimiter(line, close);
+    } else {
+      end = delimiter(line, 0);
+      key = trim(line.slice(0, Math.max(end, 0)));
+    }
+    if (end <= 0) {
+      throw this.#error('has no "=" or ":" after a key');
+    }
+
+    if (key === "-") {
+      key = `#${this.#count++}`;
+    }
+
+    let value = trim(line.slice(end + 1));
+    const valueQuote = value[0] === "`" && value.length >= 2
+      ? "`"
+      : startsWithQuotes(value)
+      ? '"""'
+      : "";
+    if (valueQuote) {
+      const close = value.lastIndexOf(valueQuote);
+      if (close < valueQuote.length) {
+        throw this.#error("has a value with no quote at the end");
+      }
+      value = value.slice(valueQuote.length, close);
+    }
+
+    // goconfig ignores an empty key. The key " " marks that a section
+    // exists, thus it is not a key.
+    if (key === "") return;
+    if (key === " ") return { section: this.#section };
+    return { section: this.#section, key, value };
+  }
+
+  /**
+   * An error with the number of the line, but not the text of the line,
+   * which can have a password or a token.
+   * @param {string} problem
+   */
+  #error(problem) {
+    return new SyntaxError(`INI: line ${this.#number} ${problem}.`);
+  }
+}
+
+/** Makes the configuration from the entries, in the order of the file. */
+class ConfigBuilder {
+  /** @type {Map<string, Map<string, string>>} */
+  #sections = new Map();
+
+  /** @param {Entry | undefined} entry */
+  add(entry) {
+    if (!entry) return;
+    const { section, key, value } = entry;
+    if (!this.#sections.has(section)) {
+      this.#sections.set(section, new Map());
+    }
+    if (key !== undefined) {
+      this.#sections.get(section).set(key, value);
+    }
+  }
+
+  /** @returns {Config} */
+  get value() {
+    // Object.fromEntries makes own properties, so a name such as "__proto__"
+    // does not change the prototype.
+    return Object.fromEntries(
+      [...this.#sections].map(([name, keys]) => [
+        name,
+        Object.fromEntries(keys),
+      ]),
+    );
+  }
+}
+
+/**
+ * Writes a section name, which goconfig reads with no white space at its two
+ * ends.
+ * @param {string} name
+ */
+function writeSection(name) {
+  if (name === "" || name.includes("\n") || trim(name) !== name) {
+    throw new TypeError(
+      `INI: the section name ${JSON.stringify(name)} cannot be written.`,
+    );
+  }
+  return name;
+}
+
+/**
+ * Writes a key, in quotes when goconfig does not read it the same with no
+ * quotes. The quotes are the quotes of goconfig for a key with "=" or ":".
+ * goconfig reads a key in quotes to the first quote at the end.
+ * @param {string} key
+ */
+function writeKey(key) {
+  if (key === "" || key === " " || key === "-" || key.includes("\n")) {
+    throw new TypeError(
+      `INI: the key ${JSON.stringify(key)} cannot be written.`,
+    );
+  }
+  // A key at the start of the file must not start with U+FEFF, which is
+  // the byte order mark there.
+  if (trim(key) === key && !/^[#;"`[\uFEFF]|[=:]/.test(key)) {
+    return key;
+  }
+  if (!key.includes("`")) {
+    return `\`${key}\``;
+  }
+  if (!key.includes('"')) {
+    return `"${key}"`;
+  }
+  if (!key.includes('"""') && !key.endsWith('"')) {
+    return `"""${key}"""`;
+  }
+  throw new TypeError(`INI: the key ${JSON.stringify(key)} cannot be written.`);
+}
 
-  const entries = Object.entries(config);
-  const blocks = [lines(entries.filter(([, value]) => !isSection(value)))];
-  for (const [name, keys] of entries.filter(([, value]) => isSection(value))) {
-    blocks.push([`[${name}]`, ...lines(Object.entries(keys))]);
+/**
+ * Writes a value, in quotes when goconfig does not read it the same with no
+ * quotes. goconfig reads a value in quotes to the last quote of the line,
+ * thus each value with no line break can go in quotes.
+ * @param {string} value
+ */
+function writeValue(value) {
+  if (value.includes("\n")) {
+    throw new TypeError("INI: a value cannot have a line break.");
+  }
+  // goconfig writes a value with "`" in """ quotes, but it writes the value
+  // in " quotes when the value has no '"'. Then it cannot read the value
+  // back, because a value in " quotes keeps its quotes.
+  if (value.includes("`")) {
+    return `"""${value}"""`;
   }
-  return blocks.filter((block) => block.length).map((block) => block.join("\n"))
-    .join("\n\n");
+  if (trim(value) !== value || value.startsWith('"""')) {
+    return `\`${value}\``;
+  }
+  return value;
+}
+
+/**
+ * Removes the white space at the two ends, as `strings.TrimSpace` of Go.
+ * @param {string} text
+ */
+function trim(text) {
+  return text.replace(TRIM, "");
+}
+
+/**
+ * Tells if a text starts with `"""` and has 6 bytes or more in UTF-8, as
+ * goconfig checks it for `"""` quotes. Thus `"""é` is not in quotes, but
+ * `"""€` is in quotes with no end, which is an error.
+ * @param {string} text
+ */
+function startsWithQuotes(text) {
+  return text.startsWith('"""') && encoder.encode(text).length >= 6;
+}
+
+/**
+ * Gives the position of the first "=" or ":" from a position, or -1.
+ * @param {string} line
+ * @param {number} from
+ */
+function delimiter(line, from) {
+  const found = line.slice(from).search(/[=:]/);
+  return found === -1 ? -1 : from + found;
 }
diff --git a/lib/ini_test.js b/lib/ini_test.js
index 7f89e00..e0aa44c 100644
--- a/lib/ini_test.js
+++ b/lib/ini_test.js
@@ -1,62 +1,476 @@
-import { test } from "node:test";
+import { after, describe, test } from "node:test";
 import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import process from "node:process";
 import fc from "fast-check";
 
-import { parse, stringify } from "./ini.js";
+import { parse, ParseStream, read, stringify } from "./ini.js";
 
-test("parse", () => {
-  assert.deepEqual(parse(""), {});
-  assert.deepEqual(
-    parse(
-      "top = 1\n[a]\ntype = s3\n  spaced key  =   a value  \nurl=https://x/?a=b\n" +
-        "; a comment\n# a comment\n\n[b c]\nempty =\n",
-    ),
-    {
-      top: "1",
-      a: { type: "s3", "spaced key": "a value", url: "https://x/?a=b" },
-      "b c": { empty: "" },
-    },
-  );
-  // Two sections with the same name become one, as in rclone.
-  assert.deepEqual(parse("[a]\nx = 1\n[a]\ny = 2\r\n"), {
-    a: { x: "1", y: "2" },
+describe("parse", () => {
+  test("reads sections and keys", () => {
+    assert.deepEqual(parse(""), {});
+    assert.deepEqual(
+      parse(
+        "[a]\ntype = s3\n  spaced key  =   a value  \nurl=https://x/?a=b\n" +
+          "; a comment\n# a comment\n\n[b c]\nempty =\n",
+      ),
+      {
+        a: { type: "s3", "spaced key": "a value", url: "https://x/?a=b" },
+        "b c": { empty: "" },
+      },
+    );
+  });
+
+  test("puts the keys before the first section in DEFAULT", () => {
+    assert.deepEqual(parse("top = 1\n[a]\nx = 2"), {
+      DEFAULT: { top: "1" },
+      a: { x: "2" },
+    });
+    assert.deepEqual(parse("[DEFAULT]\ntop = 1\n[]"), {
+      DEFAULT: { top: "1" },
+    });
+  });
+
+  test("makes one section of two sections with the same name", () => {
+    assert.deepEqual(parse("[a]\nx = 1\n[b]\n[a]\ny = 2\r\nx = 3"), {
+      a: { x: "3", y: "2" },
+      b: {},
+    });
   });
-  assert.throws(() => parse("[a]\nno equal sign"), {
-    name: "SyntaxError",
-    message: 'INI: line 2 has no "=": no equal sign',
+
+  test('ends a key at the first "=" or ":"', () => {
+    assert.deepEqual(parse("[a]\nk1: v=1\nk2 = v:2\nk3:"), {
+      a: { k1: "v=1", k2: "v:2", k3: "" },
+    });
+  });
+
+  test("reads keys and values in quotes", () => {
+    assert.deepEqual(
+      parse(
+        '[a]\n`k=1` = `  v  `\n"k`2" = """a"`b"""\n' +
+          '"""k"`3""" = `a`b` rest\nk4 = "q"\nk5 = """é\n',
+      ),
+      {
+        a: {
+          "k=1": "  v  ",
+          "k`2": 'a"`b',
+          'k"`3': "a`b",
+          k4: '"q"',
+          k5: '"""é',
+        },
+      },
+    );
+  });
+
+  test("gives numbers to the keys -", () => {
+    assert.deepEqual(parse("[a]\n- = x\n- = y\n[b]\n- = z"), {
+      a: { "#1": "x", "#2": "y" },
+      b: { "#1": "z" },
+    });
+  });
+
+  test("ignores the empty key and the key ' '", () => {
+    assert.deepEqual(parse('[a]\n"" = x\n" " = y\nk = v'), { a: { k: "v" } });
+  });
+
+  test("removes the white space of Go and the byte order mark", () => {
+    assert.deepEqual(parse("[a]\u0085\n k = v　\r\n"), {
+      a: { k: "v" },
+    });
+  });
+
+  test("gives an error with the line number and no text of the line", () => {
+    for (
+      const [text, message] of [
+        ["[a]\nno equal sign", 'INI: line 2 has no "=" or ":" after a key.'],
+        ["[a]\n= value", 'INI: line 2 has no "=" or ":" after a key.'],
+        [
+          '[a]\n"key = value',
+          "INI: line 2 has a key with no quote at the end.",
+        ],
+        [
+          "[a]\nk = `secret",
+          "INI: line 2 has a value with no quote at the end.",
+        ],
+        ['[a]\nk = """€', "INI: line 2 has a value with no quote at the end."],
+        ["[]\nk = v", "INI: line 2 has a key in a section with no name."],
+      ]
+    ) {
+      assert.throws(() => parse(text), { name: "SyntaxError", message });
+    }
+  });
+
+  test("does not change the prototype", () => {
+    const config = parse("[__proto__]\npolluted = yes\n");
+    assert.deepEqual(Object.keys(config), ["__proto__"]);
+    assert.equal({}.polluted, undefined);
   });
 });
 
-test("parse does not change the prototype", () => {
-  const config = parse("[__proto__]\npolluted = yes\n");
-  assert.deepEqual(Object.keys(config), ["__proto__"]);
-  assert.equal({}.polluted, undefined);
+describe("stringify", () => {
+  test("writes the format of rclone", () => {
+    const config = { a: { type: "s3", key: "v=1" }, b: { type: "local" } };
+    assert.equal(
+      stringify(config),
+      "[a]\ntype = s3\nkey = v=1\n\n[b]\ntype = local",
+    );
+    assert.equal(stringify(config, { section: "" }), stringify(config));
+    assert.equal(stringify(config.b, { section: "b" }), "[b]\ntype = local");
+    assert.equal(
+      stringify({ DEFAULT: { top: "1" }, a: { x: "2" } }),
+      "top = 1\n\n[a]\nx = 2",
+    );
+    assert.equal(
+      stringify({ a: {}, DEFAULT: { top: "1" } }),
+      "[a]\n\n[DEFAULT]\ntop = 1",
+    );
+    assert.equal(
+      stringify({ a: { x: undefined, y: null, z: 0 } }),
+      "[a]\nz = 0",
+    );
+    assert.equal(stringify({}), "");
+  });
+
+  test("puts in quotes what rclone does not read the same with no quotes", () => {
+    assert.equal(
+      stringify({
+        a: {
+          "k=1": "  v  ",
+          "#k": 'a"`b',
+          "k`:": "a`b",
+          'k`"=': '"""x',
+          "k5": '"q"',
+        },
+      }),
+      '[a]\n`k=1` = `  v  `\n`#k` = """a"`b"""\n"k`:" = """a`b"""\n' +
+        '"""k`"=""" = `"""x`\nk5 = "q"',
+    );
+  });
+
+  test("throws for what rclone cannot read the same", () => {
+    for (
+      const config of [
+        { "": { k: "v" } },
+        { " a": {} },
+        { "a\nb": {} },
+        { a: { "": "v" } },
+        { a: { " ": "v" } },
+        { a: { "-": "v" } },
+        { a: { "k\n": "v" } },
+        { a: { 'k`="': "v" } },
+        { a: { k: "line 1\nline 2" } },
+        { a: "not a section" },
+      ]
+    ) {
+      assert.throws(() => stringify(config), TypeError);
+    }
+  });
 });
 
-test("stringify writes the format of rclone", () => {
-  const config = { a: { type: "s3", key: "v=1" }, b: { type: "local" } };
-  assert.equal(
-    stringify(config),
-    "[a]\ntype = s3\nkey = v=1\n\n[b]\ntype = local",
+test("ParseStream gives an entry for each section and each key", async () => {
+  const entries = await Array.fromAsync(
+    ReadableStream.from(["top = 1\n[a", "]\nk = v\n- = x", "\n[b]"])
+      .pipeThrough(new ParseStream()),
   );
-  assert.equal(stringify(config, { section: "" }), stringify(config));
-  assert.equal(stringify(config.b, { section: "b" }), "[b]\ntype = local");
-  assert.equal(stringify({ top: "1", a: { x: "2" } }), "top = 1\n\n[a]\nx = 2");
-  assert.equal(stringify({ a: { x: undefined, y: null, z: 0 } }), "[a]\nz = 0");
-  assert.equal(stringify({}), "");
+  assert.deepEqual(entries, [
+    { section: "DEFAULT", key: "top", value: "1" },
+    { section: "a" },
+    { section: "a", key: "k", value: "v" },
+    { section: "a", key: "#1", value: "x" },
+    { section: "b" },
+  ]);
 });
 
-test("parse reads what stringify writes", () => {
-  const word = fc.stringMatching(/^[\w.][\w. -]*[\w.]$/);
-  const value = fc.stringMatching(/^\S(.*\S)?$/).filter((v) =>
-    !/[\r\n]/.test(v)
-  );
-  fc.assert(
-    fc.property(
-      fc.dictionary(word, fc.dictionary(word, value), { minKeys: 1 }),
-      (config) => {
-        assert.deepEqual(parse(stringify(config)), config);
-      },
-    ),
+// The generators for the properties.
+
+/** Pieces of text with the characters that have a meaning for goconfig. */
+const PIECES = [
+  "=",
+  ":",
+  "#",
+  ";",
+  "[",
+  "]",
+  '"',
+  '"""',
+  "`",
+  "-",
+  " ",
+  "\t",
+  "\r",
+  "\u0085",
+  " ",
+  "　",
+  "",
+  "é",
+  "€",
+  "😀",
+  "DEFAULT",
+  "a",
+  "b",
+  "type",
+  "s3:bucket",
+];
+
+/** A text with no line break. */
+const text = fc.array(
+  fc.oneof(
+    { weight: 4, arbitrary: fc.constantFrom(...PIECES) },
+    {
+      weight: 1,
+      arbitrary: fc.fullUnicodeString({ maxLength: 4 })
+        .map((text) => text.replaceAll("\n", "")),
+    },
+  ),
+  { maxLength: 6 },
+).map((pieces) => pieces.join(""));
+
+const quote = fc.constantFrom("`", '"', '"""');
+
+/** A key: often a name of an option, but sometimes any text. */
+const key = fc.oneof(
+  { weight: 3, arbitrary: fc.stringMatching(/^[a-z_][a-z0-9_]{0,8}$/) },
+  { weight: 2, arbitrary: text },
+);
+
+/** A line of a configuration file, often a line that goconfig accepts. */
+const line = fc.oneof(
+  { weight: 2, arbitrary: text.map((name) => `[${name}]`) },
+  {
+    weight: 4,
+    arbitrary: fc.tuple(key, fc.constantFrom(" = ", "=", ": ", " : "), text)
+      .map(([key, delimiter, value]) => `${key}${delimiter}${value}`),
+  },
+  {
+    weight: 2,
+    arbitrary: fc.tuple(quote, key, quote, text)
+      .map(([q1, key, q2, value]) => `${q1}${key}${q1} = ${q2}${value}${q2}`),
+  },
+  {
+    weight: 1,
+    arbitrary: fc.tuple(key, quote, text)
+      .map(([key, q, value]) => `${key} = ${q}${value}`),
+  },
+  { weight: 1, arbitrary: text.map((comment) => `# ${comment}`) },
+  { weight: 1, arbitrary: text },
+);
+
+/** The text of a configuration file. */
+const file = fc.tuple(
+  fc.constantFrom("", ""),
+  fc.array(fc.tuple(line, fc.constantFrom("\n", "\r\n")), { maxLength: 10 }),
+).map(([start, lines]) =>
+  start + lines.map(([line, end]) => line + end).join("")
+);
+
+/**
+ * A configuration from the given names, keys and values.
+ * @param {fc.Arbitrary<string>} name
+ * @param {fc.Arbitrary<string>} key
+ * @param {fc.Arbitrary<string>} value
+ */
+function configOf(name, key, value) {
+  const keys = fc.uniqueArray(fc.tuple(key, value), {
+    selector: ([key]) => key,
+    maxLength: 5,
+  });
+  return fc.uniqueArray(fc.tuple(name, keys), {
+    selector: ([name]) => name,
+    maxLength: 4,
+  }).map((sections) =>
+    Object.fromEntries(
+      sections.map(([name, keys]) => [name, Object.fromEntries(keys)]),
+    )
   );
+}
+
+/** A configuration from texts with the characters that have a meaning. */
+const anyConfig = configOf(text, text, text);
+
+/**
+ * A configuration as rclone makes it: the names of remotes as
+ * `fspath.CheckConfigName` accepts them, the names of options, and values of
+ * all characters but a line break.
+ */
+const rcloneConfig = configOf(
+  fc.stringMatching(/^[\w.+@é世]+(?:[ -]+[\w.+@é世-]+)*$/),
+  fc.stringMatching(/^[a-z][a-z0-9_]*$/),
+  fc.oneof(
+    text,
+    fc.fullUnicodeString().map((text) => text.replaceAll("\n", "")),
+  ),
+);
+
+/**
+ * The sections and the keys in their order, for a comparison that checks
+ * the order too.
+ * @param {Record<string, Record<string, string>>} config
+ */
+function ordered(config) {
+  return Object.entries(config).map(([name, keys]) => [
+    name,
+    Object.entries(keys),
+  ]);
+}
+
+/**
+ * Gives the result of a function, or the message of its SyntaxError.
+ * @param {() => any} read
+ */
+async function outcome(read) {
+  try {
+    return { config: ordered(await read()) };
+  } catch (error) {
+    if (!(error instanceof SyntaxError)) throw error;
+    return { error: error.message };
+  }
+}
+
+describe("properties", () => {
+  test("parse reads what stringify writes, or stringify throws", () => {
+    fc.assert(
+      fc.property(anyConfig, (config) => {
+        let text;
+        try {
+          text = stringify(config);
+        } catch (error) {
+          assert.ok(error instanceof TypeError, error);
+          return;
+        }
+        assert.deepEqual(ordered(parse(text)), ordered(config));
+      }),
+      { numRuns: 1000 },
+    );
+  });
+
+  test("stringify writes each configuration that rclone makes", () => {
+    fc.assert(
+      fc.property(rcloneConfig, (config) => {
+        assert.deepEqual(ordered(parse(stringify(config))), ordered(config));
+      }),
+      { numRuns: 500 },
+    );
+  });
+
+  test("stringify writes each configuration that parse reads", () => {
+    fc.assert(
+      fc.property(file, (text) => {
+        let config;
+        try {
+          config = parse(text);
+        } catch (error) {
+          assert.ok(error instanceof SyntaxError, error);
+          return;
+        }
+        assert.deepEqual(ordered(parse(stringify(config))), ordered(config));
+      }),
+      { numRuns: 1000 },
+    );
+  });
+
+  test("read gives the result of parse, for each split of the text", async () => {
+    await fc.assert(
+      fc.asyncProperty(
+        file,
+        fc.array(fc.nat(), { maxLength: 6 }),
+        async (text, cuts) => {
+          const points = [
+            ...new Set(cuts.map((cut) => cut % (text.length + 1))),
+          ]
+            .sort((a, b) => a - b);
+          const chunks = [];
+          let start = 0;
+          for (const point of points) {
+            chunks.push(text.slice(start, point));
+            start = point;
+          }
+          chunks.push(text.slice(start));
+
+          assert.deepEqual(
+            await outcome(() => read(ReadableStream.from(chunks))),
+            await outcome(() => parse(text)),
+          );
+        },
+      ),
+      { numRuns: 500 },
+    );
+  });
+});
+
+// The tests against rclone, which uses goconfig. RCLONE is the path of rclone,
+// or "rclone" in the PATH.
+const RCLONE = process.env.RCLONE || "rclone";
+const hasRclone = spawnSync(RCLONE, ["version"]).status === 0;
+
+describe("the same as rclone", {
+  skip: !hasRclone && "rclone is not installed. Set RCLONE to its path.",
+}, () => {
+  const folder = mkdtempSync(join(tmpdir(), "rfetch-ini-"));
+  const path = join(folder, "rclone.conf");
+  after(() => rmSync(folder, { recursive: true, force: true }));
+
+  /**
+   * Gives the configuration that rclone reads from the text, or the error of
+   * rclone.
+   * @param {string} text
+   */
+  function rclone(text) {
+    writeFileSync(path, text);
+    const { status, stdout, stderr } = spawnSync(
+      RCLONE,
+      ["--config", path, "config", "dump"],
+      // No RCLONE_* variable of this environment changes the result.
+      { encoding: "utf8", env: { PATH: process.env.PATH, HOME: folder } },
+    );
+    return status === 0 ? { config: JSON.parse(stdout) } : { error: stderr };
+  }
+
+  test("parse reads each file as rclone reads it", () => {
+    fc.assert(
+      fc.property(file, (text) => {
+        const expected = rclone(text);
+        if (expected.error) {
+          assert.match(expected.error, /could not parse line|empty section/);
+          assert.throws(() => parse(text), SyntaxError);
+        } else {
+          // The JSON of rclone has the keys in the order of the alphabet.
+          assert.deepEqual(parse(text), expected.config);
+        }
+      }),
+      { numRuns: 100 },
+    );
+  });
+
+  test("parse reads each line as rclone reads it", () => {
+    fc.assert(
+      fc.property(line, (line) => {
+        const text = `[a]\n${line}\n`;
+        const expected = rclone(text);
+        if (expected.error) {
+          assert.throws(() => parse(text), SyntaxError);
+        } else {
+          assert.deepEqual(parse(text), expected.config);
+        }
+      }),
+      { numRuns: 100 },
+    );
+  });
+
+  test("rclone reads what stringify writes", () => {
+    fc.assert(
+      fc.property(fc.oneof(anyConfig, rcloneConfig), (config) => {
+        let text;
+        try {
+          text = stringify(config);
+        } catch {
+          return;
+        }
+        assert.deepEqual(rclone(text).config, config);
+      }),
+      { numRuns: 100 },
+    );
+  });
 });

From 8a3640475ba9980a95c43bee686e3f14fb1561b1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sat, 17 Oct 2026 02:27:15 +0000
Subject: [PATCH 18/87] fix(config): the remote names of rclone, and 400 for an
 option that the file cannot keep

The old rule for names accepted a line break, and a space at the end. A line break in a name could break the file. Now the rule is fspath.CheckConfigName of rclone.

create and update give 400, and do not change the file, for an option that the file cannot keep, for example a value with a line break. The error is in the body, because a status text cannot have all characters.

show and update find only the own keys of the configuration: the name toString is not a remote.
---
 cmd/config/main.js      | 59 ++++++++++++++++++++++++-----------------
 cmd/config/main_test.js | 28 ++++++++++++++++---
 2 files changed, 60 insertions(+), 27 deletions(-)

diff --git a/cmd/config/main.js b/cmd/config/main.js
index ef9fc66..2787df2 100644
--- a/cmd/config/main.js
+++ b/cmd/config/main.js
@@ -3,7 +3,12 @@ import { env } from "node:process";
 import { join } from "node:path";
 import * as INI from "../../lib/ini.js";
 
-const NAME_REGEX = /^[\w.][\w.\s-]*$/;
+/**
+ * The names of remotes that rclone accepts (`fspath.CheckConfigName`):
+ * letters, numbers, `_`, `-`, `.`, `+`, `@` and space, but not `-` or space
+ * at the start, and not space at the end.
+ */
+export const NAME_REGEX = /^[\w\p{L}\p{N}.+@]+(?:[ -]+[\w\p{L}\p{N}.+@-]+)*$/u;
 
 /**
  * @typedef {Object<string, string>} Options
@@ -66,28 +71,38 @@ export async function config(subcommand, name, options, init) {
    * @type {Object}
    */
   let config = INI.parse(ini);
-  const encodeOptions = { section: "" };
+
+  /**
+   * Writes the config to the file, and answers with the remote. An option
+   * that the file cannot keep, for example a value with a line break, gives
+   * 400 and the file does not change.
+   * @param {Object} config
+   * @param {string} name
+   */
+  async function save(config, name) {
+    let text;
+    try {
+      text = INI.stringify(config);
+    } catch (error) {
+      if (!(error instanceof TypeError)) throw error;
+      return new Response(error.message, { status: 400 });
+    }
+    await writeFile(file, text);
+    return new Response(INI.stringify(config[name], { section: name }));
+  }
 
   switch (subcommand) {
     case "create": { // Create a new remote with name, type and options.
       if (!NAME_REGEX.test(name)) {
-        return new Response(null, {
-          status: 400,
-          statusText: `Invalid remote name: ${name}`,
-        });
+        return new Response(`Invalid remote name: ${name}`, { status: 400 });
       }
       config[name] = options;
-      await writeFile(
-        file,
-        INI.stringify(config, encodeOptions).trim(),
-      );
-      encodeOptions.section = name;
-      return new Response(INI.stringify(config[name], encodeOptions).trim());
+      return await save(config, name);
     }
 
     case "delete": // Delete an existing remote.
       delete config[name];
-      await writeFile(file, INI.stringify(config, encodeOptions).trim());
+      await writeFile(file, INI.stringify(config));
       return new Response();
 
     case "disconnect": // Disconnects user from remote
@@ -107,35 +122,31 @@ export async function config(subcommand, name, options, init) {
 
     case "show": // Print (decrypted) config file, or the config for a single remote.
       if (typeof name === "string") {
-        config = config[name];
-
-        if (!config) {
+        // Only an own key: the name "toString" is not a remote.
+        if (!Object.hasOwn(config, name)) {
           return new Response("", { status: 404 });
         }
-
-        encodeOptions.section = name;
+        config = config[name];
       }
 
       if (new Headers(init?.headers).get("Accept") === "application/json") {
         return Response.json(config);
       }
 
-      return new Response(INI.stringify(config, encodeOptions).trim());
+      return new Response(INI.stringify(config, { section: name }));
 
     case "touch": // Ensure configuration file exists.
     case "update": { // Update options in an existing remote.
       /**
        * @type {Object}
        */
-      const remote = config[name];
-      if (!remote) {
+      if (!Object.hasOwn(config, name)) {
         return new Response("", { status: 404 });
       }
+      const remote = config[name];
 
       Object.assign(remote, options);
-      await writeFile(file, INI.stringify(config, encodeOptions).trim());
-      encodeOptions.section = name;
-      return new Response(INI.stringify(config[name], encodeOptions).trim());
+      return await save(config, name);
     }
 
     case "userinfo": // Prints info about logged in user of remote.
diff --git a/cmd/config/main_test.js b/cmd/config/main_test.js
index 2d1adbd..6c5a215 100644
--- a/cmd/config/main_test.js
+++ b/cmd/config/main_test.js
@@ -4,7 +4,7 @@ import { join } from "node:path";
 import assert from "node:assert/strict";
 import fc from "fast-check";
 
-import { config as configure, config_dir } from "./main.js";
+import { config as configure, config_dir, NAME_REGEX } from "./main.js";
 
 test("config", async (t) => {
   let command = "file";
@@ -34,7 +34,7 @@ test("config", async (t) => {
 
     await fc.assert(
       fc.asyncProperty(fc.string(), async (name) => {
-        fc.pre(!/^[\w.][\w.\s-]*$/.test(name));
+        fc.pre(!NAME_REGEX.test(name));
 
         const response = await configure(command, name, {
           type: "local",
@@ -42,7 +42,7 @@ test("config", async (t) => {
 
         assert(
           !response.ok,
-          "name may only contain 0-9, A-Z, a-z, _, -, . and space, but not start with - or space",
+          "name may only contain letters, numbers, _, -, ., +, @ and space, but not start with - or space, and not end with space",
         );
       }),
     );
@@ -81,6 +81,25 @@ test("config", async (t) => {
     );
   });
 
+  await t.test("the same names as rclone", () => {
+    for (const name of ["a", "a b", "a-b", "a.b+c@d", "_", "世界", "é1"]) {
+      assert.ok(NAME_REGEX.test(name), name);
+    }
+    for (const name of ["", " a", "-a", "a ", "a\nb", "a:b", "a/b", "a=b"]) {
+      assert.ok(!NAME_REGEX.test(name), JSON.stringify(name));
+    }
+  });
+
+  await t.test("400 for an option that the file cannot keep", async () => {
+    const before = await readFile("rclone.conf", { encoding: "utf8" });
+    const response = await configure("create", "broken", {
+      type: "local",
+      key: "line 1\nline 2",
+    });
+    assert.equal(response.status, 400);
+    assert.equal(await readFile("rclone.conf", { encoding: "utf8" }), before);
+  });
+
   command = "show";
   await t.test(command, async () => {
     const config = await readFile("rclone.conf", { encoding: "utf8" });
@@ -112,6 +131,9 @@ test("config", async (t) => {
       "should return 404 when remote not found",
     );
 
+    response = await configure(command, "toString");
+    assert.equal(response.status, 404, "a key of Object is not a remote");
+
     response = await configure(command, "source", undefined, {
       headers: {
         "Accept": "application/json",

From ff5969ad1899f745b4969f33930a1834ff071eda Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sat, 17 Oct 2026 02:27:30 +0000
Subject: [PATCH 19/87] docs: format CONTRIBUTING.md with deno fmt

The note on the tests against rclone had long lines.
---
 CONTRIBUTING.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 095d395..308b95f 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -138,6 +138,6 @@ of the root folder.
 Run all the tests with `npm test`, or the tests of one backend with
 `node --test backend/remote`.
 
-Some tests compare rfetch with rclone, for example the tests of
-`lib/ini.js`. They run when `rclone` is in the `PATH`, or when the variable
-`RCLONE` is the path of rclone. Else they are skipped.
+Some tests compare rfetch with rclone, for example the tests of `lib/ini.js`.
+They run when `rclone` is in the `PATH`, or when the variable `RCLONE` is the
+path of rclone. Else they are skipped.

From 4e52ccd6aa443414a9faaf347cdf0f04ae2bdaad Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sat, 17 Oct 2026 02:54:54 +0000
Subject: [PATCH 20/87] feat(ini): ConfigFile keeps the comments and the text
 of the file

ConfigFile changes only the lines of a change: update, set and delete. All other lines stay as they are: the comments, the empty lines and the format of each line.

A comment directly above a section or a key, with no empty line between, is a comment of that line. It goes away only when that line goes away. All other comments always stay. rclone 1.75.1 does less: when it saves the file, it loses the comments at the end of the file, and a delete of a section also deletes the comments above the section that are for the whole file.

Other changes:

- The entries of ParseStream have a type (section, key or comment) and the number of the line.
- A key that starts with "[" or U+FEFF needs no quotes. A line of a key that starts with "[" must not end with "]", thus its value goes in quotes then. The property tests found such keys, which parse reads but stringify could not write.
- When a key "-" goes away, the keys "-" after it get their numbers as keys in quotes. Thus their numbers do not change.
- The source has escapes in place of invisible characters.

The new property tests:

- ConfigFile keeps the text of each file that parse reads;
- ConfigFile changes the configuration as a model of maps;
- ConfigFile removes only the comments directly above a line that goes away;
- rclone reads the file that ConfigFile changes.
---
 lib/ini.js      | 453 ++++++++++++++++++++++++++++++++++++++++++++----
 lib/ini_test.js | 373 +++++++++++++++++++++++++++++++++++++--
 2 files changed, 783 insertions(+), 43 deletions(-)

diff --git a/lib/ini.js b/lib/ini.js
index 4dbdfeb..b6aef14 100644
--- a/lib/ini.js
+++ b/lib/ini.js
@@ -4,6 +4,7 @@
  * the file:
  *
  * ```ini
+ * # The comments of the person stay in the file.
  * [remote]
  * type = s3
  * provider = Cloudflare
@@ -17,7 +18,8 @@
  *
  * - A line ends with "\n". The white space at the two ends of a line goes
  *   away, with the white space of Go: also U+0085 and U+00A0.
- * - An empty line, and a line that starts with `#` or `;`, give nothing.
+ * - An empty line, and a line that starts with `#` or `;` (a comment), give
+ *   no key.
  * - `[name]` starts a section. The keys before the first section go in the
  *   section `DEFAULT`. Two sections with the same name become one.
  * - `key = value` and `key: value` set a key. The first `=` or `:` is the
@@ -27,6 +29,9 @@
  * - A value in quotes (`` `value` `` or `"""value"""`) keeps its white space.
  *   The value ends at the last quote of the line.
  * - The key `-` gets a number in its section: `#1`, then `#2`, and so on.
+ *
+ * `parse` and `read` give the configuration. `ConfigFile` changes the
+ * configuration in the text of a file, and keeps the comments.
  */
 
 /** The section of the keys before the first section. */
@@ -36,13 +41,29 @@ export const DEFAULT = "DEFAULT";
 const SPACE =
   "[\\t\\n\\v\\f\\r \\u0085\\u00A0\\u1680\\u2000-\\u200A\\u2028\\u2029\\u202F\\u205F\\u3000]";
 const TRIM = new RegExp(`^${SPACE}+|${SPACE}+$`, "g");
+const TRIM_START = new RegExp(`^${SPACE}+`);
+
+/** The byte order mark, which goconfig removes at the start of the file. */
+const BOM = "\uFEFF";
 
 const encoder = new TextEncoder();
 
 /**
- * An item of a configuration file: the start of a section, or a key and its
- * value in a section.
- * @typedef {{ section: string, key?: string, value?: string }} Entry
+ * An item of a line of a configuration file. An empty line has no entry.
+ *
+ * - A `section` entry starts a section. The section `[]` has the name "":
+ *   goconfig makes it the section DEFAULT, but it cannot have keys.
+ * - A `key` entry has a key and its value. `auto` is true for a key `-`.
+ *   goconfig ignores the key "", and the key " " only makes the section.
+ * - A `comment` entry has the text of the comment, with its `#` or `;`.
+ *
+ * `section` is the current section of the line, and `line` is the number of
+ * the line, from 1.
+ * @typedef {{ section: string, line: number } & (
+ *   { type: "section" } |
+ *   { type: "key", key: string, value: string, auto?: true } |
+ *   { type: "comment", text: string }
+ * )} Entry
  */
 
 /**
@@ -81,7 +102,7 @@ export async function read(stream) {
 
 /**
  * A stream that reads the text of a configuration file, in chunks of any
- * size, and gives an entry for each section and for each key, line by line.
+ * size, and gives an entry for each line with a section, a key or a comment.
  * It keeps only the part of a line that has no "\n" yet. A line that goconfig
  * does not accept makes an error of the stream.
  * @extends {TransformStream<string, Entry>}
@@ -107,12 +128,296 @@ export class ParseStream extends TransformStream {
   }
 }
 
+/**
+ * The text of a configuration file, which changes only on the lines of a
+ * change. All other lines stay as they are: the comments, the empty lines and
+ * the format of each line.
+ *
+ * A comment directly above a section or a key, with no empty line between,
+ * is a comment of that line. It goes away only when that line goes away. All
+ * other comments always stay.
+ */
+export class ConfigFile {
+  #bom = false;
+  /** @type {Array<{ text: string, entry?: Entry, delimiter: number }>} */
+  #lines = [];
+  /** "\r" when the lines of the file end with "\r\n". */
+  #eol = "";
+
+  /**
+   * @param {string} [text] The text of the file.
+   * @throws {SyntaxError} For a line that goconfig does not accept.
+   */
+  constructor(text = "") {
+    this.#load(text);
+  }
+
+  /** @returns {Config} */
+  get config() {
+    const config = new ConfigBuilder();
+    for (const { entry } of this.#lines) {
+      config.add(entry);
+    }
+    return config.value;
+  }
+
+  /** @returns {string} The text of the file. */
+  toString() {
+    const text = this.#lines.map(({ text }) => text).join("\n");
+    // A line that starts with U+FEFF needs a byte order mark before it when
+    // it is the first line.
+    return this.#bom || text.startsWith(BOM) ? BOM + text : text;
+  }
+
+  /**
+   * Sets the keys of a section, and makes the section when it does not
+   * exist. A key with no value (undefined or null) goes away. The other keys
+   * stay.
+   * @param {string} name
+   * @param {Record<string, unknown>} keys
+   * @throws {TypeError} For a name, a key or a value that rclone cannot read
+   *   back the same, as `stringify`. Then the file does not change.
+   */
+  update(name, keys) {
+    this.#change(name, keys, false);
+  }
+
+  /**
+   * Sets the keys of a section as `update`, and removes the other keys of
+   * the section.
+   * @param {string} name
+   * @param {Record<string, unknown>} keys
+   * @throws {TypeError} As `update`.
+   */
+  set(name, keys) {
+    this.#change(name, keys, true);
+  }
+
+  /**
+   * Removes a section: all its lines, and their comments.
+   * @param {string} name
+   */
+  delete(name) {
+    const remove = new Set();
+    for (const [index, { entry }] of this.#lines.entries()) {
+      if (entry && entry.type !== "comment" && sectionOf(entry) === name) {
+        remove.add(index);
+      }
+    }
+    if (remove.size) {
+      this.#write({ remove });
+    }
+  }
+
+  /**
+   * @param {string} name
+   * @param {Record<string, unknown>} keys
+   * @param {boolean} replace True to remove the keys that are not in `keys`.
+   */
+  #change(name, keys, replace) {
+    const lines = this.#lines;
+    /** Tells if a line has a key of the section. */
+    const isKey = (index) => {
+      const entry = lines[index].entry;
+      return entry?.type === "key" && sectionOf(entry) === name &&
+        entry.key !== "" && entry.key !== " ";
+    };
+
+    /** @type {Set<number>} */
+    const remove = new Set();
+    /** @type {Map<number, string>} The new values of lines. */
+    const values = new Map();
+    /** @type {string[]} The lines of the new keys. */
+    const added = [];
+
+    for (const [key, value] of Object.entries(keys)) {
+      const indexes = [...lines.keys()].filter((index) =>
+        isKey(index) && lines[index].entry.key === key
+      );
+      if (value === undefined || value === null) {
+        for (const index of indexes) remove.add(index);
+      } else if (indexes.length) {
+        // The last line of a key gives its value.
+        const index = indexes.at(-1);
+        withValue(lines[index], `${value}`);
+        if (lines[index].entry.value !== `${value}`) {
+          values.set(index, `${value}`);
+        }
+      } else {
+        added.push(writeLine(key, `${value}`) + this.#eol);
+      }
+    }
+    if (replace) {
+      for (const index of lines.keys()) {
+        if (!isKey(index)) continue;
+        const { key } = lines[index].entry;
+        // Only own keys: the key "toString" is not in `{}`.
+        if ((Object.hasOwn(keys, key) ? keys[key] : null) == null) {
+          remove.add(index);
+        }
+      }
+    }
+
+    if (!Object.hasOwn(this.config, name)) {
+      const header = `[${writeSection(name)}]${this.#eol}`;
+      this.#write({ remove, values, section: [header, ...added] });
+      return;
+    }
+
+    /** @type {Map<number, string[]>} */
+    const insert = new Map();
+    /** @type {Map<number, string>} */
+    const texts = new Map();
+
+    // The new keys go after the last line of the section that stays.
+    const after = lines.findLastIndex(({ entry }, index) =>
+      entry && entry.type !== "comment" && sectionOf(entry) === name &&
+      !(entry.type === "key" && entry.key === "") && !remove.has(index)
+    );
+
+    // DEFAULT has no `[DEFAULT]` line when its keys are at the start of the
+    // file. When all of them go away, a `[DEFAULT]` line in the place of the
+    // first one keeps the place of the section.
+    const top = lines.findIndex(({ entry }) => entry?.type === "section");
+    const atTop = [...lines.keys()].filter((index) =>
+      (top === -1 || index < top) && lines[index].entry?.type === "key" &&
+      lines[index].entry.key !== ""
+    );
+    if (
+      name === DEFAULT && atTop.length &&
+      atTop.every((index) => remove.has(index))
+    ) {
+      const header = `[${DEFAULT}]${this.#eol}`;
+      insert.set(atTop[0] - 1, after === -1 ? [header, ...added] : [header]);
+    }
+
+    if (after !== -1) {
+      insert.set(after, added);
+      // The section `[]` cannot have keys, but `[DEFAULT]` can.
+      const { entry, text } = lines[after];
+      if (added.length && entry.type === "section" && entry.section === "") {
+        texts.set(after, `[${DEFAULT}]${eolOf(text)}`);
+      }
+    }
+
+    this.#write({ remove, values, texts, insert });
+  }
+
+  /**
+   * Writes the new text of the file, and reads it again.
+   * @param {object} change
+   * @param {Set<number>} change.remove The lines to remove, with their
+   *   comments.
+   * @param {Map<number, string>} [change.values] The new values of lines.
+   * @param {Map<number, string>} [change.texts] The new texts of lines.
+   * @param {Map<number, string[]>} [change.insert] The lines to put after a
+   *   line, or at the start for -1.
+   * @param {string[]} [change.section] A new section for the end.
+   */
+  #write({
+    remove,
+    values = new Map(),
+    texts = new Map(),
+    insert = new Map(),
+    section = [],
+  }) {
+    const lines = this.#lines;
+
+    // A comment directly above a line that goes away goes away too.
+    for (const index of [...remove]) {
+      for (
+        let above = index - 1;
+        lines[above]?.entry?.type === "comment";
+        above--
+      ) {
+        remove.add(above);
+      }
+    }
+
+    // A key `-` gets its number from the keys `-` before it in its part of
+    // the section. When one goes away, the keys `-` after it get their
+    // number as a key in quotes.
+    const explicit = new Set();
+    let shift = false;
+    for (const [index, { entry }] of lines.entries()) {
+      if (entry?.type === "section") shift = false;
+      if (entry?.type !== "key" || !entry.auto) continue;
+      if (remove.has(index)) shift = true;
+      else if (shift) explicit.add(index);
+    }
+
+    const result = [...insert.get(-1) ?? []];
+    let removed = false;
+    for (const [index, line] of lines.entries()) {
+      if (!remove.has(index)) {
+        // Two empty lines do not come together where lines went away.
+        const blank = !line.entry && trim(line.text) === "";
+        if (
+          !(blank && removed && (!result.length || trim(result.at(-1)) === ""))
+        ) {
+          result.push(this.#text(index, values, texts, explicit.has(index)));
+        }
+        removed = false;
+      } else {
+        removed = true;
+      }
+      if (insert.get(index)?.length) {
+        result.push(...insert.get(index));
+        removed = false;
+      }
+    }
+
+    if (section.length) {
+      // The new section goes at the end, before the empty end of the file,
+      // after an empty line.
+      let end = result.length;
+      if (end && result[end - 1] === "") end--;
+      if (end && trim(result[end - 1]) !== "") section.unshift(this.#eol);
+      result.splice(end, 0, ...section);
+    }
+
+    const text = result.join("\n");
+    this.#load(this.#bom || text.startsWith(BOM) ? BOM + text : text);
+  }
+
+  /**
+   * The new text of a line.
+   * @param {number} index
+   * @param {Map<number, string>} values
+   * @param {Map<number, string>} texts
+   * @param {boolean} explicit True to write the number of a key `-`.
+   */
+  #text(index, values, texts, explicit) {
+    const line = this.#lines[index];
+    const { entry } = line;
+    if (explicit) {
+      const value = values.get(index) ?? entry.value;
+      return writeLine(entry.key, value) + eolOf(line.text);
+    }
+    if (values.has(index)) {
+      return withValue(line, values.get(index));
+    }
+    return texts.get(index) ?? line.text;
+  }
+
+  /** @param {string} text */
+  #load(text) {
+    this.#bom = text.startsWith(BOM);
+    const reader = new LineReader({ bom: false });
+    this.#lines = (this.#bom ? text.slice(1) : text).split("\n").map((
+      text,
+    ) => ({ text, entry: reader.read(text), delimiter: reader.delimiter }));
+    this.#eol = this.#lines.some(({ text }) => text.endsWith("\r")) ? "\r" : "";
+  }
+}
+
 /**
  * Writes a configuration file that rclone reads as the same configuration.
  * The keys of the section `DEFAULT` come first with no `[DEFAULT]` line, when
  * `DEFAULT` is the first section. Then each section comes, with an empty line
  * between the sections, as rclone writes them. A key with no value
- * (undefined or null) is not written.
+ * (undefined or null) is not written. To keep the comments of a file, use
+ * `ConfigFile`.
  *
  * A key or a value goes in quotes when rclone does not read it the same with
  * no quotes, for example a value with a space at the start. In some of these
@@ -139,7 +444,7 @@ export function stringify(config, { section } = {}) {
     }
     const lines = Object.entries(keys)
       .filter(([, value]) => value !== undefined && value !== null)
-      .map(([key, value]) => `${writeKey(key)} = ${writeValue(`${value}`)}`);
+      .map(([key, value]) => writeLine(key, `${value}`));
 
     if (name === DEFAULT && index === 0 && lines.length) {
       blocks.push(lines);
@@ -147,7 +452,10 @@ export function stringify(config, { section } = {}) {
       blocks.push([`[${writeSection(name)}]`, ...lines]);
     }
   }
-  return blocks.map((lines) => lines.join("\n")).join("\n\n");
+  const text = blocks.map((lines) => lines.join("\n")).join("\n\n");
+  // A key that starts with U+FEFF needs a byte order mark before it when it
+  // is the first line.
+  return text.startsWith(BOM) ? BOM + text : text;
 }
 
 /**
@@ -159,29 +467,52 @@ class LineReader {
   /** The number of the next key `-` in the section. */
   #count = 1;
   #number = 0;
+  #bom;
+
+  /**
+   * The position of the `=` or `:` after the key in the last line, or -1
+   * when the last line has no key.
+   */
+  delimiter = -1;
+
+  /**
+   * @param {{ bom?: boolean }} [options] `bom: false` keeps a byte order mark
+   *   at the start of the first line.
+   */
+  constructor({ bom = true } = {}) {
+    this.#bom = bom;
+  }
 
   /**
    * Reads one line, with no "\n".
-   * @param {string} text
+   * @param {string} raw
    * @returns {Entry | undefined}
    */
-  read(text) {
+  read(raw) {
     this.#number++;
-    // goconfig removes the byte order mark at the start of the file.
-    if (this.#number === 1 && text.startsWith("")) {
+    this.delimiter = -1;
+    let text = raw;
+    if (this.#bom && this.#number === 1 && text.startsWith(BOM)) {
       text = text.slice(1);
     }
 
     const line = trim(text);
-    if (line === "" || line[0] === "#" || line[0] === ";") {
+    if (line === "") {
       return;
     }
+    if (line[0] === "#" || line[0] === ";") {
+      return {
+        type: "comment",
+        section: this.#section,
+        line: this.#number,
+        text: line,
+      };
+    }
 
     if (line[0] === "[" && line.at(-1) === "]") {
       this.#section = trim(line.slice(1, -1));
       this.#count = 1;
-      // The section `[]` is the section DEFAULT, but it cannot have keys.
-      return { section: this.#section || DEFAULT };
+      return { type: "section", section: this.#section, line: this.#number };
     }
 
     if (this.#section === "") {
@@ -209,8 +540,17 @@ class LineReader {
       throw this.#error('has no "=" or ":" after a key');
     }
 
+    /** @type {Entry} */
+    const entry = {
+      type: "key",
+      section: this.#section,
+      line: this.#number,
+      key,
+      value: "",
+    };
     if (key === "-") {
-      key = `#${this.#count++}`;
+      entry.key = `#${this.#count++}`;
+      entry.auto = true;
     }
 
     let value = trim(line.slice(end + 1));
@@ -226,12 +566,11 @@ class LineReader {
       }
       value = value.slice(valueQuote.length, close);
     }
+    entry.value = value;
 
-    // goconfig ignores an empty key. The key " " marks that a section
-    // exists, thus it is not a key.
-    if (key === "") return;
-    if (key === " ") return { section: this.#section };
-    return { section: this.#section, key, value };
+    // The line starts after the byte order mark and the white space.
+    this.delimiter = raw.length - text.replace(TRIM_START, "").length + end;
+    return entry;
   }
 
   /**
@@ -244,20 +583,27 @@ class LineReader {
   }
 }
 
-/** Makes the configuration from the entries, in the order of the file. */
+/**
+ * Makes the configuration from the entries, in the order of the file, as
+ * `ConfigFile.SetValue` of goconfig.
+ */
 class ConfigBuilder {
   /** @type {Map<string, Map<string, string>>} */
   #sections = new Map();
 
   /** @param {Entry | undefined} entry */
   add(entry) {
-    if (!entry) return;
-    const { section, key, value } = entry;
+    if (!entry || entry.type === "comment") return;
+    // goconfig ignores an empty key.
+    if (entry.type === "key" && entry.key === "") return;
+
+    const section = sectionOf(entry);
     if (!this.#sections.has(section)) {
       this.#sections.set(section, new Map());
     }
-    if (key !== undefined) {
-      this.#sections.get(section).set(key, value);
+    // The key " " only makes the section.
+    if (entry.type === "key" && entry.key !== " ") {
+      this.#sections.get(section).set(entry.key, entry.value);
     }
   }
 
@@ -274,6 +620,55 @@ class ConfigBuilder {
   }
 }
 
+/**
+ * The section of an entry. The section `[]` is DEFAULT.
+ * @param {Entry} entry
+ */
+function sectionOf(entry) {
+  return entry.section || DEFAULT;
+}
+
+/**
+ * The line with a new value, with no change to the key and the `=` or `:`.
+ * @param {{ text: string, delimiter: number }} line
+ * @param {string} value
+ */
+function withValue({ text, delimiter }, value) {
+  const head = text.slice(0, delimiter + 1);
+  const after = text.slice(delimiter + 1);
+  const space = after === "" || TRIM_START.test(after) ? " " : "";
+  return head + space + writeLineValue(head, value) + eolOf(text);
+}
+
+/**
+ * Writes the line of a key and its value.
+ * @param {string} key
+ * @param {string} value
+ */
+function writeLine(key, value) {
+  const head = `${writeKey(key)} =`;
+  return `${head} ${writeLineValue(head, value)}`;
+}
+
+/**
+ * Writes the value of a line. A line that starts with "[" and ends with "]"
+ * is a section for goconfig, thus the value goes in quotes then.
+ * @param {string} head The line before the value.
+ * @param {string} value
+ */
+function writeLineValue(head, value) {
+  const written = writeValue(value);
+  if (trim(head).startsWith("[") && written.endsWith("]")) {
+    return `\`${value}\``;
+  }
+  return written;
+}
+
+/** "\r" when the line ends with "\r". @param {string} text */
+function eolOf(text) {
+  return text.endsWith("\r") ? "\r" : "";
+}
+
 /**
  * Writes a section name, which goconfig reads with no white space at its two
  * ends.
@@ -300,9 +695,9 @@ function writeKey(key) {
       `INI: the key ${JSON.stringify(key)} cannot be written.`,
     );
   }
-  // A key at the start of the file must not start with U+FEFF, which is
-  // the byte order mark there.
-  if (trim(key) === key && !/^[#;"`[\uFEFF]|[=:]/.test(key)) {
+  // A key that starts with "[" needs care for its value: see
+  // writeLineValue.
+  if (trim(key) === key && !/^[#;"`]|[=:]/.test(key)) {
     return key;
   }
   if (!key.includes("`")) {
diff --git a/lib/ini_test.js b/lib/ini_test.js
index e0aa44c..a5c4861 100644
--- a/lib/ini_test.js
+++ b/lib/ini_test.js
@@ -7,7 +7,7 @@ import { join } from "node:path";
 import process from "node:process";
 import fc from "fast-check";
 
-import { parse, ParseStream, read, stringify } from "./ini.js";
+import { ConfigFile, parse, ParseStream, read, stringify } from "./ini.js";
 
 describe("parse", () => {
   test("reads sections and keys", () => {
@@ -77,7 +77,7 @@ describe("parse", () => {
   });
 
   test("removes the white space of Go and the byte order mark", () => {
-    assert.deepEqual(parse("[a]\u0085\n k = v　\r\n"), {
+    assert.deepEqual(parse("\uFEFF[a]\u0085\n\u00A0k = v\u3000\r\n"), {
       a: { k: "v" },
     });
   });
@@ -143,10 +143,11 @@ describe("stringify", () => {
           "k`:": "a`b",
           'k`"=': '"""x',
           "k5": '"q"',
+          "[k6": "v]",
         },
       }),
       '[a]\n`k=1` = `  v  `\n`#k` = """a"`b"""\n"k`:" = """a`b"""\n' +
-        '"""k`"=""" = `"""x`\nk5 = "q"',
+        '"""k`"=""" = `"""x`\nk5 = "q"\n[k6 = `v]`',
     );
   });
 
@@ -170,20 +171,137 @@ describe("stringify", () => {
   });
 });
 
-test("ParseStream gives an entry for each section and each key", async () => {
+test("ParseStream gives an entry for each line with a section, a key or a comment", async () => {
   const entries = await Array.fromAsync(
-    ReadableStream.from(["top = 1\n[a", "]\nk = v\n- = x", "\n[b]"])
+    ReadableStream.from(["top = 1\n[a", "]\n# note\nk = v\n\n- = x", "\n[]"])
       .pipeThrough(new ParseStream()),
   );
   assert.deepEqual(entries, [
-    { section: "DEFAULT", key: "top", value: "1" },
-    { section: "a" },
-    { section: "a", key: "k", value: "v" },
-    { section: "a", key: "#1", value: "x" },
-    { section: "b" },
+    { type: "key", section: "DEFAULT", line: 1, key: "top", value: "1" },
+    { type: "section", section: "a", line: 2 },
+    { type: "comment", section: "a", line: 3, text: "# note" },
+    { type: "key", section: "a", line: 4, key: "k", value: "v" },
+    { type: "key", section: "a", line: 6, key: "#1", value: "x", auto: true },
+    { type: "section", section: "", line: 7 },
   ]);
 });
 
+describe("ConfigFile", () => {
+  const text = [
+    "# The remotes of the person.",
+    "",
+    "# The disk at work.",
+    "[work]",
+    "type: drive",
+    "# A note on the token.",
+    "token = {}",
+    "",
+    "[home]",
+    "type = local",
+    "# The last comment.",
+    "",
+  ].join("\n");
+
+  test("keeps the text when nothing changes", () => {
+    const file = new ConfigFile(text);
+    assert.equal(file.toString(), text);
+    assert.deepEqual(file.config, parse(text));
+  });
+
+  test("changes only the value of a key, and keeps the comments", () => {
+    const file = new ConfigFile(text);
+    file.update("work", { type: "s3", token: "{}" });
+    assert.equal(file.toString(), text.replace("type: drive", "type: s3"));
+  });
+
+  test("puts a new key after the last key of the section", () => {
+    const file = new ConfigFile(text);
+    file.update("home", { "a b": "  x  " });
+    assert.equal(
+      file.toString(),
+      text.replace("type = local", "type = local\na b = `  x  `"),
+    );
+  });
+
+  test("puts a new section at the end, after an empty line", () => {
+    const file = new ConfigFile(text);
+    file.update("new", { type: "memory" });
+    assert.equal(file.toString(), `${text}\n[new]\ntype = memory\n`);
+    assert.equal(
+      new ConfigFile("[a]").toString(),
+      "[a]",
+    );
+    const empty = new ConfigFile("");
+    empty.set("a", { type: "local" });
+    assert.equal(empty.toString(), "[a]\ntype = local\n");
+  });
+
+  test("removes a key with its comment, and keeps the other comments", () => {
+    const file = new ConfigFile(text);
+    file.update("work", { token: null });
+    assert.equal(
+      file.toString(),
+      text.replace("# A note on the token.\ntoken = {}\n", ""),
+    );
+
+    const again = new ConfigFile(text);
+    again.set("work", { type: "drive" });
+    assert.equal(again.toString(), file.toString());
+  });
+
+  test("removes a section with its comments, but not the other comments", () => {
+    const file = new ConfigFile(text);
+    file.delete("work");
+    assert.equal(
+      file.toString(),
+      "# The remotes of the person.\n\n[home]\ntype = local\n# The last comment.\n",
+    );
+    // The last comment has an empty line below it, thus it stays.
+    file.delete("home");
+    assert.equal(
+      file.toString(),
+      "# The remotes of the person.\n\n# The last comment.\n",
+    );
+  });
+
+  test("keeps the numbers of the keys -", () => {
+    const file = new ConfigFile("[a]\n- = x\n- = y\n- = z");
+    file.update("a", { "#1": null, "#3": "Z" });
+    assert.equal(file.toString(), "[a]\n`#2` = y\n`#3` = Z");
+    assert.deepEqual(file.config, { a: { "#2": "y", "#3": "Z" } });
+  });
+
+  test("keeps the place of DEFAULT", () => {
+    const top = new ConfigFile("x = 1\n[a]");
+    top.set("DEFAULT", { y: "2" });
+    assert.equal(top.toString(), "[DEFAULT]\ny = 2\n[a]");
+
+    const empty = new ConfigFile("[]\n[a]");
+    empty.update("DEFAULT", { y: "2" });
+    assert.equal(empty.toString(), "[DEFAULT]\ny = 2\n[a]");
+  });
+
+  test("keeps the ends of lines and the byte order mark", () => {
+    const file = new ConfigFile("\uFEFF[a]\r\nk = v\r\n");
+    file.update("a", { k: "w", n: "1" });
+    assert.equal(file.toString(), "\uFEFF[a]\r\nk = w\r\nn = 1\r\n");
+  });
+
+  test("does not change for what rclone cannot read the same", () => {
+    const file = new ConfigFile(text);
+    for (
+      const change of [
+        () => file.update("work", { type: "line 1\nline 2" }),
+        () => file.update("work", { "-": "x" }),
+        () => file.set(" bad name", {}),
+      ]
+    ) {
+      assert.throws(change, TypeError);
+      assert.equal(file.toString(), text);
+    }
+  });
+});
+
 // The generators for the properties.
 
 /** Pieces of text with the characters that have a meaning for goconfig. */
@@ -202,9 +320,9 @@ const PIECES = [
   "\t",
   "\r",
   "\u0085",
-  " ",
-  "　",
-  "",
+  "\u00A0",
+  "\u3000",
+  "\uFEFF",
   "é",
   "€",
   "😀",
@@ -254,13 +372,14 @@ const line = fc.oneof(
     arbitrary: fc.tuple(key, quote, text)
       .map(([key, q, value]) => `${key} = ${q}${value}`),
   },
+  { weight: 1, arbitrary: text.map((value) => `- = ${value}`) },
   { weight: 1, arbitrary: text.map((comment) => `# ${comment}`) },
   { weight: 1, arbitrary: text },
 );
 
 /** The text of a configuration file. */
 const file = fc.tuple(
-  fc.constantFrom("", ""),
+  fc.constantFrom("", "\uFEFF"),
   fc.array(fc.tuple(line, fc.constantFrom("\n", "\r\n")), { maxLength: 10 }),
 ).map(([start, lines]) =>
   start + lines.map(([line, end]) => line + end).join("")
@@ -329,6 +448,112 @@ async function outcome(read) {
   }
 }
 
+/**
+ * A file that parse reads, and changes for it: the names and the keys are
+ * often names and keys of the file.
+ */
+const edited = file.chain((source) => {
+  let config;
+  try {
+    config = parse(source);
+  } catch {
+    return fc.constant(null);
+  }
+  const names = Object.keys(config);
+  const keys = [...new Set(Object.values(config).flatMap(Object.keys))];
+  const name = fc.oneof(
+    ...(names.length ? [fc.constantFrom(...names)] : []),
+    fc.constant("DEFAULT"),
+    text,
+  );
+  const changes = fc.uniqueArray(
+    fc.tuple(
+      keys.length ? fc.oneof(fc.constantFrom(...keys), key) : key,
+      fc.option(text, { nil: null, freq: 3 }),
+    ),
+    { selector: ([key]) => key, maxLength: 4 },
+  ).map((entries) => Object.fromEntries(entries));
+  const change = fc.oneof(
+    fc.record({ type: fc.constantFrom("update", "set"), name, keys: changes }),
+    fc.record({ type: fc.constant("delete"), name }),
+  );
+  return fc.record({
+    text: fc.constant(source),
+    changes: fc.array(change, { maxLength: 4 }),
+  });
+}).filter((value) => value !== null);
+
+/**
+ * Makes a change in a ConfigFile, and in a model of the configuration with
+ * maps. A change that throws a TypeError must not change the file, and does
+ * not change the model.
+ * @param {ConfigFile} file
+ * @param {Map<string, Map<string, string>>} model
+ * @param {{ type: string, name: string, keys?: Record<string, ?string> }} change
+ */
+function change(file, model, { type, name, keys }) {
+  const before = file.toString();
+  try {
+    if (type === "delete") file.delete(name);
+    else file[type](name, keys);
+  } catch (error) {
+    assert.ok(error instanceof TypeError, error);
+    assert.equal(
+      file.toString(),
+      before,
+      "a change that throws changes nothing",
+    );
+    return false;
+  }
+
+  if (type === "delete") {
+    model.delete(name);
+    return true;
+  }
+  const old = model.get(name) ?? new Map();
+  const next = new Map(old);
+  if (type === "set") {
+    for (const key of old.keys()) {
+      if ((Object.hasOwn(keys, key) ? keys[key] : null) === null) {
+        next.delete(key);
+      }
+    }
+  }
+  for (const [key, value] of Object.entries(keys)) {
+    if (value === null) next.delete(key);
+    else next.set(key, value);
+  }
+  model.set(name, next);
+  return true;
+}
+
+/** @param {Record<string, Record<string, string>>} config */
+function toModel(config) {
+  return new Map(
+    Object.entries(config).map((
+      [name, keys],
+    ) => [name, new Map(Object.entries(keys))]),
+  );
+}
+
+/** @param {Map<string, Map<string, string>>} model */
+function fromModel(model) {
+  return Object.fromEntries(
+    [...model].map(([name, keys]) => [name, Object.fromEntries(keys)]),
+  );
+}
+
+/**
+ * The entries of each line of a text, by the number of the line.
+ * @param {string} text
+ */
+async function entriesOf(text) {
+  const entries = await Array.fromAsync(
+    ReadableStream.from([text]).pipeThrough(new ParseStream()),
+  );
+  return new Map(entries.map((entry) => [entry.line, entry]));
+}
+
 describe("properties", () => {
   test("parse reads what stringify writes, or stringify throws", () => {
     fc.assert(
@@ -371,6 +596,112 @@ describe("properties", () => {
     );
   });
 
+  test("ConfigFile keeps the text of each file that parse reads", () => {
+    fc.assert(
+      fc.property(file, (text) => {
+        let config;
+        try {
+          config = parse(text);
+        } catch {
+          return;
+        }
+        const configFile = new ConfigFile(text);
+        assert.equal(configFile.toString(), text);
+        assert.deepEqual(ordered(configFile.config), ordered(config));
+      }),
+      { numRuns: 1000 },
+    );
+  });
+
+  test("ConfigFile changes the configuration as a model of maps", () => {
+    fc.assert(
+      fc.property(edited, ({ text, changes }) => {
+        const configFile = new ConfigFile(text);
+        const model = toModel(configFile.config);
+        for (const item of changes) {
+          change(configFile, model, item);
+          const expected = ordered(fromModel(model));
+          assert.deepEqual(ordered(configFile.config), expected);
+          assert.deepEqual(ordered(parse(configFile.toString())), expected);
+        }
+      }),
+      { numRuns: 1000 },
+    );
+  });
+
+  test("ConfigFile does not throw for the changes that rclone makes", () => {
+    fc.assert(
+      fc.property(
+        rcloneConfig,
+        fc.array(fc.tuple(fc.boolean(), fc.boolean()), { maxLength: 4 }),
+        (config, steps) => {
+          const configFile = new ConfigFile();
+          const model = new Map();
+          const names = Object.keys(config);
+          for (const [index, [set, remove]] of steps.entries()) {
+            const name = names[index % names.length];
+            if (name === undefined) break;
+            const item = remove
+              ? { type: "delete", name }
+              : { type: set ? "set" : "update", name, keys: config[name] };
+            assert.ok(change(configFile, model, item), "no TypeError");
+          }
+          assert.deepEqual(
+            ordered(configFile.config),
+            ordered(fromModel(model)),
+          );
+        },
+      ),
+      { numRuns: 500 },
+    );
+  });
+
+  test("ConfigFile removes only the comments directly above a line that goes away", async () => {
+    await fc.assert(
+      fc.asyncProperty(
+        edited.filter(({ changes }) => changes.length > 0),
+        async ({ text, changes: [item] }) => {
+          const before = await entriesOf(text);
+          const configFile = new ConfigFile(text);
+          const changed = change(configFile, toModel(configFile.config), item);
+
+          /** Tells if the line of an entry goes away with the change. */
+          const goes = (entry) => {
+            if (!changed || entry.type === "comment") return false;
+            const section = entry.section || "DEFAULT";
+            if (item.type === "delete") return section === item.name;
+            if (entry.type !== "key" || section !== item.name) return false;
+            if (entry.key === "" || entry.key === " ") return false;
+            const value = Object.hasOwn(item.keys, entry.key)
+              ? item.keys[entry.key]
+              : undefined;
+            return value === null ||
+              (item.type === "set" && value === undefined);
+          };
+
+          const lines = text.split("\n").length;
+          const expected = [];
+          for (const entry of before.values()) {
+            if (entry.type !== "comment") continue;
+            // The comment is of the first line below it that is not a
+            // comment, when that line is not empty.
+            let below = entry.line + 1;
+            while (before.get(below)?.type === "comment") below++;
+            const target = below <= lines ? before.get(below) : undefined;
+            if (!target || !goes(target)) expected.push(entry.text);
+          }
+
+          const after = await entriesOf(configFile.toString());
+          const comments = [...after.values()]
+            .filter(({ type }) => type === "comment")
+            .map(({ text }) => text);
+          assert.deepEqual(comments, expected);
+        },
+      ),
+      { numRuns: 1000 },
+    );
+  });
+
   test("read gives the result of parse, for each split of the text", async () => {
     await fc.assert(
       fc.asyncProperty(
@@ -473,4 +804,18 @@ describe("the same as rclone", {
       { numRuns: 100 },
     );
   });
+  test("rclone reads the file that ConfigFile changes", () => {
+    fc.assert(
+      fc.property(edited, ({ text, changes }) => {
+        const configFile = new ConfigFile(text);
+        const model = toModel(configFile.config);
+        for (const item of changes) change(configFile, model, item);
+        assert.deepEqual(
+          rclone(configFile.toString()).config,
+          fromModel(model),
+        );
+      }),
+      { numRuns: 50 },
+    );
+  });
 });

From d7bbb4bc80df0170d9c07ca83edcf3518d53f693 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sat, 17 Oct 2026 02:54:54 +0000
Subject: [PATCH 21/87] fix(config): keep the comments of the person in the
 file

create, update and delete change the file with ConfigFile. show with no name gives the whole file with its comments, as rclone config show does.

The tests use a new folder as the current folder and as the home folder. Before, they wrote rclone.conf in the folder of the repository, as main_test.js does, and the two test files ran at the same time.
---
 cmd/config/main.js      | 34 ++++++++++++++++---------------
 cmd/config/main_test.js | 45 +++++++++++++++++++++++++++++++++++------
 2 files changed, 57 insertions(+), 22 deletions(-)

diff --git a/cmd/config/main.js b/cmd/config/main.js
index 2787df2..1eaebf9 100644
--- a/cmd/config/main.js
+++ b/cmd/config/main.js
@@ -67,28 +67,30 @@ export async function config(subcommand, name, options, init) {
     }
   }
 
+  const configFile = new INI.ConfigFile(ini);
   /**
    * @type {Object}
    */
-  let config = INI.parse(ini);
+  let config = configFile.config;
 
   /**
-   * Writes the config to the file, and answers with the remote. An option
+   * Changes the file, and answers with the remote. The other lines of the
+   * file do not change, thus the comments of the person stay. An option
    * that the file cannot keep, for example a value with a line break, gives
    * 400 and the file does not change.
-   * @param {Object} config
+   * @param {(configFile: INI.ConfigFile) => void} change
    * @param {string} name
    */
-  async function save(config, name) {
-    let text;
+  async function save(change, name) {
     try {
-      text = INI.stringify(config);
+      change(configFile);
     } catch (error) {
       if (!(error instanceof TypeError)) throw error;
       return new Response(error.message, { status: 400 });
     }
-    await writeFile(file, text);
-    return new Response(INI.stringify(config[name], { section: name }));
+    await writeFile(file, configFile.toString());
+    const remote = configFile.config[name];
+    return new Response(INI.stringify(remote, { section: name }));
   }
 
   switch (subcommand) {
@@ -96,13 +98,12 @@ export async function config(subcommand, name, options, init) {
       if (!NAME_REGEX.test(name)) {
         return new Response(`Invalid remote name: ${name}`, { status: 400 });
       }
-      config[name] = options;
-      return await save(config, name);
+      return await save((configFile) => configFile.set(name, options), name);
     }
 
     case "delete": // Delete an existing remote.
-      delete config[name];
-      await writeFile(file, INI.stringify(config));
+      configFile.delete(name);
+      await writeFile(file, configFile.toString());
       return new Response();
 
     case "disconnect": // Disconnects user from remote
@@ -133,6 +134,10 @@ export async function config(subcommand, name, options, init) {
         return Response.json(config);
       }
 
+      // The whole file, with its comments, as `rclone config show`.
+      if (typeof name !== "string") {
+        return new Response(configFile.toString());
+      }
       return new Response(INI.stringify(config, { section: name }));
 
     case "touch": // Ensure configuration file exists.
@@ -143,10 +148,7 @@ export async function config(subcommand, name, options, init) {
       if (!Object.hasOwn(config, name)) {
         return new Response("", { status: 404 });
       }
-      const remote = config[name];
-
-      Object.assign(remote, options);
-      return await save(config, name);
+      return await save((configFile) => configFile.update(name, options), name);
     }
 
     case "userinfo": // Prints info about logged in user of remote.
diff --git a/cmd/config/main_test.js b/cmd/config/main_test.js
index 6c5a215..4528e6b 100644
--- a/cmd/config/main_test.js
+++ b/cmd/config/main_test.js
@@ -1,11 +1,22 @@
 import { test } from "node:test";
-import { readFile, unlink, writeFile } from "node:fs/promises";
+import { mkdtemp, readFile, rm, unlink, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
 import { join } from "node:path";
+import process from "node:process";
 import assert from "node:assert/strict";
 import fc from "fast-check";
 
 import { config as configure, config_dir, NAME_REGEX } from "./main.js";
 
+// Each test file runs in its own process. These tests use a new folder as the
+// current folder and as the home folder. Thus they do not change the files of
+// the person, or the rclone.conf of other tests that run at the same time.
+const folder = await mkdtemp(join(tmpdir(), "rfetch-config-"));
+process.chdir(folder);
+process.env.HOME = folder;
+delete process.env.XDG_CONFIG_HOME;
+delete process.env.APPDATA;
+
 test("config", async (t) => {
   let command = "file";
   await t.test(command, async () => {
@@ -54,12 +65,12 @@ test("config", async (t) => {
     config = await readFile("rclone.conf", { encoding: "utf8" });
     assert.deepEqual(
       config,
-      "[source]\ntype = local",
+      "[source]\ntype = local\n",
       "should have the new remote added",
     );
     assert.deepEqual(
       await response.text(),
-      config,
+      "[source]\ntype = local",
       "should return the new remote in response",
     );
 
@@ -71,7 +82,7 @@ test("config", async (t) => {
     config = await readFile("rclone.conf", { encoding: "utf8" });
     assert.deepEqual(
       config,
-      "[source]\ntype = local\n\n[target]\ntype = local",
+      "[source]\ntype = local\n\n[target]\ntype = local\n",
       "should have both remotes",
     );
     assert.deepEqual(
@@ -154,7 +165,7 @@ test("config", async (t) => {
     const config = await readFile("rclone.conf", { encoding: "utf8" });
     assert.deepEqual(
       config,
-      `[source]\ntype = local\n\n${remote}`,
+      `[source]\ntype = local\n\n${remote}\n`,
       "should have the remote updated",
     );
     assert.deepEqual(
@@ -191,7 +202,7 @@ test("config", async (t) => {
     const config = await readFile("rclone.conf", { encoding: "utf8" });
     assert.deepEqual(
       config,
-      "[source]\ntype = local",
+      "[source]\ntype = local\n",
       "should have the remote deleted",
     );
     assert.deepEqual(
@@ -208,6 +219,28 @@ test("config", async (t) => {
     );
   });
 
+  await t.test("keeps the comments of the person", async () => {
+    await writeFile(
+      "rclone.conf",
+      "# My remotes.\n\n# Old disk.\n[old]\ntype = local\n\n" +
+        "[work]\n# The type.\ntype = local\n",
+    );
+    await configure("create", "new", { type: "memory" });
+    await configure("update", "work", { type: "alias", remote: "new:" });
+    await configure("delete", "old");
+    assert.equal(
+      await readFile("rclone.conf", { encoding: "utf8" }),
+      "# My remotes.\n\n[work]\n# The type.\ntype = alias\n" +
+        "remote = new:\n\n[new]\ntype = memory\n",
+    );
+    assert.equal(
+      await configure("show").then((response) => response.text()),
+      await readFile("rclone.conf", { encoding: "utf8" }),
+      "show gives the file with the comments",
+    );
+  });
+
   // Cleans up
   await unlink("rclone.conf");
+  await rm(folder, { recursive: true, force: true });
 });

From 36174a8fb57cb11024eb81947e111a63808c4e43 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sat, 17 Oct 2026 03:16:31 +0000
Subject: [PATCH 22/87] feat(crypt): the cipher of rclone, with its test
 vectors

The data:

- DecryptionStream reads the header and the blocks from chunks of any size. Before, the header had to be in the first chunk.
- It checks the magic bytes, and gives the errors of rclone: file too short, truncated block header, bad magic, block that does not authenticate.
- encryptedSize and decryptedSize are the functions of rclone, and decryptedSize throws for a size that no encrypted data has.

The names:

- PathCipher removes the padding with the checks of rclone, and refuses bad UTF-8, a size that is not a number of blocks, and a name of more than 2048 bytes.
- padding.js goes away: crypt uses only PKCS#7.

The tests use the vectors of backend/crypt/cipher_test.go of rclone: the names, the paths, the files of TestEncryptData, the sizes and the errors. Properties test each split of the chunks and each size of block.
---
 backend/crypt/PathCipher.js      |  71 ++++++--
 backend/crypt/PathCipher_test.js |  95 +++++++++++
 backend/crypt/padding.js         | 119 --------------
 backend/crypt/secretbox.js       | 193 ++++++++++++----------
 backend/crypt/secretbox_test.js  | 269 +++++++++++++++++++++++++++++--
 5 files changed, 522 insertions(+), 225 deletions(-)
 create mode 100644 backend/crypt/PathCipher_test.js
 delete mode 100644 backend/crypt/padding.js

diff --git a/backend/crypt/PathCipher.js b/backend/crypt/PathCipher.js
index 55f26ef..2221019 100644
--- a/backend/crypt/PathCipher.js
+++ b/backend/crypt/PathCipher.js
@@ -2,10 +2,14 @@ import decodeBase32 from "base32-decode";
 import encodeBase32 from "base32-encode";
 import { aes256 } from "./aes.js";
 import * as EME from "./eme.js";
-import { pad, Padding, unpad } from "./padding.js";
+
+/** The size of a block of AES and of the padding, in bytes. */
+const BLOCK_SIZE = 16;
+/** The largest encrypted name that rclone decrypts, in bytes. */
+const MAX_SIZE = 2048;
 
 const encoder = new TextEncoder();
-const decoder = new TextDecoder();
+const decoder = new TextDecoder("utf-8", { fatal: true });
 
 /**
  * @typedef {Object} PathCipherOptions
@@ -22,7 +26,9 @@ const decoder = new TextDecoder();
  */
 
 /**
- * Creates a path cipher.
+ * Creates a path cipher, as the standard name encryption of rclone crypt with
+ * the base32 encoding: EME with AES-256, PKCS#7 padding, and base32hex in
+ * lowercase with no padding.
  * @param {PathCipherOptions} param0
  * @returns {PathCipher}
  */
@@ -39,12 +45,10 @@ export default function PathCipher({ nameKey, nameTweak } = {}) {
    */
   function encryptName(name) {
     if (name === "") return "";
-    const ciphertext = encoder.encode(name);
-    const paddedCipherText = pad(ciphertext, Padding.PKCS7, 16);
-    const rawCipherText = EME.encrypt(nameCipher, nameTweak, paddedCipherText);
-
-    const encodedCipher = encodeBase32(rawCipherText, "RFC4648-HEX");
-    return encodedCipher.replace(/=+$/, "").toLowerCase();
+    const padded = pad(encoder.encode(name));
+    const ciphertext = EME.encrypt(nameCipher, nameTweak, padded);
+    return encodeBase32(ciphertext, "RFC4648-HEX", { padding: false })
+      .toLowerCase();
   }
 
   /**
@@ -60,18 +64,28 @@ export default function PathCipher({ nameKey, nameTweak } = {}) {
   }
 
   /**
-   * Decrypts a name
+   * Decrypts a name, with the checks of `decryptSegment` of rclone.
    * @param {string} name
    * @returns {string}
+   * @throws {Error} For a name that is not an encrypted name of this key.
    */
   function decryptName(name) {
     // An empty segment of a path stays empty, as in rclone.
     if (name === "") return "";
-    const rawCipherText = new Uint8Array(
+    const ciphertext = new Uint8Array(
       decodeBase32(name.toUpperCase(), "RFC4648-HEX"),
     );
-    const paddedPlaintext = EME.decrypt(nameCipher, nameTweak, rawCipherText);
-    return decoder.decode(unpad(paddedPlaintext, Padding.PKCS7, 16));
+    if (ciphertext.length % BLOCK_SIZE !== 0) {
+      throw new Error("not a multiple of blocksize");
+    }
+    if (ciphertext.length === 0) {
+      throw new Error("too short after base32 decode");
+    }
+    if (ciphertext.length > MAX_SIZE) {
+      throw new Error("too long after base32 decode");
+    }
+    const padded = EME.decrypt(nameCipher, nameTweak, ciphertext);
+    return decoder.decode(unpad(padded));
   }
 
   /**
@@ -93,3 +107,34 @@ export default function PathCipher({ nameKey, nameTweak } = {}) {
     decrypt,
   };
 }
+
+/**
+ * Adds PKCS#7 padding: 1 to 16 bytes, each with the number of the bytes.
+ * @param {Uint8Array} bytes
+ * @returns {Uint8Array}
+ */
+function pad(bytes) {
+  const count = BLOCK_SIZE - bytes.length % BLOCK_SIZE;
+  const padded = new Uint8Array(bytes.length + count);
+  padded.set(bytes);
+  padded.fill(count, bytes.length);
+  return padded;
+}
+
+/**
+ * Removes PKCS#7 padding, with the checks of the package pkcs7 of rclone.
+ * @param {Uint8Array} bytes
+ * @returns {Uint8Array}
+ */
+function unpad(bytes) {
+  const count = bytes[bytes.length - 1];
+  if (count === 0 || count > BLOCK_SIZE) {
+    throw new Error("bad padding");
+  }
+  for (let index = bytes.length - count; index < bytes.length; index++) {
+    if (bytes[index] !== count) {
+      throw new Error("bad padding");
+    }
+  }
+  return bytes.subarray(0, bytes.length - count);
+}
diff --git a/backend/crypt/PathCipher_test.js b/backend/crypt/PathCipher_test.js
new file mode 100644
index 0000000..6e43f35
--- /dev/null
+++ b/backend/crypt/PathCipher_test.js
@@ -0,0 +1,95 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import encodeBase32 from "base32-encode";
+import fc from "fast-check";
+
+import PathCipher from "./PathCipher.js";
+
+// rclone tests its names with keys of zero bytes: the keys of an empty
+// password (backend/crypt/cipher_test.go).
+const cipher = PathCipher({
+  nameKey: new Uint8Array(32),
+  nameTweak: new Uint8Array(16),
+});
+
+test("encrypts the names as rclone (TestEncryptSegmentBase32)", () => {
+  const vectors = {
+    "": "",
+    "1": "p0e52nreeaj0a5ea7s64m4j72s",
+    "12": "l42g6771hnv3an9cgc8cr2n1ng",
+    "123": "qgm4avr35m5loi1th53ato71v0",
+    "1234": "8ivr2e9plj3c3esisjpdisikos",
+    "12345": "rh9vu63q3o29eqmj4bg6gg7s44",
+    "123456": "bn717l3alepn75b2fb2ejmi4b4",
+    "1234567": "n6bo9jmb1qe3b1ogtj5qkf19k8",
+    "12345678": "u9t24j7uaq94dh5q53m3s4t9ok",
+    "123456789": "37hn305g6j12d1g0kkrl7ekbs4",
+    "1234567890": "ot8d91eplaglb62k2b1trm2qv0",
+    "12345678901": "h168vvrgb53qnrtvvmb378qrcs",
+    "123456789012": "s3hsdf9e29ithrqbjqu01t8q2s",
+    "1234567890123": "cf3jimlv1q2oc553mv7s3mh3eo",
+    "12345678901234": "moq0uqdlqrblrc5pa5u5c7hq9g",
+    "123456789012345": "eeam3li4rnommi3a762h5n7meg",
+    "1234567890123456": "mijbj0frqf6ms7frcr6bd9h0env53jv96pjaaoirk7forcgpt70g",
+  };
+  for (const [name, encrypted] of Object.entries(vectors)) {
+    assert.equal(cipher.encryptName(name), encrypted, name);
+    assert.equal(cipher.decryptName(encrypted), name, encrypted);
+    // The decryption does not see the case.
+    assert.equal(cipher.decryptName(encrypted.toUpperCase()), name);
+  }
+});
+
+test("encrypts the paths as rclone (TestStandardEncryptFileNameBase32)", () => {
+  const vectors = {
+    "1/12": "p0e52nreeaj0a5ea7s64m4j72s/l42g6771hnv3an9cgc8cr2n1ng",
+    "1/12/123": "p0e52nreeaj0a5ea7s64m4j72s/l42g6771hnv3an9cgc8cr2n1ng/" +
+      "qgm4avr35m5loi1th53ato71v0",
+    "/1/12/": "/p0e52nreeaj0a5ea7s64m4j72s/l42g6771hnv3an9cgc8cr2n1ng/",
+  };
+  for (const [path, encrypted] of Object.entries(vectors)) {
+    assert.equal(cipher.encrypt(path), encrypted);
+    assert.equal(cipher.decrypt(encrypted), path);
+  }
+});
+
+test("refuses the names that rclone refuses (TestDecryptSegmentBase32)", () => {
+  const base32 = (text) =>
+    encodeBase32(new TextEncoder().encode(text), "RFC4648-HEX", {
+      padding: false,
+    }).toLowerCase();
+  for (
+    const name of [
+      "64=",
+      "!",
+      "hello=hello",
+      "a".repeat(3328),
+      base32("a"),
+      base32("123456789abcdef"),
+      base32("123456789abcdef0"),
+      // One character more than an encrypted name.
+      base32("1") + "p0e52nreeaj0a5ea7s64m4j72s",
+    ]
+  ) {
+    assert.throws(() => cipher.decryptName(name), Error, name);
+  }
+});
+
+test("decrypts each name that it encrypts", () => {
+  const key = fc.uint8Array({ minLength: 32, maxLength: 32 });
+  const tweak = fc.uint8Array({ minLength: 16, maxLength: 16 });
+  fc.assert(
+    fc.property(
+      key,
+      tweak,
+      fc.fullUnicodeString({ maxLength: 200 }),
+      (nameKey, nameTweak, name) => {
+        fc.pre(!name.includes("/"));
+        const names = PathCipher({ nameKey, nameTweak });
+        const encrypted = names.encryptName(name);
+        assert.match(encrypted, /^[0-9a-v]*$/);
+        assert.equal(names.decryptName(encrypted), name);
+      },
+    ),
+  );
+});
diff --git a/backend/crypt/padding.js b/backend/crypt/padding.js
deleted file mode 100644
index 8c4a5c5..0000000
--- a/backend/crypt/padding.js
+++ /dev/null
@@ -1,119 +0,0 @@
-/**
- * @enum { number }
- */
-export const Padding = {
-  NONE: 1,
-  PKCS7: 2,
-  ONE_AND_ZEROS: 3,
-  LAST_BYTE: 4,
-  NULL: 5,
-  SPACES: 6,
-};
-
-/**
- * Pads the input bytes to the specified block size.
- * @param {Uint8Array} bytes
- * @param {Padding} padding
- * @param {number} blockSize
- * @returns {Uint8Array}
- */
-export function pad(bytes, padding, blockSize) {
-  if (padding === Padding.NONE) {
-    if (bytes.length % blockSize === 0) return bytes;
-    else {
-      throw new Error(
-        `Invalid data size (must be multiple of ${blockSize} bytes)`,
-      );
-    }
-  }
-
-  const count = blockSize - bytes.length % blockSize;
-
-  if (count === blockSize && bytes.length > 0 && padding !== Padding.PKCS7) {
-    return bytes;
-  }
-
-  const writer = new Uint8Array(bytes.length + count);
-  const newBytes = [];
-  let remaining = count;
-  let padChar = 0;
-
-  switch (padding) {
-    case Padding.PKCS7: {
-      padChar = count;
-      break;
-    }
-    case Padding.ONE_AND_ZEROS: {
-      newBytes.push(0x80);
-      remaining--;
-      break;
-    }
-    case Padding.SPACES: {
-      padChar = 0x20;
-      break;
-    }
-  }
-
-  while (remaining > 0) {
-    if (padding === Padding.LAST_BYTE && remaining === 1) {
-      newBytes.push(count);
-      break;
-    }
-    newBytes.push(padChar);
-    remaining--;
-  }
-
-  writer.set(bytes);
-  writer.set(newBytes, bytes.length);
-  return writer;
-}
-
-/**
- * Unpads the input bytes to the specified block size.
- * @param {Uint8Array} bytes
- * @param {Padding} padding
- * @param {number} blockSize
- * @returns {Uint8Array}
- */
-export function unpad(bytes, padding, blockSize) {
-  let cutLength = 0;
-  switch (padding) {
-    case Padding.NONE: {
-      return bytes;
-    }
-    case Padding.LAST_BYTE:
-    case Padding.PKCS7: {
-      const lastChar = bytes[bytes.length - 1];
-      if (lastChar <= blockSize) {
-        cutLength = lastChar;
-      }
-      break;
-    }
-    case Padding.ONE_AND_ZEROS: {
-      for (let i = 1; i <= blockSize; i++) {
-        const char = bytes[bytes.length - i];
-        if (char === 0x80) {
-          cutLength = i;
-          break;
-        }
-        if (char !== 0) {
-          break;
-        }
-      }
-      break;
-    }
-    case Padding.NULL:
-    case Padding.SPACES: {
-      const padChar = (padding === Padding.SPACES) ? 0x20 : 0;
-      for (let i = 1; i <= blockSize; i++) {
-        const char = bytes[bytes.length - i];
-        if (char !== padChar) {
-          cutLength = i - 1;
-          break;
-        }
-      }
-      break;
-    }
-  }
-  return bytes.subarray(0, bytes.length - cutLength);
-}
diff --git a/backend/crypt/secretbox.js b/backend/crypt/secretbox.js
index e4acf67..dcc8f7d 100644
--- a/backend/crypt/secretbox.js
+++ b/backend/crypt/secretbox.js
@@ -1,5 +1,11 @@
 /**
  * @module crypt/secretbox
+ *
+ * The format of the data of rclone crypt: a header of the magic bytes and a
+ * nonce of 24 bytes, then blocks of NaCl SecretBox (XSalsa20 and Poly1305).
+ * Each block has 16 bytes of Poly1305 tag and up to `blockSize` bytes of
+ * data. The nonce goes up by 1 for each block, as a number in little-endian
+ * bytes.
  */
 import { xsalsa20poly1305 } from "@noble/ciphers/salsa";
 
@@ -12,6 +18,16 @@ import { xsalsa20poly1305 } from "@noble/ciphers/salsa";
 
 const DEFAULT_MAGIC = new Uint8Array();
 const DEFAULT_BLOCK_SIZE = 64 * 1024;
+const NONCE_SIZE = 24;
+const TAG_SIZE = 16;
+
+/** The errors of rclone for encrypted data. */
+export const Errors = {
+  TOO_SHORT: "file is too short to be encrypted",
+  BAD_HEADER: "file has truncated block header",
+  BAD_MAGIC: "not an encrypted file - bad magic string",
+  BAD_BLOCK: "failed to authenticate decrypted block - bad password?",
+};
 
 export class EncryptionStream extends TransformStream {
   /**
@@ -22,36 +38,27 @@ export class EncryptionStream extends TransformStream {
   constructor(key = randomBytes(32), options = {}) {
     const { magic = DEFAULT_MAGIC, blockSize = DEFAULT_BLOCK_SIZE } = options;
     // Generates initial nonce from OS's crypto strong random number generator.
-    let nonce = randomBytes(24);
-    let buffer = new Uint8Array();
+    const nonce = randomBytes(NONCE_SIZE);
+    /** The data that is not a full block yet. */
+    let pending = new Uint8Array(0);
 
     super({
       start(controller) {
-        const header = new Uint8Array(magic.length + nonce.length);
-        header.set(magic);
-        header.set(nonce, magic.length);
-        controller.enqueue(header);
+        controller.enqueue(concat(magic, nonce));
       },
       transform(chunk, controller) {
-        // Concatenate the new chunk with the buffer
-        buffer = concat(buffer, chunk);
-
-        while (buffer.byteLength >= blockSize) {
-          const block = buffer.slice(0, blockSize); // Extract the block
-          const cipher = xsalsa20poly1305(key, nonce);
-          const ciphertext = cipher.encrypt(block);
-          controller.enqueue(ciphertext);
-
-          buffer = buffer.slice(blockSize); // Remove the processed portion from the buffer
-          nonce = increment(nonce);
+        const data = pending.length ? concat(pending, chunk) : chunk;
+        let offset = 0;
+        for (; data.length - offset >= blockSize; offset += blockSize) {
+          const block = data.subarray(offset, offset + blockSize);
+          controller.enqueue(xsalsa20poly1305(key, nonce).encrypt(block));
+          increment(nonce);
         }
+        pending = data.slice(offset);
       },
       flush(controller) {
-        // Encrypts the remaining data in the buffer
-        if (buffer.byteLength > 0) {
-          const cipher = xsalsa20poly1305(key, nonce);
-          const ciphertext = cipher.encrypt(buffer);
-          controller.enqueue(ciphertext);
+        if (pending.length > 0) {
+          controller.enqueue(xsalsa20poly1305(key, nonce).encrypt(pending));
         }
       },
     });
@@ -60,77 +67,105 @@ export class EncryptionStream extends TransformStream {
 
 export class DecryptionStream extends TransformStream {
   /**
-   * Creates a new decryption stream
+   * Creates a new decryption stream. It reads the header and the blocks from
+   * chunks of any size. An error of the stream has a message of `Errors`.
    * @param {Uint8Array} key
    * @param {Options} [options]
    */
   constructor(key, options = {}) {
     const { magic = DEFAULT_MAGIC, blockSize = DEFAULT_BLOCK_SIZE } = options;
-    const tagLength = 16;
-    const blockLength = blockSize + tagLength;
+    const headerSize = magic.length + NONCE_SIZE;
+    const blockLength = blockSize + TAG_SIZE;
 
+    /** @type {Uint8Array | null} */
     let nonce = null;
-    let buffer = new Uint8Array();
+    /** The data that is not a full header or block yet. */
+    let pending = new Uint8Array(0);
+
+    /** @param {Uint8Array} block */
+    function open(block) {
+      try {
+        return xsalsa20poly1305(key, nonce).decrypt(block);
+      } catch {
+        throw new Error(Errors.BAD_BLOCK);
+      }
+    }
 
     super({
-      transform(ciphertext, controller) {
+      transform(chunk, controller) {
+        const data = pending.length ? concat(pending, chunk) : chunk;
+        let offset = 0;
         if (!nonce) {
-          // Extracts 24-byte nonce from header, after the magic.
-          nonce = ciphertext.slice(magic.length, magic.length + 24);
-          ciphertext = ciphertext.slice(magic.length + 24);
+          if (data.length < headerSize) {
+            pending = data.slice();
+            return;
+          }
+          if (magic.some((byte, index) => data[index] !== byte)) {
+            throw new Error(Errors.BAD_MAGIC);
+          }
+          nonce = data.slice(magic.length, headerSize);
+          offset = headerSize;
         }
-
-        if (ciphertext.byteLength === 0) {
-          return;
-        }
-
-        // Concatenate the new chunk with the buffer
-        buffer = concat(buffer, ciphertext);
-
-        // Check if the buffer has enough data for a block
-        while (buffer.byteLength >= blockLength) {
-          const block = buffer.slice(0, blockLength); // Extract the block
-          const cipher = xsalsa20poly1305(key, nonce);
-          const plaintext = cipher.decrypt(block);
-          controller.enqueue(plaintext);
-
-          buffer = buffer.slice(blockLength); // Remove the processed portion from the buffer
-          // The nonce is incremented for each chunk read making sure each nonce is unique for each block written
-          nonce = increment(nonce);
+        for (; data.length - offset >= blockLength; offset += blockLength) {
+          controller.enqueue(open(data.subarray(offset, offset + blockLength)));
+          // The nonce goes up by 1 for each block.
+          increment(nonce);
         }
+        pending = data.slice(offset);
       },
       flush(controller) {
-        // Decrypts the remaining data in the buffer
-        if (buffer.byteLength > 0) {
-          const cipher = xsalsa20poly1305(key, nonce);
-          const plaintext = cipher.decrypt(buffer);
-          controller.enqueue(plaintext);
+        if (!nonce) {
+          throw new Error(Errors.TOO_SHORT);
+        }
+        if (pending.length > 0) {
+          if (pending.length <= TAG_SIZE) {
+            throw new Error(Errors.BAD_HEADER);
+          }
+          controller.enqueue(open(pending));
         }
       },
     });
   }
+}
 
-  /**
-   * Calculates original size from encrypted size
-   * @param {number} size Encrypted size
-   * @param {Options} [options]
-   * @returns {number} Original size
-   */
-  static size(size, options = {}) {
-    const { magic = DEFAULT_MAGIC, blockSize = DEFAULT_BLOCK_SIZE } = options;
-    const tagLength = 16;
-    const blockLength = blockSize + tagLength;
+/**
+ * The size of the encrypted data for data of a size.
+ * @param {number} size
+ * @param {Options} [options]
+ * @returns {number}
+ */
+export function encryptedSize(size, options = {}) {
+  const { magic = DEFAULT_MAGIC, blockSize = DEFAULT_BLOCK_SIZE } = options;
+  const blocks = Math.floor(size / blockSize);
+  const residue = size % blockSize;
+  return magic.length + NONCE_SIZE + blocks * (blockSize + TAG_SIZE) +
+    (residue ? residue + TAG_SIZE : 0);
+}
 
-    size = size - magic.length - 24;
-    const blocks = Math.floor(size / blockLength);
-    const decryptedSize = blocks * blockSize;
-    let residue = size % blockLength;
-    if (residue !== 0) {
-      residue -= tagLength;
+/**
+ * The size of the data in encrypted data of a size, as `DecryptedSize` of
+ * rclone.
+ * @param {number} size
+ * @param {Options} [options]
+ * @returns {number}
+ * @throws {RangeError} When no encrypted data has the size.
+ */
+export function decryptedSize(size, options = {}) {
+  const { magic = DEFAULT_MAGIC, blockSize = DEFAULT_BLOCK_SIZE } = options;
+  const blockLength = blockSize + TAG_SIZE;
+  size -= magic.length + NONCE_SIZE;
+  if (size < 0) {
+    throw new RangeError(Errors.TOO_SHORT);
+  }
+  const blocks = Math.floor(size / blockLength);
+  let residue = size % blockLength;
+  if (residue !== 0) {
+    residue -= TAG_SIZE;
+    if (residue <= 0) {
+      throw new RangeError(Errors.BAD_HEADER);
     }
-
-    return decryptedSize + residue;
   }
+  return blocks * blockSize + residue;
 }
 
 /**
@@ -156,20 +191,16 @@ function concat(a, b) {
 }
 
 /**
- * Increments the nonce by 1
+ * Adds 1 to the nonce, in place: the first byte is the lowest.
  * @param {Uint8Array} nonce
- * @param {number} offset
  */
-function increment(nonce, offset = 0) {
-  const length = nonce.byteLength;
-  for (; offset < length; offset++) {
-    const digit = nonce[offset];
-    const newDigit = (digit + 1) % 256;
-    nonce[offset] = newDigit;
-    if (newDigit >= digit) {
+function increment(nonce) {
+  for (let offset = 0; offset < nonce.length; offset++) {
+    nonce[offset] = (nonce[offset] + 1) & 0xff;
+    // No carry when the byte is not 0 after the addition.
+    if (nonce[offset] !== 0) {
       break;
     }
   }
-
   return nonce;
 }
diff --git a/backend/crypt/secretbox_test.js b/backend/crypt/secretbox_test.js
index 1863ce0..66e65b6 100644
--- a/backend/crypt/secretbox_test.js
+++ b/backend/crypt/secretbox_test.js
@@ -2,24 +2,269 @@ import { test } from "node:test";
 import assert from "node:assert/strict";
 import fc from "fast-check";
 
-import { DecryptionStream, EncryptionStream } from "./secretbox.js";
+import {
+  decryptedSize,
+  DecryptionStream,
+  encryptedSize,
+  EncryptionStream,
+  Errors,
+} from "./secretbox.js";
 
-test("decrypt/crypt", () => {
-  fc.assert(
+/** The options of rclone crypt. */
+const RCLONE = {
+  magic: new TextEncoder().encode("RCLONE\x00\x00"),
+  blockSize: 64 * 1024,
+};
+
+/**
+ * The files of TestEncryptData of rclone (backend/crypt/cipher_test.go): the
+ * key of zero bytes, and the nonce 1, 2, ..., 24.
+ */
+const header = [
+  0x52,
+  0x43,
+  0x4c,
+  0x4f,
+  0x4e,
+  0x45,
+  0x00,
+  0x00,
+  0x01,
+  0x02,
+  0x03,
+  0x04,
+  0x05,
+  0x06,
+  0x07,
+  0x08,
+  0x09,
+  0x0a,
+  0x0b,
+  0x0c,
+  0x0d,
+  0x0e,
+  0x0f,
+  0x10,
+  0x11,
+  0x12,
+  0x13,
+  0x14,
+  0x15,
+  0x16,
+  0x17,
+  0x18,
+];
+const file0 = Uint8Array.from(header);
+const file1 = Uint8Array.from([
+  ...header,
+  0x09,
+  0x5b,
+  0x44,
+  0x6c,
+  0xd6,
+  0x23,
+  0x7b,
+  0xbc,
+  0xb0,
+  0x8d,
+  0x09,
+  0xfb,
+  0x52,
+  0x4c,
+  0xe5,
+  0x65,
+  0xAA,
+]);
+const file16 = Uint8Array.from([
+  ...header,
+  0xb9,
+  0xc4,
+  0x55,
+  0x2a,
+  0x27,
+  0x10,
+  0x06,
+  0x29,
+  0x18,
+  0x96,
+  0x0a,
+  0x3e,
+  0x60,
+  0x8c,
+  0x29,
+  0xb9,
+  0xaa,
+  0x8a,
+  0x5e,
+  0x1e,
+  0x16,
+  0x5b,
+  0x6d,
+  0x07,
+  0x5d,
+  0xe4,
+  0xe9,
+  0xbb,
+  0x36,
+  0x7f,
+  0xd6,
+  0xd4,
+]);
+const zeroKey = new Uint8Array(32);
+
+/**
+ * Sends the chunks through a stream, and gives the bytes at the end.
+ * @param {Uint8Array[]} chunks
+ * @param {TransformStream} stream
+ */
+async function through(chunks, stream) {
+  const body = ReadableStream.from(chunks).pipeThrough(stream);
+  return new Uint8Array(await new Response(body).arrayBuffer());
+}
+
+/**
+ * Cuts the bytes into chunks at the points.
+ * @param {Uint8Array} bytes
+ * @param {number[]} cuts
+ */
+function cut(bytes, cuts) {
+  const points = [...new Set(cuts.map((cut) => cut % (bytes.length + 1)))]
+    .sort((a, b) => a - b);
+  const chunks = [];
+  let start = 0;
+  for (const point of points) {
+    chunks.push(bytes.slice(start, point));
+    start = point;
+  }
+  chunks.push(bytes.slice(start));
+  return chunks;
+}
+
+test("decrypts the files of rclone (TestEncryptData)", async () => {
+  for (
+    const [file, data] of [
+      [file0, []],
+      [file1, [1]],
+      [file16, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]],
+    ]
+  ) {
+    // In one chunk, and in chunks of 1 byte.
+    for (
+      const chunks of [
+        [file],
+        [...file].map((byte) => Uint8Array.of(byte)),
+      ]
+    ) {
+      const plain = await through(
+        chunks,
+        new DecryptionStream(zeroKey, RCLONE),
+      );
+      assert.deepEqual(plain, Uint8Array.from(data));
+    }
+  }
+});
+
+test("gives the errors of rclone for data that is not correct", async () => {
+  const decrypt = (bytes) =>
+    through([bytes], new DecryptionStream(zeroKey, RCLONE));
+
+  // Each part of the header is too short (TestNewDecrypter).
+  for (let length = 0; length < file0.length; length++) {
+    await assert.rejects(decrypt(file0.slice(0, length)), {
+      message: Errors.TOO_SHORT,
+    });
+  }
+  // A change of each byte of the magic (TestNewDecrypter).
+  for (let index = 0; index < 8; index++) {
+    const bad = file0.slice();
+    bad[index] ^= 1;
+    await assert.rejects(decrypt(bad), { message: Errors.BAD_MAGIC });
+  }
+  // A block of 16 bytes or less has no data after its tag.
+  await assert.rejects(decrypt(file1.slice(0, 48)), {
+    message: Errors.BAD_HEADER,
+  });
+  // A change of the data of a block, or a different key.
+  const changed = file16.slice();
+  changed[40] ^= 1;
+  await assert.rejects(decrypt(changed), { message: Errors.BAD_BLOCK });
+  await assert.rejects(
+    through([file16], new DecryptionStream(new Uint8Array(32).fill(1), RCLONE)),
+    { message: Errors.BAD_BLOCK },
+  );
+});
+
+test("gives the sizes of rclone (TestEncryptedSize, TestDecryptedSize)", () => {
+  for (
+    const [size, encrypted] of [
+      [0, 32],
+      [1, 32 + 16 + 1],
+      [65536, 32 + 16 + 65536],
+      [65537, 32 + 16 + 65536 + 16 + 1],
+      [2 ** 20, 32 + 16 * (16 + 65536)],
+      [2 ** 20 + 65535, 32 + 16 * (16 + 65536) + 16 + 65535],
+      [2 ** 30, 32 + 16384 * (16 + 65536)],
+      [2 ** 40 + 1, 32 + 16777216 * (16 + 65536) + 16 + 1],
+    ]
+  ) {
+    assert.equal(encryptedSize(size, RCLONE), encrypted, `${size}`);
+    assert.equal(decryptedSize(encrypted, RCLONE), size, `${encrypted}`);
+  }
+  for (
+    const [size, message] of [
+      [0, Errors.TOO_SHORT],
+      [1, Errors.TOO_SHORT],
+      [7, Errors.TOO_SHORT],
+      [32 + 1, Errors.BAD_HEADER],
+      [32 + 16, Errors.BAD_HEADER],
+      [32 + 16 + 65536 + 1, Errors.BAD_HEADER],
+      [32 + 16 + 65536 + 16, Errors.BAD_HEADER],
+    ]
+  ) {
+    assert.throws(() => decryptedSize(size, RCLONE), { message }, `${size}`);
+  }
+});
+
+test("decrypts what it encrypts, for each split of the chunks", async () => {
+  await fc.assert(
     fc.asyncProperty(
       fc.uint8Array({ minLength: 32, maxLength: 32 }),
       fc.uint8Array({ maxLength: 8 }),
-      fc.uint8Array(),
-      async (key, magic, content) => {
-        const decryptionStream = ReadableStream.from([content])
-          .pipeThrough(new EncryptionStream(key, { magic }))
-          .pipeThrough(new DecryptionStream(key, { magic }));
-
-        const result = new Uint8Array(
-          await new Response(decryptionStream).arrayBuffer(),
+      fc.integer({ min: 1, max: 40 }),
+      fc.uint8Array({ maxLength: 300 }),
+      fc.array(fc.nat(), { maxLength: 5 }),
+      fc.array(fc.nat(), { maxLength: 5 }),
+      async (key, magic, blockSize, content, cuts, cuts2) => {
+        const options = { magic, blockSize };
+        const encrypted = await through(
+          cut(content, cuts),
+          new EncryptionStream(key, options),
         );
-        assert.deepEqual(result, content);
+        assert.equal(encrypted.length, encryptedSize(content.length, options));
+        assert.equal(decryptedSize(encrypted.length, options), content.length);
+
+        const decrypted = await through(
+          cut(encrypted, cuts2),
+          new DecryptionStream(key, options),
+        );
+        assert.deepEqual(decrypted, content);
       },
     ),
   );
 });
+
+test("decrypts what it encrypts, at the size of the blocks of rclone", async () => {
+  const key = crypto.getRandomValues(new Uint8Array(32));
+  for (const size of [0, 1, 65535, 65536, 65537, 2 * 65536 + 7]) {
+    const content = new Uint8Array(size).map((_, index) => index * 31 + 7);
+    const encrypted = await through(
+      [content],
+      new EncryptionStream(key, RCLONE),
+    );
+    assert.equal(encrypted.length, encryptedSize(size, RCLONE));
+    assert.deepEqual(
+      await through([encrypted], new DecryptionStream(key, RCLONE)),
+      content,
+    );
+  }
+});

From b11f5a8bf6bde5a4f3a9732f2fe13d5e16ec2cbd Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sat, 17 Oct 2026 03:16:31 +0000
Subject: [PATCH 23/87] fix(crypt): pass the shared test suite, with no
 password in the links

The crypt backend now:

- puts no password and no salt in the links of a list. Before, each link had the query of the request with the password, and a browser keeps the links in its history;
- writes each name with percent-encoding in the link and with escapes in the HTML, and shows no link for a name that does not decrypt, as rclone skips such a name;
- gives the error of the remote, for example 404, and does not decrypt it;
- gives Content-Type, Content-Length and Last-Modified for GET and HEAD, and no other header of the encrypted data;
- sends the encrypted size as Content-Length on PUT, and not the type of the file;
- gives 400 for a path that is not safe, with no remote, with no password, or with a password that is not obscured;
- makes the keys as rclone: an empty password gives keys of zero bytes. It keeps the keys of the last 16 passwords, as scrypt takes much time.

The tests have the key vectors of rclone (TestKey) and run the shared suite over the memory backend.

In a Worker, a response of a stream has no Content-Length. Thus crypt sends the data through a FixedLengthStream when the runtime has one, and the memory backend gives a Blob.
---
 backend/crypt/main.js      | 388 ++++++++++++++++++++++++++-----------
 backend/crypt/main_test.js | 215 ++++++++++----------
 backend/memory/main.js     |   3 +-
 lib/streams/sized.js       |  16 ++
 4 files changed, 407 insertions(+), 215 deletions(-)
 create mode 100644 lib/streams/sized.js

diff --git a/backend/crypt/main.js b/backend/crypt/main.js
index b12f192..a8cccdd 100644
--- a/backend/crypt/main.js
+++ b/backend/crypt/main.js
@@ -95,11 +95,19 @@
 
 import { scryptAsync as scrypt } from "@noble/hashes/scrypt";
 import { HTMLRewriter } from "@sntran/html-rewriter";
+import { formatBytes } from "../../lib/format.js";
 import { mimeType } from "../../lib/mime.js";
+import { decodePath } from "../../lib/path.js";
+import { sized } from "../../lib/streams/sized.js";
 import { fetch } from "../../mod.js";
 import { reveal } from "../../cmd/obscure/main.js";
 import PathCipher from "./PathCipher.js";
-import { DecryptionStream, EncryptionStream } from "./secretbox.js";
+import {
+  decryptedSize,
+  DecryptionStream,
+  encryptedSize,
+  EncryptionStream,
+} from "./secretbox.js";
 
 const encoder = new TextEncoder();
 
@@ -133,121 +141,226 @@ const SECRETBOX_OPTIONS = {
   magic: encoder.encode("RCLONE\x00\x00"),
 };
 
+/**
+ * The options that are secret. They are not in the links of a list, which a
+ * browser can keep in its history and send to other sites.
+ */
+const SECRETS = ["password", "password2"];
+
 /**
  * Serves a crypted remote.
  * @param {Request} request
  * @returns {Promise<Response>}
  */
 async function crypt(request) {
-  let { pathname, searchParams } = new URL(request.url);
+  const { method } = request;
+  const { pathname, searchParams } = new URL(request.url);
+
+  const path = decodePath(pathname);
+  if (path === null) {
+    return new Response(null, { status: 400 });
+  }
 
-  let remote = searchParams.get("remote");
+  const remote = searchParams.get("remote")?.replace(/\/$/, "");
   if (!remote) {
     return new Response("Missing remote", { status: 400 });
   }
+  if (!searchParams.get("password")) {
+    return new Response("Missing password", { status: 400 });
+  }
 
-  remote = remote.replace(/\/$/, "");
-
-  const password = searchParams.get("password");
-  const salt = searchParams.get("password2");
+  let cipher;
+  try {
+    cipher = await cipherOf(
+      searchParams.get("password"),
+      searchParams.get("password2") ?? "",
+    );
+  } catch {
+    return new Response("The password is not obscured", { status: 400 });
+  }
 
-  const key = await deriveKey(password, salt);
+  const isDirectory = path.endsWith("/");
+  const target = remote + cipher.names.encrypt(path);
 
-  const pathCipher = PathCipher({
-    nameKey: key.subarray(32, 64),
-    nameTweak: key.subarray(64),
-  });
+  // The data on the remote is encrypted, thus a range of the data is not a
+  // range of the file.
+  const headers = new Headers(request.headers);
+  headers.delete("Range");
 
-  const isDirectory = pathname.endsWith("/");
-  pathname = decodeURIComponent(pathname);
-  const encryptedPathname = pathCipher.encrypt(pathname);
+  if (method === "GET" || method === "HEAD") {
+    const response = await fetch(target, { method, headers });
+    if (!response.ok) {
+      return response;
+    }
+    if (isDirectory) {
+      return listing(response, cipher, searchParams);
+    }
 
-  const url = remote.replace(/\/$/, "") + encryptedPathname;
+    const result = new Headers({ "Content-Type": mimeType(path) });
+    const size = sizeOf(response.headers.get("Content-Length"));
+    if (size >= 0) {
+      result.set("Content-Length", `${size}`);
+    }
+    const lastModified = response.headers.get("Last-Modified");
+    if (lastModified) {
+      result.set("Last-Modified", lastModified);
+    }
 
-  // Encrypts upload body if any.
-  if (request.body) {
-    request = new Request(request, {
-      body: request.body.pipeThrough(
-        new EncryptionStream(key.subarray(0, 32), SECRETBOX_OPTIONS),
-      ),
-    });
+    let body = null;
+    if (method === "GET" && response.body) {
+      body = response.body.pipeThrough(
+        new DecryptionStream(cipher.dataKey, SECRETBOX_OPTIONS),
+      );
+      if (size >= 0) body = sized(body, size);
+    } else {
+      await response.body?.cancel();
+    }
+    return new Response(body, { status: response.status, headers: result });
   }
 
-  // Delegates to the underlying remote.
-  const requestHeaders = new Headers(request.headers);
-  // Encrypted data on underlying remote won't respond to range.
-  requestHeaders.delete("Range");
-  request = new Request(request, {
-    headers: requestHeaders,
-  });
+  if (method === "PUT") {
+    // The remote does not get the type of the file: the type tells about
+    // the content.
+    headers.delete("Content-Type");
+    /** @type {RequestInit} */
+    const init = { method, headers };
+    if (!isDirectory) {
+      const length = request.headers.get("Content-Length");
+      headers.delete("Content-Length");
+      if (length !== null && /^\d+$/.test(length)) {
+        headers.set(
+          "Content-Length",
+          `${encryptedSize(Number(length), SECRETBOX_OPTIONS)}`,
+        );
+      }
+      const body = request.body ?? ReadableStream.from([]);
+      init.body = body.pipeThrough(
+        new EncryptionStream(cipher.dataKey, SECRETBOX_OPTIONS),
+      );
+      init.duplex = "half";
+    }
 
-  let response = await fetch(url, request);
-  let { status, statusText, headers, body } = response;
-  headers = new Headers(headers);
+    const response = await fetch(target, init);
+    await response.body?.cancel();
+    const result = new Headers();
+    if (response.ok) {
+      result.set("Content-Location", pathname);
+    }
+    return new Response(null, { status: response.status, headers: result });
+  }
 
-  const mimetype = mimeType(pathname);
-  if (mimetype) {
-    headers.set("Content-Type", mimetype);
+  if (method === "DELETE") {
+    const response = await fetch(target, { method, headers });
+    await response.body?.cancel();
+    return new Response(null, { status: response.status });
   }
 
-  if (body) {
-    let contentLength = Number(headers.get("Content-Length"));
-    if (contentLength) { // Adjusts the content length.
-      contentLength = DecryptionStream.size(contentLength, SECRETBOX_OPTIONS);
-      headers.set("Content-Length", `${contentLength}`);
-    }
+  return new Response(null, {
+    status: 405,
+    headers: { Allow: "GET, HEAD, PUT, DELETE" },
+  });
+}
 
-    if (isDirectory) {
-      const rewriter = new HTMLRewriter();
-      rewriter.on("tr a[href]", {
-        element(element) {
-          let href = element.getAttribute("href");
-          let type = element.getAttribute("type");
-
-          const { pathname } = new URL(href, "file:");
-          let basename = pathname.slice(1);
-          if (pathname != "/") {
-            basename = pathCipher.decrypt(basename);
-            href = `${basename}?${searchParams}`;
-            element.setAttribute("href", href);
-
-            // Replaces inner text with original name.
-            element.setInnerContent(basename);
-          }
-
-          if (type) {
-            type = mimeType(basename);
-            element.setAttribute("type", type);
-          }
-        },
-      });
-      rewriter.on(`tr data[value]`, {
-        element(element) {
-          const encryptedSize = Number(element.getAttribute("value"));
-          const originalSize = DecryptionStream.size(
-            encryptedSize,
-            SECRETBOX_OPTIONS,
+/**
+ * Gives the list of a folder with the names, the sizes and the types of the
+ * files, from the list of the encrypted folder on the remote.
+ *
+ * Each link gets the query of the request with no secret option, and no
+ * option of the remote. A name that does not decrypt is not a link, as
+ * rclone skips such a name.
+ * @param {Response} response The list of the encrypted folder.
+ * @param {{ names: import("./PathCipher.js").PathCipher }} cipher
+ * @param {URLSearchParams} searchParams
+ * @returns {Response}
+ */
+function listing(response, { names }, searchParams) {
+  const query = new URLSearchParams(searchParams);
+  for (const name of SECRETS) query.delete(name);
+  const suffix = query.size ? `?${query}` : "";
+
+  // The links of the list are relative to the encrypted folder.
+  const base = new URL("http://remote/folder/");
+
+  /** True when the link of the current row is a file that decrypts. */
+  let isFile = false;
+
+  const rewriter = new HTMLRewriter()
+    .on("tr", {
+      element() {
+        isFile = false;
+      },
+    })
+    .on("tr a[href]", {
+      element(element) {
+        const href = new URL(element.getAttribute("href"), base);
+        if (href.origin !== base.origin) {
+          element.removeAttribute("href");
+          return;
+        }
+        if (!href.pathname.startsWith(base.pathname)) {
+          // The parent folder.
+          element.setAttribute("href", `../${suffix}`);
+          return;
+        }
+
+        const rest = href.pathname.slice(base.pathname.length);
+        const isDirectory = rest.endsWith("/");
+        let name;
+        try {
+          const encrypted = decodeURIComponent(
+            isDirectory ? rest.slice(0, -1) : rest,
           );
-          element.setAttribute("value", `${originalSize}`);
-        },
-      });
-
-      response = rewriter.transform(response);
-      body = response.body;
-    } else {
-      body = body.pipeThrough(
-        new DecryptionStream(key.subarray(0, 32), SECRETBOX_OPTIONS),
-      );
-    }
-  }
+          if (encrypted === "" || encrypted.includes("/")) throw encrypted;
+          name = names.decryptName(encrypted);
+        } catch {
+          element.removeAttribute("href");
+          element.removeAttribute("type");
+          return;
+        }
+
+        isFile = !isDirectory;
+        element.setAttribute(
+          "href",
+          `${encodeURIComponent(name)}${isDirectory ? "/" : ""}${suffix}`,
+        );
+        element.setAttribute("type", isDirectory ? "" : mimeType(name));
+        // The text of an element is HTML-escaped.
+        element.setInnerContent(isDirectory ? `${name}/` : name);
+      },
+    })
+    .on("tr data[value]", {
+      element(element) {
+        const size = isFile ? sizeOf(element.getAttribute("value")) : -1;
+        element.setAttribute("value", `${size}`);
+        element.setInnerContent(
+          size >= 0 ? formatBytes(size, { locale: true }) : "—",
+        );
+      },
+    });
 
-  return new Response(body, {
-    status,
-    statusText,
+  const headers = new Headers(response.headers);
+  headers.delete("Content-Length");
+  return new Response(rewriter.transform(response).body, {
+    status: response.status,
     headers,
   });
 }
 
+/**
+ * The size of a file from the size of its encrypted data, or -1 for no size
+ * or a size that no encrypted data has.
+ * @param {string | null} value
+ * @returns {number}
+ */
+function sizeOf(value) {
+  if (value === null || !/^\d+$/.test(value)) return -1;
+  try {
+    return decryptedSize(Number(value), SECRETBOX_OPTIONS);
+  } catch {
+    return -1;
+  }
+}
+
 /**
  * Encode the given filename(s)
  *
@@ -273,15 +386,8 @@ async function crypt(request) {
  * @param {...string} args
  */
 export async function encode(options, ...args) {
-  const key = await deriveKey(options.password, options.password2);
-  const pathCipher = PathCipher({
-    nameKey: key.slice(32, 64),
-    nameTweak: key.slice(64),
-  });
-  const encoded = args.map((path) =>
-    (path ? pathCipher.encrypt(path) : "") + "\n"
-  );
-
+  const { names } = await cipherOf(options.password, options.password2 ?? "");
+  const encoded = args.map((path) => (path ? names.encrypt(path) : "") + "\n");
   return new Response(encoded.join(""));
 }
 
@@ -311,33 +417,81 @@ export async function encode(options, ...args) {
  * @param {...string} args
  */
 export async function decode(options, ...args) {
-  const key = await deriveKey(options.password, options.password2);
-  const pathCipher = PathCipher({
-    nameKey: key.slice(32, 64),
-    nameTweak: key.slice(64),
-  });
-
-  const decoded = args.map((arg) =>
-    (arg ? pathCipher.decrypt(arg) : "") + "\n"
-  );
+  const { names } = await cipherOf(options.password, options.password2 ?? "");
+  const decoded = args.map((arg) => (arg ? names.decrypt(arg) : "") + "\n");
   return new Response(decoded.join(""));
 }
 
 /**
- * @param {string} encPass
- * @param {string} encSalt
+ * Makes the keys from a password and a salt, as `Cipher.Key` of rclone: 32
+ * bytes for the data, 32 bytes for the names, and 16 bytes of tweak for the
+ * names. An empty password gives keys of zero bytes.
+ * @param {string | Uint8Array} password The password, not obscured.
+ * @param {string | Uint8Array} [salt] The salt, not obscured. An empty salt
+ *   is the salt of rclone.
+ * @returns {Promise<Uint8Array>}
+ */
+export async function deriveKey(password, salt = "") {
+  const bytes = (text) =>
+    typeof text === "string" ? encoder.encode(text) : text;
+  if (bytes(password).length === 0) {
+    return new Uint8Array(dkLen);
+  }
+  const saltBytes = bytes(salt).length ? bytes(salt) : DEFAULT_SALT;
+  return await scrypt(bytes(password), saltBytes, { N, r, p, dkLen });
+}
+
+/**
+ * The ciphers of the last passwords. scrypt takes much time, thus each
+ * request does not make the keys again.
+ * @type {Map<string, Promise<{ dataKey: Uint8Array, names: import("./PathCipher.js").PathCipher }>>}
+ */
+const ciphers = new Map();
+const MAX_CIPHERS = 16;
+
+/**
+ * Gives the key of the data and the cipher of the names for an obscured
+ * password and an obscured salt.
+ * @param {string} password
+ * @param {string} salt "" for the salt of rclone.
+ * @throws {Error} When the password or the salt is not obscured.
+ */
+function cipherOf(password, salt) {
+  const id = JSON.stringify([password, salt]);
+  let cipher = ciphers.get(id);
+  if (cipher) {
+    // The last used cipher goes to the end.
+    ciphers.delete(id);
+  } else {
+    cipher = (async () => {
+      const key = await deriveKey(
+        await revealBytes(password),
+        salt ? await revealBytes(salt) : "",
+      );
+      return {
+        dataKey: key.subarray(0, 32),
+        names: PathCipher({
+          nameKey: key.subarray(32, 64),
+          nameTweak: key.subarray(64),
+        }),
+      };
+    })();
+    cipher.catch(() => ciphers.delete(id));
+  }
+  ciphers.set(id, cipher);
+  if (ciphers.size > MAX_CIPHERS) {
+    ciphers.delete(ciphers.keys().next().value);
+  }
+  return cipher;
+}
+
+/**
+ * @param {string} obscured
  * @returns {Promise<Uint8Array>}
  */
-async function deriveKey(encPass, encSalt) {
-  const password = await reveal(encPass)
-    .then((response) => response.arrayBuffer())
-    .then((buf) => new Uint8Array(buf));
-  const decryptedSalt = await reveal(encSalt)
-    .then((response) => response.arrayBuffer())
-    .then((buf) => new Uint8Array(buf));
-  const salt = decryptedSalt.length ? decryptedSalt : DEFAULT_SALT;
-
-  return scrypt(password, salt, { N, r, p, dkLen });
+async function revealBytes(obscured) {
+  const response = await reveal(obscured);
+  return new Uint8Array(await response.arrayBuffer());
 }
 
 export default {
diff --git a/backend/crypt/main_test.js b/backend/crypt/main_test.js
index a4d5b73..0d1956a 100644
--- a/backend/crypt/main_test.js
+++ b/backend/crypt/main_test.js
@@ -1,25 +1,23 @@
-import { test } from "node:test";
+import { describe, test } from "node:test";
 import { readFile } from "node:fs/promises";
-import { Buffer } from "node:buffer";
 import { join } from "node:path";
-import { mimeType } from "../../lib/mime.js";
+import process from "node:process";
 import assert from "node:assert/strict";
 import fc from "fast-check";
 
-import { decode, default as crypt, encode } from "./main.js";
-
-/**
- * Tells if the two arrays have the same bytes.
- * @param {Uint8Array} a
- * @param {Uint8Array} b
- * @returns {boolean}
- */
-const sameBytes = (a, b) => Buffer.compare(a, b) === 0;
+import { backendSuite } from "../../lib/testing/suite.js";
+import { remote } from "../../lib/testing/remote.js";
+import { mimeType } from "../../lib/mime.js";
+import { decode, default as crypt, deriveKey, encode } from "./main.js";
 
+// The password "123456" and the salt, obscured.
 const PASSWORD = "UmyLSdRHfew6aual28-ggx78qHqSfQ";
 const SALT = "Cj3gLa5PVwc2aot0QpKiOZ3YEzs3Sw";
 
+// The tests read the fixtures from the current folder. Each test file runs in
+// its own process.
 const fixtures = new URL(join(".", "fixtures"), import.meta.url).pathname;
+process.chdir(fixtures);
 
 const CRYPT = {
   "hello.txt": "7656ki2d7s0mgv9ci91hnq77k8",
@@ -27,8 +25,6 @@ const CRYPT = {
   "1MB.bin": "k6ki5t8t5e5h3qoq78mpd29pns",
 };
 
-const MAGIC = new TextEncoder().encode("RCLONE\x00\x00");
-
 /**
  * @param {Response | Promise<Response>} response
  * @returns
@@ -39,6 +35,48 @@ async function getText(response) {
   return text.replace(/\n$/, "");
 }
 
+test("makes the keys of rclone (TestKey)", async () => {
+  const hex = (bytes) => Buffer.from(bytes).toString("hex");
+  for (
+    const [password, salt, dataKey, nameKey, nameTweak] of [
+      [
+        "potato",
+        "",
+        "7455c71ab17c865b8471f47b79acb07eb31d5678b80c7e2eaf4fc8066a9ee468",
+        "765da27ab15d77f95796711f7b93ad63bbb484072e7180a8d17a9bbec14270d0",
+        "c18d5932f55b2828c5e1e87215520310",
+      ],
+      [
+        "Potato",
+        "",
+        "aeea6ad347df75b963ce12f57623e946d42ed8bf3e928b39243794133e5ef75e",
+        "54f7026e8afc560a86636aab2c9c5162e51a122351836eaf50420f981c860a19",
+        "f8c1b6272d529b4a8fdaeb424a28ddf3",
+      ],
+      [
+        "potato",
+        "sausage",
+        "8e9b6b99f8690467a071f9cb92d0aa787f8ff178bec96f999fd5206e644a1b50",
+        "3ea95ef681782dc9d9955d225bfd442c6f5d6897b029015c6f462e2a9dae2ce3",
+        "f17fd7141d65274f363fc2a04dd2148a",
+      ],
+      [
+        "potato",
+        "Sausage",
+        "da818c67ef110fc8d5c8624b7fe29e3535b08d798489accba0ff0272031a5e64",
+        "02817e7bea99815ad02db96448b028277c20b4d4a468ad4e5c290f79efeedb3b",
+        "9ab50b3dcb605955a54de6b6470323e2",
+      ],
+      ["", "", "00".repeat(32), "00".repeat(32), "00".repeat(16)],
+    ]
+  ) {
+    const key = await deriveKey(password, salt);
+    assert.equal(hex(key.subarray(0, 32)), dataKey, password);
+    assert.equal(hex(key.subarray(32, 64)), nameKey, password);
+    assert.equal(hex(key.subarray(64)), nameTweak, password);
+  }
+});
+
 test("decode", async () => {
   const options = {
     password: PASSWORD,
@@ -68,6 +106,7 @@ test("encode", async () => {
   // encode them all at once.
   fc.assert(
     fc.property(fc.string(), (plaintext) => {
+      fc.pre(!plaintext.includes("\n"));
       plaintexts.push(plaintext);
     }),
   );
@@ -79,99 +118,81 @@ test("encode", async () => {
   assert.deepEqual(decoded, plaintexts.join("\n"));
 });
 
-test("GET", async (t) => {
-  const remote = join(fixtures, "crypt");
-  let request, response;
-
-  await t.test("should return original file", async () => {
-    for await (const originalFilename of Object.keys(CRYPT)) {
-      const originalFile = await readFile(
-        join(fixtures, "local", originalFilename),
-      );
-      const url = new URL(`/${originalFilename}`, "file:");
-      url.searchParams.set("remote", remote);
-      url.searchParams.set("password", PASSWORD);
-      url.searchParams.set("password2", SALT);
-
-      request = new Request(url);
-      response = await crypt.fetch(request);
-
-      const decryptedFile = new Uint8Array(await response.arrayBuffer());
-      assert(sameBytes(decryptedFile, originalFile));
-    }
+test("GET of the fixtures", async () => {
+  const fs = remote(crypt, {
+    params: { remote: "crypt", password: PASSWORD, password2: SALT },
   });
+  for (const name of Object.keys(CRYPT)) {
+    const original = await readFile(join("local", name));
+    const response = await fs.get(name);
+    assert.equal(response.status, 200);
+    assert.equal(response.headers.get("Content-Type"), mimeType(name));
+    assert.equal(
+      response.headers.get("Content-Length"),
+      `${original.byteLength}`,
+    );
+    assert.deepEqual(
+      new Uint8Array(await response.arrayBuffer()),
+      new Uint8Array(original),
+    );
+  }
+});
 
-  await t.test("should return original file info in headers", async () => {
-    for await (const originalFilename of Object.keys(CRYPT)) {
-      const originalFile = await readFile(
-        join(fixtures, "local", originalFilename),
-      );
-      const url = new URL(`/${originalFilename}`, "file:");
-      url.searchParams.set("remote", remote);
-      url.searchParams.set("password", PASSWORD);
-      url.searchParams.set("password2", SALT);
-
-      request = new Request(url);
-      response = await crypt.fetch(request);
+const params = {
+  remote: ":memory:/crypt",
+  password: PASSWORD,
+  password2: SALT,
+};
 
-      const size = Number(response.headers.get("Content-Length"));
-      assert.deepEqual(size, originalFile.byteLength);
+backendSuite("crypt", crypt, { params });
 
-      const type = response.headers.get("Content-Type");
-      assert.deepEqual(type, mimeType(originalFilename));
+describe("crypt", () => {
+  const fs = remote(crypt, { params });
 
-      response.body?.cancel();
+  test("puts no password in the links of a list", async () => {
+    await fs.put("secret/a b.txt", new TextEncoder().encode("a"));
+    for (const path of ["", "secret/"]) {
+      const html = await fs.get(path).then((response) => response.text());
+      assert.ok(html.includes(` href="a%20b.txt?`) || path === "");
+      assert.ok(!html.includes(PASSWORD), "no password");
+      assert.ok(!html.includes(SALT), "no salt");
+      assert.ok(html.includes("remote="), "the other options stay");
     }
+    await fs.delete("secret/");
   });
-});
-
-test("PUT", async () => {
-  const remote = ":memory:";
-
-  for await (const originalFilename of Object.keys(CRYPT)) {
-    const originalFile = await readFile(
-      join(fixtures, "local", originalFilename),
-    );
-
-    const encryptedFilename = CRYPT[originalFilename];
-    const url = new URL(`/${originalFilename}`, "file:");
-    url.searchParams.set("remote", remote);
-    url.searchParams.set("password", PASSWORD);
-    url.searchParams.set("password2", SALT);
-
-    let request, response;
 
-    // Asserts file does not exist in the original remote.
-    response = await fetch(join(remote, originalFilename));
-    assert.deepEqual(response.status, 404);
+  test("lists no file with a name that does not decrypt", async () => {
+    // A file that is not encrypted, next to the encrypted files.
+    await globalThis.fetch(":memory:/crypt/plain.txt", {
+      method: "PUT",
+      body: "plain",
+    });
+    await fs.put("encrypted.txt", new TextEncoder().encode("e"));
+    const names = (await fs.list("")).map(({ Name }) => Name);
+    assert.ok(names.includes("encrypted.txt"));
+    assert.ok(!names.includes("plain.txt"));
+    assert.equal(names.length, 1);
+    await fs.delete("encrypted.txt");
+    await globalThis.fetch(":memory:/crypt/plain.txt", { method: "DELETE" });
+  });
 
-    response = await fetch(join(remote, encryptedFilename));
-    assert.deepEqual(response.status, 404);
+  test("gives 400 for a password that is not obscured", async () => {
+    const bad = remote(crypt, { params: { ...params, password: "!!" } });
+    const response = await bad.get("");
+    assert.equal(response.status, 400);
+    assert.ok(!(await response.text()).includes("!!"));
+  });
 
-    // Uploads the file to the crypt remote.
-    request = new Request(url, {
+  test("gives an error of the stream for data that is not encrypted", async () => {
+    const encrypted = await getText(
+      encode({ password: PASSWORD, password2: SALT }, "plain2.txt"),
+    );
+    // The name is encrypted, but the data is not.
+    await globalThis.fetch(`:memory:/crypt/${encrypted}`, {
       method: "PUT",
-      body: originalFile,
+      body: "not encrypted data, longer than a header of 32 bytes",
     });
-    response = await crypt.fetch(request);
-
-    // Asserts original file does not exist in the original remote.
-    response = await fetch(join(remote, originalFilename));
-    assert.deepEqual(response.status, 404);
-
-    // Asserts encrypted file exists in the original remote.
-    response = await fetch(join(remote, encryptedFilename));
-    assert.deepEqual(response.status, 200);
-    const encryptedBuffer = new Uint8Array(await response.arrayBuffer());
-    assert(!sameBytes(encryptedBuffer, originalFile));
-
-    const magic = encryptedBuffer.subarray(0, 8);
-    assert.deepEqual(magic, MAGIC, "should have magic header");
-
-    // Gets the new file from the crypt remote.
-    request = new Request(url);
-    response = await crypt.fetch(request);
-    const decryptedFile = new Uint8Array(await response.arrayBuffer());
-    assert(sameBytes(decryptedFile, originalFile));
-  }
+    const response = await fs.get("plain2.txt");
+    await assert.rejects(response.arrayBuffer(), /bad magic/);
+  });
 });
diff --git a/backend/memory/main.js b/backend/memory/main.js
index 7259a36..8b05b95 100644
--- a/backend/memory/main.js
+++ b/backend/memory/main.js
@@ -48,8 +48,9 @@ async function memory(request) {
       headers.set("Content-Type", file.type || mimeType(path));
       headers.set("Content-Length", `${file.size}`);
       headers.set("Last-Modified", new Date(file.lastModified).toUTCString());
+      // A Blob has a size, thus a Worker sends its Content-Length.
       if (method === "GET") {
-        body = file.stream();
+        body = file;
       }
     } else {
       headers.set("Content-Type", "text/html;charset=utf-8");
diff --git a/lib/streams/sized.js b/lib/streams/sized.js
new file mode 100644
index 0000000..f5e4e8e
--- /dev/null
+++ b/lib/streams/sized.js
@@ -0,0 +1,16 @@
+/**
+ * Gives a stream with a known size for the body of a response. In a Worker,
+ * the response of a stream has no Content-Length, unless the stream is a
+ * `FixedLengthStream`, which also makes an error when the stream has a
+ * different size. Other runtimes keep the Content-Length header, thus the
+ * stream does not change there.
+ * @param {ReadableStream<Uint8Array>} stream
+ * @param {number} size
+ * @returns {ReadableStream<Uint8Array>}
+ */
+export function sized(stream, size) {
+  const { FixedLengthStream } = globalThis;
+  return FixedLengthStream
+    ? stream.pipeThrough(new FixedLengthStream(size))
+    : stream;
+}

From d894a38f988f797d54d95c38d26d3fe4928bb12e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sat, 17 Oct 2026 03:16:31 +0000
Subject: [PATCH 24/87] test(crypt): the same as rclone 1.75.1 in the two
 directions

rclone copy encrypts files and rfetch reads them: the bytes, the sizes and the lists, as rclone lsjson -R. rfetch encrypts files and rclone reads them: rclone copy and rclone cryptcheck. A property sends random names and data in the two directions.

The files have hard names and the sizes 0, 1, 65535, 65536, 65537 and 1 MiB + 1. The tests run when rclone is installed.
---
 CONTRIBUTING.md              |   6 +-
 backend/crypt/rclone_test.js | 184 +++++++++++++++++++++++++++++++++++
 2 files changed, 187 insertions(+), 3 deletions(-)
 create mode 100644 backend/crypt/rclone_test.js

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 308b95f..07800db 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -138,6 +138,6 @@ of the root folder.
 Run all the tests with `npm test`, or the tests of one backend with
 `node --test backend/remote`.
 
-Some tests compare rfetch with rclone, for example the tests of `lib/ini.js`.
-They run when `rclone` is in the `PATH`, or when the variable `RCLONE` is the
-path of rclone. Else they are skipped.
+Some tests compare rfetch with rclone, for example the tests of `lib/ini.js` and
+`backend/crypt/rclone_test.js`. They run when `rclone` is in the `PATH`, or when
+the variable `RCLONE` is the path of rclone. Else they are skipped.
diff --git a/backend/crypt/rclone_test.js b/backend/crypt/rclone_test.js
new file mode 100644
index 0000000..e7e9d2c
--- /dev/null
+++ b/backend/crypt/rclone_test.js
@@ -0,0 +1,184 @@
+/**
+ * The tests of crypt against rclone, in the two directions: rclone encrypts
+ * and rfetch decrypts, then rfetch encrypts and rclone decrypts. The tests
+ * run when rclone is in the PATH, or when RCLONE is the path of rclone.
+ */
+import { after, before, describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import {
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import process from "node:process";
+import fc from "fast-check";
+
+import { remote } from "../../lib/testing/remote.js";
+import crypt from "./main.js";
+
+const RCLONE = process.env.RCLONE || "rclone";
+const hasRclone = spawnSync(RCLONE, ["version"]).status === 0;
+
+// The password "123456" and the salt, obscured.
+const PASSWORD = "UmyLSdRHfew6aual28-ggx78qHqSfQ";
+const SALT = "Cj3gLa5PVwc2aot0QpKiOZ3YEzs3Sw";
+
+/** The files: hard names, and sizes at the ends of the blocks of 64 KiB. */
+const FILES = {
+  "empty.txt": 0,
+  "file name.txt": 1,
+  "a/65535.bin": 65535,
+  "a/65536.bin": 65536,
+  "a/b/65537.bin": 65537,
+  [`hello? sausage/êé/Hello, 世界/ " ' @ < > & ? + ≠/z.txt`]: 2 ** 20 + 1,
+};
+
+/** @param {number} size */
+function content(size) {
+  return new Uint8Array(size).map((_, index) => (index * 31 + size) & 0xff);
+}
+
+describe("crypt and rclone", {
+  skip: !hasRclone && "rclone is not installed. Set RCLONE to its path.",
+}, () => {
+  const folder = mkdtempSync(join(tmpdir(), "rfetch-crypt-"));
+  const config = join(folder, "rclone.conf");
+
+  /** @param {string[]} args */
+  function rclone(...args) {
+    const { status, stdout, stderr } = spawnSync(
+      RCLONE,
+      ["--config", config, ...args],
+      {
+        env: { PATH: process.env.PATH, HOME: folder },
+        maxBuffer: 64 * 2 ** 20,
+      },
+    );
+    assert.equal(status, 0, `rclone ${args.join(" ")}: ${stderr}`);
+    return stdout;
+  }
+
+  /**
+   * A client of rfetch crypt on a folder of the local backend.
+   * @param {string} name The folder, in the current folder.
+   */
+  const rfetch = (name) =>
+    remote(crypt, {
+      params: { remote: name, password: PASSWORD, password2: SALT },
+    });
+
+  before(() => {
+    // The local backend serves the current folder.
+    process.chdir(folder);
+    writeFileSync(
+      config,
+      ["one", "two"].map((name) =>
+        `[${name}]\ntype = crypt\nremote = ${join(folder, name)}\n` +
+        `password = ${PASSWORD}\npassword2 = ${SALT}\n`
+      ).join("\n"),
+    );
+    for (const [path, size] of Object.entries(FILES)) {
+      mkdirSync(dirname(join(folder, "plain", path)), { recursive: true });
+      writeFileSync(join(folder, "plain", path), content(size));
+    }
+  });
+  after(() => rmSync(folder, { recursive: true, force: true }));
+
+  test("rfetch reads what rclone encrypts", async () => {
+    rclone("copy", join(folder, "plain"), "one:");
+    const fs = rfetch("one");
+
+    for (const [path, size] of Object.entries(FILES)) {
+      const response = await fs.get(path);
+      assert.equal(response.status, 200, path);
+      assert.equal(response.headers.get("Content-Length"), `${size}`, path);
+      assert.deepEqual(
+        new Uint8Array(await response.arrayBuffer()),
+        content(size),
+        path,
+      );
+    }
+
+    // The lists of rfetch have the names and sizes of `rclone lsjson`.
+    const expected = JSON.parse(rclone("lsjson", "-R", "one:"));
+    const actual = [];
+    const walk = async (path) => {
+      for (const entry of await fs.list(path)) {
+        actual.push({
+          Path: `${path}${entry.Name}`,
+          IsDir: entry.IsDir,
+          Size: entry.Size,
+        });
+        if (entry.IsDir) await walk(`${path}${entry.Name}/`);
+      }
+    };
+    await walk("");
+    // A folder has the size of the local folder in rclone, and no size in
+    // rfetch.
+    const sort = (entries) =>
+      entries.map(({ Path, IsDir, Size }) =>
+        IsDir ? { Path, IsDir } : { Path, IsDir, Size }
+      )
+        .sort((a, b) => a.Path < b.Path ? -1 : +(a.Path > b.Path));
+    assert.deepEqual(sort(actual), sort(expected));
+  });
+
+  test("rclone reads what rfetch encrypts", async () => {
+    const fs = rfetch("two");
+    for (const [path, size] of Object.entries(FILES)) {
+      const response = await fs.put(path, content(size), {
+        "Content-Length": `${size}`,
+      });
+      assert.equal(response.status, 201, path);
+    }
+
+    rclone("copy", "two:", join(folder, "out"));
+    for (const [path, size] of Object.entries(FILES)) {
+      assert.deepEqual(
+        new Uint8Array(readFileSync(join(folder, "out", path))),
+        content(size),
+        path,
+      );
+    }
+    // rclone checks the files with the hashes of the data that it encrypts
+    // again with the nonces of the files of rfetch.
+    rclone("cryptcheck", join(folder, "plain"), "two:");
+  });
+
+  test("rclone and rfetch read the names and the data of each other", async () => {
+    const name = fc.fullUnicodeString({ minLength: 1, maxLength: 40 })
+      .filter((name) =>
+        !/[/\0\n\r]/.test(name) && name.trim() === name && name !== "." &&
+        name !== ".."
+      );
+    await fc.assert(
+      fc.asyncProperty(
+        name,
+        fc.uint8Array({ maxLength: 3000 }),
+        async (name, data) => {
+          // rfetch encrypts, rclone decrypts.
+          const fs = rfetch("two");
+          await fs.put(`random/${name}`, data);
+          assert.deepEqual(
+            new Uint8Array(rclone("cat", `two:random/${name}`)),
+            data,
+          );
+          // rclone encrypts, rfetch decrypts.
+          writeFileSync(join(folder, "input"), data);
+          rclone("copyto", join(folder, "input"), `one:random/${name}`);
+          const response = await rfetch("one").get(`random/${name}`);
+          assert.deepEqual(new Uint8Array(await response.arrayBuffer()), data);
+
+          await fs.delete("random/");
+          await rfetch("one").delete("random/");
+        },
+      ),
+      { numRuns: 20 },
+    );
+  });
+});

From e72209bf69c49e556a648bdac8c0ccc4df804365 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sat, 17 Oct 2026 03:40:05 +0000
Subject: [PATCH 25/87] refactor(lib): one module for the lists of folders

lib/listing.js reads and writes the HTML table of a list. The tests and the backends use it:

- readListing gives the entries of a list, as rclone lsjson. It was lib/testing/listing.js.
- renderListing writes a list from the entries. The memory backend uses it, and other backends can use it.
- relink puts a query in place of the query of each link of a list, for a backend on top of another backend.
- childOf gives the name of a file or a folder directly in a folder, from a link.

A link of renderListing has a query only when the query is not empty.
---
 backend/memory/main.js |  90 +++++---------------
 lib/listing.js         | 185 +++++++++++++++++++++++++++++++++++++++++
 lib/testing/listing.js |  79 ------------------
 lib/testing/remote.js  |  14 +++-
 4 files changed, 216 insertions(+), 152 deletions(-)
 create mode 100644 lib/listing.js
 delete mode 100644 lib/testing/listing.js

diff --git a/backend/memory/main.js b/backend/memory/main.js
index 8b05b95..dac68f1 100644
--- a/backend/memory/main.js
+++ b/backend/memory/main.js
@@ -7,8 +7,7 @@
  * Because it has no parameters you can just use it with the `:memory:` remote
  * name.
  */
-import { formatBytes } from "../../lib/format.js";
-import { escapeHTML } from "../../lib/html.js";
+import { renderListing } from "../../lib/listing.js";
 import { mimeType } from "../../lib/mime.js";
 import { decodePath } from "../../lib/path.js";
 
@@ -112,78 +111,31 @@ async function memory(request) {
 function listing(path, searchParams) {
   // The children are the paths in the folder with no other "/" than a "/" at
   // the end for a folder.
-  /** @type {string[]} */
-  const children = [];
-  for (const key of cache.keys()) {
+  /** @type {import("../../lib/listing.js").Entry[]} */
+  const entries = [];
+  for (const [key, file] of cache) {
     if (key === path || !key.startsWith(path)) continue;
     const child = key.slice(path.length);
     const slash = child.indexOf("/");
-    if (slash === -1 || slash === child.length - 1) {
-      children.push(child);
+    if (slash === -1) {
+      entries.push({
+        Name: child,
+        IsDir: false,
+        Size: file.size,
+        MimeType: file.type || mimeType(child),
+        ModTime: new Date(file.lastModified).toISOString(),
+      });
+    } else if (slash === child.length - 1) {
+      entries.push({
+        Name: child.slice(0, -1),
+        IsDir: true,
+        Size: -1,
+        MimeType: "",
+        ModTime: "",
+      });
     }
   }
-  children.sort((a, b) => a.localeCompare(b));
-
-  const query = escapeHTML(`${searchParams}`);
-
-  return new ReadableStream({
-    start(controller) {
-      controller.enqueue(`
-        <table cellpadding="4">
-        <thead>
-          <tr>
-            <th></th>
-            <th>Name</th>
-            <th>Size</th>
-            <th>Modified</th>
-          </tr>
-        </thead>
-        <tbody>
-          <tr>
-            <td>📁</td>
-            <td><a href="../?${query}">Go up</a></td>
-            <td>—</td>
-            <td>—</td>
-          </tr>
-      `);
-
-      for (const child of children) {
-        const file = cache.get(path + child);
-        const isDirectory = file === null;
-        const name = isDirectory ? child.slice(0, -1) : child;
-        const href = `${encodeURIComponent(name)}${isDirectory ? "/" : ""}`;
-        const type = isDirectory ? "" : file.type || mimeType(name);
-        const lastModified = isDirectory ? null : new Date(file.lastModified);
-
-        controller.enqueue(`<tr>
-          <td>${isDirectory ? "📁" : "📄"}</td>
-          <td>
-            <a
-              href="${href}?${query}"
-              type="${escapeHTML(type)}"
-            >${escapeHTML(child)}</a>
-          </td>
-          <td>${
-          isDirectory ? "—" : `<data
-              value="${file.size}"
-            >${formatBytes(file.size, { locale: true })}</data>`
-        }
-          </td>
-          <td>${
-          lastModified
-            ? `<time
-                datetime="${lastModified.toISOString()}"
-              >${lastModified.toLocaleString()}</time>`
-            : "-"
-        }
-          </td>
-        </tr>`);
-      }
-
-      controller.enqueue("</tbody></table>");
-      controller.close();
-    },
-  }).pipeThrough(new TextEncoderStream());
+  return renderListing(entries, { query: `${searchParams}` });
 }
 
 export default {
diff --git a/lib/listing.js b/lib/listing.js
new file mode 100644
index 0000000..78d8a6b
--- /dev/null
+++ b/lib/listing.js
@@ -0,0 +1,185 @@
+/**
+ * The list of a folder in HTML, as CONTRIBUTING.md tells: the rows of a
+ * `<table>`. In each row, `<a href>` is the link to the file or the folder,
+ * with a `/` at the end for a folder, `type` is the media type, `<data
+ * value>` is the size in bytes, and `<time datetime>` is the time of the last
+ * change.
+ */
+import { HTMLRewriter } from "@sntran/html-rewriter";
+import { formatBytes } from "./format.js";
+import { escapeHTML } from "./html.js";
+
+/**
+ * An entry of the list of a folder, with the names of `rclone lsjson`.
+ * @typedef {Object} Entry
+ * @property {string} Name The name, with no percent-encoding.
+ * @property {boolean} IsDir
+ * @property {number} Size The value of `<data>`, or -1 when there is none.
+ * @property {string} MimeType The `type` of the link, or "".
+ * @property {string} ModTime The `datetime` of `<time>`, or "".
+ */
+
+/**
+ * Reads the entries of the list of a folder. Only a link to a file or a
+ * folder directly in the folder makes an entry. Thus the row of the parent
+ * folder (`../`) is not an entry, and a name that has no percent-encoding
+ * for `?`, `#` or `/` gives a wrong entry.
+ * @param {Response} response
+ * @param {URL} base The URL of the folder.
+ * @returns {Promise<Entry[]>}
+ */
+export async function readListing(response, base) {
+  /** @type {Entry[]} */
+  const entries = [];
+  /** @type {Entry | null} */
+  let entry = null;
+
+  await new HTMLRewriter()
+    .on("tr", {
+      element(element) {
+        entry = null;
+        element.onEndTag(() => {
+          if (entry) entries.push(entry);
+        });
+      },
+    })
+    .on("tr a[href]", {
+      element(element) {
+        const name = childOf(element.getAttribute("href"), base);
+        if (name === null) return;
+        const isDir = name.endsWith("/");
+        entry = {
+          Name: isDir ? name.slice(0, -1) : name,
+          IsDir: isDir,
+          Size: -1,
+          MimeType: element.getAttribute("type") || "",
+          ModTime: "",
+        };
+      },
+    })
+    .on("tr data[value]", {
+      element(element) {
+        if (entry) entry.Size = Number(element.getAttribute("value"));
+      },
+    })
+    .on("tr time[datetime]", {
+      element(element) {
+        if (entry) entry.ModTime = element.getAttribute("datetime");
+      },
+    })
+    .transform(response)
+    .arrayBuffer();
+
+  return entries;
+}
+
+/**
+ * Writes the list of a folder.
+ * @param {Entry[]} entries
+ * @param {{ query?: string }} [options] `query` goes in each link, for
+ *   example the options of the backend, with no secret.
+ * @returns {ReadableStream<Uint8Array>}
+ */
+export function renderListing(entries, { query = "" } = {}) {
+  const suffix = escapeHTML(query ? `?${query}` : "");
+  const rows = entries.toSorted((a, b) => a.Name.localeCompare(b.Name)).map(
+    ({ Name, IsDir, Size, MimeType, ModTime }) => {
+      const href = `${encodeURIComponent(Name)}${IsDir ? "/" : ""}`;
+      const time = ModTime ? new Date(ModTime) : null;
+      return `
+          <tr>
+            <td>${IsDir ? "📁" : "📄"}</td>
+            <td><a href="${href}${suffix}" type="${
+        escapeHTML(IsDir ? "" : MimeType)
+      }">${escapeHTML(IsDir ? `${Name}/` : Name)}</a></td>
+            <td>${
+        IsDir || Size < 0
+          ? "—"
+          : `<data value="${Size}">${
+            formatBytes(Size, { locale: true })
+          }</data>`
+      }</td>
+            <td>${
+        time && !isNaN(time)
+          ? `<time datetime="${time.toISOString()}">${time.toLocaleString()}</time>`
+          : "-"
+      }</td>
+          </tr>`;
+    },
+  );
+
+  const html = `
+      <table cellpadding="4">
+        <thead>
+          <tr>
+            <th></th>
+            <th>Name</th>
+            <th>Size</th>
+            <th>Modified</th>
+          </tr>
+        </thead>
+        <tbody>
+          <tr>
+            <td>📁</td>
+            <td><a href="../${suffix}">Go up</a></td>
+            <td>—</td>
+            <td>—</td>
+          </tr>${rows.join("")}
+        </tbody>
+      </table>
+    `;
+  return new Blob([html]).stream();
+}
+
+/**
+ * Puts a query in place of the query of each link of a list, for a backend
+ * on top of another backend. The links of the other backend have its own
+ * options, which are not the options of a request to this backend.
+ * @param {Response} response The list of the other backend.
+ * @param {string} query The query, with no secret option.
+ * @returns {Response}
+ */
+export function relink(response, query) {
+  const suffix = query ? `?${query}` : "";
+  const headers = new Headers(response.headers);
+  headers.delete("Content-Length");
+  const rewritten = new HTMLRewriter()
+    .on("tr a[href]", {
+      element(element) {
+        const href = element.getAttribute("href");
+        // Only a relative link, which stays in the backend.
+        if (/^[a-z][a-z0-9+.-]*:|^\/\//i.test(href)) return;
+        element.setAttribute("href", href.replace(/[?#].*$/s, "") + suffix);
+      },
+    })
+    .transform(response);
+  return new Response(rewritten.body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers,
+  });
+}
+
+/**
+ * The name of a file (`name`) or a folder (`name/`) directly in a folder,
+ * from a link, or null when the link is not to such a child. The query and
+ * the fragment of the link are not a part of the name.
+ * @param {string} href
+ * @param {URL} base The URL of the folder.
+ * @returns {string | null}
+ */
+export function childOf(href, base) {
+  const { origin, pathname } = new URL(href, base);
+  if (origin !== base.origin || !pathname.startsWith(base.pathname)) {
+    return null;
+  }
+  const rest = pathname.slice(base.pathname.length);
+  const isDir = rest.endsWith("/");
+  const name = isDir ? rest.slice(0, -1) : rest;
+  if (name === "" || name.includes("/")) return null;
+  try {
+    return decodeURIComponent(name) + (isDir ? "/" : "");
+  } catch {
+    return null;
+  }
+}
diff --git a/lib/testing/listing.js b/lib/testing/listing.js
deleted file mode 100644
index 19fd68f..0000000
--- a/lib/testing/listing.js
+++ /dev/null
@@ -1,79 +0,0 @@
-import { HTMLRewriter } from "@sntran/html-rewriter";
-
-/**
- * An entry of the list of a folder, with the names of `rclone lsjson`.
- * @typedef {Object} Entry
- * @property {string} Name The name, with no percent-encoding.
- * @property {boolean} IsDir
- * @property {number} Size The value of `<data>`, or -1 when there is none.
- * @property {string} MimeType The `type` of the link, or "".
- * @property {string} ModTime The `datetime` of `<time>`, or "".
- */
-
-/**
- * Reads the list of a folder from its HTML: the rows of a `<table>`, as
- * CONTRIBUTING.md tells. In each row, `<a href>` is the link to the file or
- * the folder, with a `/` at the end for a folder, `type` is the media type,
- * `<data value>` is the size in bytes, and `<time datetime>` is the time of
- * the last change.
- *
- * Only a link to a file or a folder directly in the folder makes an entry.
- * Thus the row of the parent folder (`../`) is not an entry, and a name that
- * has no percent-encoding for `?`, `#` or `/` gives a wrong entry.
- * @param {Response} response
- * @param {URL} base The URL of the folder.
- * @returns {Promise<Entry[]>}
- */
-export async function parseListing(response, base) {
-  /** @type {Entry[]} */
-  const entries = [];
-  /** @type {Entry | null} */
-  let entry = null;
-
-  await new HTMLRewriter()
-    .on("tr", {
-      element(element) {
-        entry = null;
-        element.onEndTag(() => {
-          if (entry) entries.push(entry);
-        });
-      },
-    })
-    .on("tr a[href]", {
-      element(element) {
-        const { origin, pathname } = new URL(
-          element.getAttribute("href"),
-          base,
-        );
-        if (origin !== base.origin || !pathname.startsWith(base.pathname)) {
-          return;
-        }
-        const rest = pathname.slice(base.pathname.length);
-        const isDir = rest.endsWith("/");
-        const name = isDir ? rest.slice(0, -1) : rest;
-        if (name === "" || name.includes("/")) return;
-
-        entry = {
-          Name: decodeURIComponent(name),
-          IsDir: isDir,
-          Size: -1,
-          MimeType: element.getAttribute("type") || "",
-          ModTime: "",
-        };
-      },
-    })
-    .on("tr data[value]", {
-      element(element) {
-        if (entry) entry.Size = Number(element.getAttribute("value"));
-      },
-    })
-    .on("tr time[datetime]", {
-      element(element) {
-        if (entry) entry.ModTime = element.getAttribute("datetime");
-      },
-    })
-    .transform(response)
-    .arrayBuffer();
-
-  return entries;
-}
diff --git a/lib/testing/remote.js b/lib/testing/remote.js
index 6f0b742..6180632 100644
--- a/lib/testing/remote.js
+++ b/lib/testing/remote.js
@@ -1,4 +1,4 @@
-import { parseListing } from "./listing.js";
+import { readListing } from "../listing.js";
 
 /** The origin of the URLs of the requests. A backend reads only the path. */
 const ORIGIN = "http://rfetch.test";
@@ -44,8 +44,14 @@ export function remote(backend, { params = {}, root = "/" } = {}) {
     url,
     send,
     /** @param {string} path @param {BodyInit} [body] @param {HeadersInit} [headers] */
-    put: (path, body = new Uint8Array(0), headers = {}) =>
-      send(path, { method: "PUT", body, headers }),
+    put(path, body = new Uint8Array(0), headers = {}) {
+      headers = new Headers(headers);
+      // An HTTP client sends the size of a body that it knows.
+      if (body instanceof Uint8Array && !headers.has("Content-Length")) {
+        headers.set("Content-Length", `${body.length}`);
+      }
+      return send(path, { method: "PUT", body, headers });
+    },
     /** @param {string} path @param {HeadersInit} [headers] */
     get: (path, headers = {}) => send(path, { headers }),
     /** @param {string} path */
@@ -62,7 +68,7 @@ export function remote(backend, { params = {}, root = "/" } = {}) {
         await response.body?.cancel();
         throw new Error(`GET ${JSON.stringify(path)} gave ${response.status}`);
       }
-      return await parseListing(response, url(path));
+      return await readListing(response, url(path));
     },
   };
 }

From 9e2e4f51fc07c6efc975e531a137f51497084002 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sat, 17 Oct 2026 03:40:05 +0000
Subject: [PATCH 26/87] test(lib): skip names, write through other backends,
 and clean up

The shared suite has two new options:

- skipName: the tests skip the names that match it. Use it only for a limit that the backend has in rclone too.
- writer: for a read only backend, the PUT and DELETE requests go to this backend, and the backend under test reads the files.

When a test of a name fails, the test deletes its folder. Thus the next tests do not see its files.
---
 lib/testing/suite.js | 58 +++++++++++++++++++++++++++++++-------------
 1 file changed, 41 insertions(+), 17 deletions(-)

diff --git a/lib/testing/suite.js b/lib/testing/suite.js
index 3cde24e..197ebe8 100644
--- a/lib/testing/suite.js
+++ b/lib/testing/suite.js
@@ -48,12 +48,27 @@ const FILE2 = `hello? sausage/êé/Hello, 世界/ " ' @ < > & ? + ≠/z.txt`;
  * Runs the tests of a backend.
  * @param {string} name The name of the backend, for the report.
  * @param {{ fetch: (request: Request) => Response | Promise<Response> }} backend
- * @param {{ params?: Record<string, string> }} [options] `params` go in the
- *   query of each request, for example the options of the backend.
+ * @param {{
+ *   params?: Record<string, string>,
+ *   skipName?: RegExp,
+ *   writer?: { fetch: (request: Request) => Response | Promise<Response> },
+ * }} [options] `params` go in the query of each request, for example the
+ *   options of the backend. The tests skip the names that match `skipName`,
+ *   for a limit that the backend has in rclone too. For a backend that is
+ *   read only, the PUT and DELETE requests go to `writer`, with no `params`:
+ *   a backend that writes the files that the backend under test reads.
  */
-export function backendSuite(name, backend, { params = {} } = {}) {
+export function backendSuite(
+  name,
+  backend,
+  { params = {}, skipName, writer } = {},
+) {
   const root = `/rfetch-test-${randomBytes(6).toString("hex")}/`;
   const fs = remote(backend, { params, root });
+  if (writer) {
+    const { put, delete: remove } = remote(writer, { root });
+    Object.assign(fs, { put, delete: remove });
+  }
 
   describe(`backend ${name}`, () => {
     after(async () => {
@@ -97,22 +112,31 @@ export function backendSuite(name, backend, { params = {} } = {}) {
 
     describe("names", () => {
       for (const name of NAMES) {
-        it(`keeps the name ${JSON.stringify(name)}`, async () => {
+        const skip = skipName?.test(name) && "a limit of the backend in rclone";
+        it(`keeps the name ${JSON.stringify(name)}`, { skip }, async () => {
           // The name is a folder and a file in it.
           const path = `${name}/${name}`;
           const content = random(64);
-          const start = Date.now();
-          await put(path, content);
-          const end = Date.now();
-
-          assertEntries(await fs.list(""), [folder(name)]);
-          assertEntries(await fs.list(`${name}/`), [
-            file(name, content.length),
-          ]);
-          await assertFile(path, content, start, end);
-
-          await expect(fs.delete(`${name}/`), 204);
-          assertEntries(await fs.list(""), []);
+          try {
+            const start = Date.now();
+            await put(path, content);
+            const end = Date.now();
+
+            assertEntries(await fs.list(""), [folder(name)]);
+            assertEntries(await fs.list(`${name}/`), [
+              file(name, content.length),
+            ]);
+            await assertFile(path, content, start, end);
+
+            await expect(fs.delete(`${name}/`), 204);
+            assertEntries(await fs.list(""), []);
+          } catch (error) {
+            // The next tests do not see the files of this test.
+            await fs.delete(`${name}/`).then((response) =>
+              response.body?.cancel()
+            );
+            throw error;
+          }
         });
       }
     });
@@ -295,7 +319,7 @@ async function expect(request, status) {
 /**
  * Makes sure that the entries of a list are the expected entries, in any
  * order. A folder has only its name. A file has its name and its size.
- * @param {import("./listing.js").Entry[]} entries
+ * @param {import("../listing.js").Entry[]} entries
  * @param {Array<{ Name: string, IsDir: boolean, Size?: number }>} expected
  */
 function assertEntries(entries, expected) {

From 6d991b766058945df9c6cb2c2b9e7900ac978e12 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sat, 17 Oct 2026 03:40:05 +0000
Subject: [PATCH 27/87] fix(alias): pass the shared test suite

The alias backend now:

- gives 400 with no remote, and for a path that is not safe. Before, it threw an error;
- sends the path with percent-encoding to the remote, with the method, the headers and the body of the request;
- puts its own query in the links of a list, not the query of the remote;
- gives the path of the alias in Content-Location.

lib/path.js has encodePath, the reverse of decodePath.
---
 backend/alias/main.js      | 37 ++++++++++++++++++++++++++++++++-----
 backend/alias/main_test.js | 12 ++++++++++++
 lib/path.js                | 10 ++++++++++
 3 files changed, 54 insertions(+), 5 deletions(-)

diff --git a/backend/alias/main.js b/backend/alias/main.js
index 6ead225..fd238fb 100644
--- a/backend/alias/main.js
+++ b/backend/alias/main.js
@@ -19,23 +19,50 @@
  * allowed as a remote. To alias the current directory use `.` instead.
  */
 
-import { join } from "node:path";
+import { relink } from "../../lib/listing.js";
+import { decodePath, encodePath } from "../../lib/path.js";
 import { fetch } from "../../mod.js";
 
 /**
  * @param {Request} request
  * @returns {Promise<Response>}
  */
-function alias(request) {
+async function alias(request) {
+  const { method } = request;
   const { pathname, searchParams } = new URL(request.url);
-  const remote = searchParams.get("remote");
 
+  const remote = searchParams.get("remote")?.replace(/\/$/, "");
   if (!remote) {
-    throw new Error("Missing remote");
+    return new Response("Missing remote", { status: 400 });
+  }
+  const path = decodePath(pathname);
+  if (path === null) {
+    return new Response(null, { status: 400 });
   }
 
   // Delegates to the underlying remote.
-  return fetch(join(remote, pathname), request);
+  /** @type {RequestInit} */
+  const init = { method, headers: request.headers };
+  if (request.body) {
+    init.body = request.body;
+    init.duplex = "half";
+  }
+  const response = await fetch(remote + encodePath(path), init);
+  if (!response.ok) {
+    return response;
+  }
+
+  // The links of a list and the location of a new file are in this remote,
+  // not in the underlying remote.
+  if (path.endsWith("/") && (method === "GET" || method === "HEAD")) {
+    return relink(response, `${searchParams}`);
+  }
+  if (method === "PUT") {
+    const headers = new Headers(response.headers);
+    headers.set("Content-Location", pathname);
+    return new Response(response.body, { status: response.status, headers });
+  }
+  return response;
 }
 
 export default {
diff --git a/backend/alias/main_test.js b/backend/alias/main_test.js
index f4ae74c..9b2432d 100644
--- a/backend/alias/main_test.js
+++ b/backend/alias/main_test.js
@@ -4,6 +4,8 @@ import { readdir } from "node:fs/promises";
 import { join } from "node:path";
 import assert from "node:assert/strict";
 
+import { backendSuite } from "../../lib/testing/suite.js";
+import { remote } from "../../lib/testing/remote.js";
 import backend from "./main.js";
 
 test("local path", async () => {
@@ -30,3 +32,13 @@ test("local path", async () => {
     );
   }
 });
+
+backendSuite("alias", backend, { params: { remote: ":memory:/alias" } });
+
+test("the links of a list are in the alias", async () => {
+  const fs = remote(backend, { params: { remote: ":memory:/links" } });
+  await fs.put("a b.txt", new TextEncoder().encode("a"));
+  const html = await fs.get("").then((response) => response.text());
+  assert.ok(html.includes(` href="a%20b.txt?remote=%3Amemory%3A%2Flinks"`));
+  assert.ok(html.includes(` href="../?remote=%3Amemory%3A%2Flinks"`));
+});
diff --git a/lib/path.js b/lib/path.js
index 16c04bf..317bdc9 100644
--- a/lib/path.js
+++ b/lib/path.js
@@ -34,3 +34,13 @@ export function decodePath(pathname) {
 
   return `/${names.join("/")}`;
 }
+
+/**
+ * Puts the percent-encoding in each name of a path, the reverse of
+ * `decodePath`.
+ * @param {string} path For example `/a b/c.txt`.
+ * @returns {string} For example `/a%20b/c.txt`.
+ */
+export function encodePath(path) {
+  return path.split("/").map(encodeURIComponent).join("/");
+}

From baa3c20969b0c4c13f57d8e621eae78c050507b7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sat, 17 Oct 2026 03:40:05 +0000
Subject: [PATCH 28/87] feat(lib): read sizes as rclone

parseSize reads a size as SizeSuffix of rclone: no suffix is KiB, b is bytes, and k, M, G, T, P and E are powers of 1024, with an optional i and B. off is -1. The test has the vectors of TestSizeSuffixSet of rclone.
---
 lib/size.js      | 60 ++++++++++++++++++++++++++++++++++++++++++++++++
 lib/size_test.js | 40 ++++++++++++++++++++++++++++++++
 2 files changed, 100 insertions(+)
 create mode 100644 lib/size.js
 create mode 100644 lib/size_test.js

diff --git a/lib/size.js b/lib/size.js
new file mode 100644
index 0000000..cb13d13
--- /dev/null
+++ b/lib/size.js
@@ -0,0 +1,60 @@
+/** The multipliers of the suffixes of a size, as rclone reads them. */
+const SYMBOLS = {
+  k: 2 ** 10,
+  m: 2 ** 20,
+  g: 2 ** 30,
+  t: 2 ** 40,
+  p: 2 ** 50,
+  e: 2 ** 60,
+};
+
+/**
+ * Reads a size as `SizeSuffix.Set` of rclone: a number with an optional
+ * suffix of 1024 (k), 1024² (M), and so on to E, with an optional "i" and
+ * "B" after it. A number with no suffix is in KiB, and "b" or "B" is a size
+ * in bytes. "off" is -1.
+ * @param {string} text For example `10M`, `2Gi`, `100KiB` or `4096b`.
+ * @returns {number} The size in bytes.
+ * @throws {RangeError} For a text that rclone does not accept.
+ */
+export function parseSize(text) {
+  if (text === "") throw new RangeError("Size: empty string.");
+  if (text.toLowerCase() === "off") return -1;
+
+  let suffix = text.at(-1);
+  let suffixLength = 1;
+  let multiplier;
+  if (/[0-9.]/.test(suffix)) {
+    suffixLength = 0;
+    multiplier = SYMBOLS.k;
+  } else if (suffix === "b" || suffix === "B") {
+    if (text.length > 2 && text.at(-2) === "i") {
+      suffix = text.at(-3);
+      suffixLength = 3;
+      multiplier = SYMBOLS[suffix.toLowerCase()];
+    } else {
+      multiplier = 1;
+    }
+  } else if (suffix === "i" || suffix === "I") {
+    if (text.length > 1) {
+      suffix = text.at(-2);
+      suffixLength = 2;
+      multiplier = SYMBOLS[suffix.toLowerCase()];
+    }
+  } else {
+    multiplier = SYMBOLS[suffix.toLowerCase()];
+  }
+  if (!multiplier) {
+    throw new RangeError(`Size: bad suffix ${JSON.stringify(suffix)}.`);
+  }
+
+  const number = text.slice(0, text.length - suffixLength);
+  if (!/^[+-]?(\d+\.?\d*|\.\d+)([eE][+-]?\d+)?$/.test(number)) {
+    throw new RangeError(`Size: ${JSON.stringify(text)} is not a number.`);
+  }
+  const value = Number(number);
+  if (value < 0) {
+    throw new RangeError(`Size: ${JSON.stringify(text)} is negative.`);
+  }
+  return Math.trunc(value * multiplier);
+}
diff --git a/lib/size_test.js b/lib/size_test.js
new file mode 100644
index 0000000..c257f13
--- /dev/null
+++ b/lib/size_test.js
@@ -0,0 +1,40 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+
+import { parseSize } from "./size.js";
+
+test("parseSize reads the sizes of rclone (TestSizeSuffixSet)", () => {
+  for (
+    const [text, size] of [
+      ["0", 0],
+      ["1b", 1],
+      ["102B", 102],
+      ["0.1k", 102],
+      ["0.1", 102],
+      ["1K", 1024],
+      ["1k", 1024],
+      ["1KI", 1024],
+      ["1Ki", 1024],
+      ["1kI", 1024],
+      ["1ki", 1024],
+      ["1KiB", 1024],
+      ["1kib", 1024],
+      ["1", 1024],
+      ["2.5", 1024 * 2.5],
+      ["1M", 1024 * 1024],
+      ["1Mi", 1024 * 1024],
+      ["1MiB", 1024 * 1024],
+      ["1.g", 1024 * 1024 * 1024],
+      ["10G", 10 * 1024 ** 3],
+      ["10T", 10 * 1024 ** 4],
+      ["10P", 10 * 1024 ** 5],
+      ["off", -1],
+      ["OFF", -1],
+    ]
+  ) {
+    assert.equal(parseSize(text), size, text);
+  }
+  for (const text of ["", "1q", "1.q", "-1K", "1i", "1iB", "1MB"]) {
+    assert.throws(() => parseSize(text), RangeError, text);
+  }
+});

From ef717e2bfccb3ac00ab7811aafd0e54ce0c8a29e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sat, 17 Oct 2026 03:40:31 +0000
Subject: [PATCH 29/87] fix(chunker): the format of rclone, on the shared test
 suite

The chunker backend now writes and reads the files of the chunker of rclone 1.75.1:

- The names of the chunks are as name_format, with start_from, and with the suffix of a transaction for norename. A name with the form of a chunk, a control chunk or a temporary chunk is not a file of the list.
- The metadata is simplejson, version 1 or 2, with the size, the number of chunks, md5 or sha1, and the transaction. As rclone, it reads at most 1023 bytes and writes at most 255 bytes, and it refuses metadata that is not correct.
- meta_format none needs hash_type none, as in rclone. Then a file is always in chunks.
- A small file goes to the remote as it is. When its content looks like metadata, it gets one chunk and metadata.
- A file of unknown size goes in chunks with metadata when it is larger than 1 MiB or than the chunk size.
- A list gives the sum of the sizes of the chunks, and it does not show a file with missing chunks. GET of such a file gives 500.
- DELETE deletes the metadata first, then the chunks.
- chunk_size is a size of rclone, 2 GiB by default.

The backends of rfetch cannot rename. Thus with the transactions rename, a reader can see a file that is not complete. The transactions auto are norename.

The tests run the shared suite in three modes, and check the files on the remote. With rclone, the tests copy files in the two directions, and check that rfetch and rclone make the same files. In the mode rename, the chunks and the metadata are the same bytes.
---
 backend/chunker/main.js        | 1023 +++++++++++++++++++++++++-------
 backend/chunker/main_test.js   |  466 +++++----------
 backend/chunker/rclone_test.js |  196 ++++++
 3 files changed, 1149 insertions(+), 536 deletions(-)
 create mode 100644 backend/chunker/rclone_test.js

diff --git a/backend/chunker/main.js b/backend/chunker/main.js
index 4494ecb..bab864a 100644
--- a/backend/chunker/main.js
+++ b/backend/chunker/main.js
@@ -17,11 +17,12 @@
  * called a streaming upload), chunker will internally create a temporary copy,
  * record its size and repeat the above process.
  *
- * When upload completes, temporary chunk files are finally renamed. This
- * scheme guarantees that operations can be run in parallel and look from
- * outside as atomic. A similar method with hidden temporary chunks is used for
- * other operations (copy/move/rename, etc.). If an operation fails, hidden
- * chunks are normally destroyed, and the target composite file stays intact.
+ * rclone puts the chunks with temporary names, and renames them when the
+ * upload is complete. The backends of rfetch cannot rename. Thus with the
+ * transactions `rename`, the chunks get their last names at once, and a
+ * reader can see a file that is not complete. With the transactions
+ * `norename`, the chunks have the suffix of the transaction, and the file
+ * changes only when its metadata changes. See `putFile`.
  *
  * When a composite file download is requested, chunker transparently assembles
  * it by concatenating data chunks in order. As the split is trivial one could
@@ -100,10 +101,22 @@
  * metadata enabled.
  */
 import { createHash } from "node:crypto";
-import { Chunker } from "../../lib/streams/chunker.js";
+import { readListing, renderListing } from "../../lib/listing.js";
+import { mimeType } from "../../lib/mime.js";
+import { decodePath, encodePath } from "../../lib/path.js";
+import { parseSize } from "../../lib/size.js";
+import { sized } from "../../lib/streams/sized.js";
 import { fetch } from "../../mod.js";
 
-const METADATA_VERSION = 1;
+/** The largest metadata that rclone reads, and that it writes, in bytes. */
+const MAX_METADATA_SIZE = 1023;
+const MAX_METADATA_SIZE_WRITTEN = 255;
+/** The version of the metadata with a transaction, and with none. */
+const METADATA_VERSION = 2;
+/** A control chunk has this type after "_" in place of its number. */
+const CTRL_TYPE = "[a-z][a-z0-9]{2,6}";
+/** The largest number of chunks of rclone. */
+const MAX_CHUNKS = 10_000_000;
 
 /**
  * @typedef {Object} Metadata
@@ -112,7 +125,7 @@ const METADATA_VERSION = 1;
  * @property {number} nchunks - number of data chunks in file
  * @property {string} [md5] - MD5 hashsum of composite file
  * @property {string} [sha1] - SHA1 hashsum
- * @property {number} [txn] - identifies current version of the file
+ * @property {string} [txn] - identifies current version of the file
  */
 
 export const options = {
@@ -130,7 +143,7 @@ export const options = {
   ],
   boolean: ["fail_hard"],
   default: {
-    chunk_size: 2 * 1024 * 1024 * 1024, // 2 GiB
+    chunk_size: "2Gi",
     hash_type: "md5", // | "sha1" | "md5all" | "sha1all" | "md5quick" | "sha1quick" | "none"
     meta_format: "simplejson", // | "none"
     name_format: "*.rclone_chunk.###",
@@ -139,262 +152,834 @@ export const options = {
   },
 };
 
+/**
+ * The options of a request.
+ * @typedef {Object} Config
+ * @property {string} remote
+ * @property {number} chunkSize
+ * @property {number} startFrom
+ * @property {boolean} useMeta
+ * @property {"md5" | "sha1" | ""} hash
+ * @property {boolean} hashAll True to write metadata for each file.
+ * @property {boolean} noRename True for the transactions "norename".
+ * @property {boolean} failHard
+ * @property {ReturnType<typeof nameFormat>} names
+ */
+
 /**
  * @param {Request} request
  * @returns {Promise<Response>}
  */
 async function chunker(request) {
-  const { method, url } = request;
-  const { pathname, searchParams } = new URL(url);
-
-  const remote = searchParams.get("remote");
-  if (!remote) {
-    throw new Error("Missing remote");
-  }
-  const chunkSize = Number(searchParams.get("chunk_size")) ||
-    options.default.chunk_size;
-  const nameFormat = searchParams.get("name_format") ||
-    options.default.name_format;
-  const startFrom = Number(
-    searchParams.get("start_from") || options.default.start_from,
-  );
-  const metaFormat = searchParams.get("meta_format") ||
-    options.default.meta_format;
-  // const failHard = searchParams.get("fail_hard") !== "false";
-  // const transactions = searchParams.get("transactions") ||
-  //   options.default.transactions;
+  const { method } = request;
+  const { pathname, searchParams } = new URL(request.url);
+
+  /** @type {Config} */
+  let config;
+  try {
+    config = configOf(searchParams);
+  } catch (error) {
+    return new Response(error.message, { status: 400 });
+  }
+  const path = decodePath(pathname);
+  if (path === null) {
+    return new Response(null, { status: 400 });
+  }
+
+  const slash = path.lastIndexOf("/", path.length - 2) + 1;
+  const dir = path.slice(0, slash);
+  const name = path.slice(slash);
+
+  if (path.endsWith("/")) {
+    if (method === "GET" || method === "HEAD") {
+      return await listFolder(config, path, method, `${searchParams}`);
+    }
+    // A folder is a folder of the remote.
+    const response = await fetch(config.remote + encodePath(path), {
+      method,
+      headers: request.headers,
+    });
+    await response.body?.cancel();
+    const headers = new Headers();
+    if (method === "PUT" && response.ok) {
+      headers.set("Content-Location", pathname);
+    }
+    return new Response(null, { status: response.status, headers });
+  }
+
+  try {
+    switch (method) {
+      case "GET":
+      case "HEAD":
+        return await getFile(config, dir, name, method);
+      case "PUT":
+        return await putFile(config, dir, name, request, pathname);
+      case "DELETE":
+        return await deleteFile(config, dir, name);
+    }
+  } catch (error) {
+    if (!(error instanceof ChunkerError)) throw error;
+    return new Response(error.message, { status: error.status });
+  }
+  return new Response(null, {
+    status: 405,
+    headers: { Allow: "GET, HEAD, PUT, DELETE" },
+  });
+}
+
+/** An error with the status of the answer. */
+class ChunkerError extends Error {
+  /** @param {string} message @param {number} status */
+  constructor(message, status) {
+    super(`chunker: ${message}`);
+    this.status = status;
+  }
+}
+
+/**
+ * Reads the options, as `NewFs` of the chunker of rclone.
+ * @param {URLSearchParams} searchParams
+ * @returns {Config}
+ */
+function configOf(searchParams) {
+  const get = (name) => searchParams.get(name) ?? options.default[name];
 
-  if (startFrom < 0) {
+  const remote = searchParams.get("remote")?.replace(/\/$/, "");
+  if (!remote) throw new Error("Missing remote");
+
+  const chunkSize = parseSize(`${get("chunk_size")}`);
+  if (chunkSize <= 0) throw new Error("chunk_size must be positive");
+
+  const startFrom = Number(get("start_from"));
+  if (!Number.isInteger(startFrom) || startFrom < 0) {
     throw new Error("start_from must be non-negative");
   }
 
-  const headers = new Headers();
-  let status = 200, body = null;
+  const metaFormat = get("meta_format");
+  if (metaFormat !== "simplejson" && metaFormat !== "none") {
+    throw new Error(`unsupported meta format '${metaFormat}'`);
+  }
+  const useMeta = metaFormat === "simplejson";
+
+  const hashType = get("hash_type");
+  const hashes = {
+    none: ["", false],
+    md5: ["md5", false],
+    sha1: ["sha1", false],
+    md5quick: ["md5", false],
+    sha1quick: ["sha1", false],
+    md5all: ["md5", true],
+    sha1all: ["sha1", true],
+  };
+  if (!Object.hasOwn(hashes, hashType)) {
+    throw new Error(`unsupported hash type '${hashType}'`);
+  }
+  const [hash, hashAll] = hashes[hashType];
+  if (hash && !useMeta) {
+    throw new Error(`hash type '${hashType}' requires compatible meta format`);
+  }
 
-  const fileName = pathname.split("/").pop();
+  // The backends of rfetch cannot rename, thus "auto" is "norename".
+  const transactions = get("transactions");
+  if (!["rename", "norename", "auto"].includes(transactions)) {
+    throw new Error(`unsupported transaction mode '${transactions}'`);
+  }
+  const noRename = transactions !== "rename";
+  if (noRename && !useMeta) {
+    throw new Error("using norename transactions requires metadata");
+  }
 
-  if (method === "GET") {
-    // Gets the file from the remote. This file can be the metadata file or the
-    // original file, either size should not be greater than the chunk size.
-    const response = await fetch(`${remote}/${fileName}`);
+  return {
+    remote,
+    chunkSize,
+    startFrom,
+    useMeta,
+    hash,
+    hashAll,
+    noRename,
+    failHard: get("fail_hard") === "true",
+    names: nameFormat(get("name_format"), startFrom),
+  };
+}
 
-    // Responds immediately if meta_format is none.
-    if (metaFormat === "none") {
-      return new Response(response.body, {
-        status,
-        headers,
-      });
+/**
+ * Makes and reads the names of chunks, as `setChunkNameFormat`,
+ * `makeChunkName` and `parseChunkName` of the chunker of rclone.
+ * @param {string} pattern For example `*.rclone_chunk.###`.
+ * @param {number} startFrom The number of the first chunk.
+ */
+function nameFormat(pattern, startFrom) {
+  if (pattern.split("*").length !== 2) {
+    throw new Error("pattern must have exactly one asterisk (*)");
+  }
+  const digits = pattern.split("#").length - 1;
+  if (digits < 1) throw new Error("pattern must have a hash character (#)");
+  if (pattern.indexOf("*") > pattern.indexOf("#")) {
+    throw new Error("asterisk (*) in pattern must come before hashes (#)");
+  }
+  if (!/^[^#]*#+[^#]*$/.test(pattern)) {
+    throw new Error("hashes (#) in pattern must be consecutive");
+  }
+  if (pattern.includes("/")) throw new Error("directory separator prohibited");
+  if (pattern[0] !== "*") throw new Error("pattern must start with asterisk");
+
+  // The parts of the pattern before and after the number.
+  const [before, after] = pattern.split(/#+/);
+  const number = digits > 1 ? `[0-9]{${digits},}` : "[0-9]+";
+  const source = pattern
+    .replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
+    .replace(/#+/, `(?:(${number})|_(${CTRL_TYPE}))`)
+    // A name has no "\n", as "." of Go. Non-greedy, to keep the suffix.
+    .replace("\\*", "([^\\n]+?)");
+  const regex = new RegExp(
+    `^${source}(?:_([0-9a-z]{4,9})|\\.\\.tmp_([0-9]{10,13}))?$`,
+  );
+
+  return {
+    /**
+     * The name of a data chunk, from 0. A transaction gives a suffix.
+     * @param {string} main
+     * @param {number} chunkNo
+     * @param {string} [xact]
+     */
+    make(main, chunkNo, xact = "") {
+      // A "#" in the name of the file is not a part of the pattern.
+      const name = before.replace("*", () => main) +
+        `${chunkNo + startFrom}`.padStart(digits, "0") + after;
+      return xact ? `${name}_${xact.padStart(4, "0")}` : name;
+    },
+    /**
+     * The parts of the name of a chunk, or null for a name that is not a
+     * chunk. `chunkNo` is -1 for a control chunk.
+     * @param {string} name
+     * @returns {{ main: string, chunkNo: number, ctrl: string, xact: string } | null}
+     */
+    parse(name) {
+      const match = regex.exec(name);
+      if (!match || !match[1]) return null;
+      let chunkNo = -1;
+      if (match[2]) {
+        chunkNo = Number(match[2]) - startFrom;
+        if (chunkNo < 0) return null;
+      }
+      let xact = match[4] ?? "";
+      if (match[5]) {
+        // The old suffix of a transaction, as a number in base 36.
+        xact = Number(match[5]).toString(36).padStart(4, "0");
+      }
+      return { main: match[1], chunkNo, ctrl: match[3] ?? "", xact };
+    },
+  };
+}
+
+/**
+ * Gives the entries of a folder of the remote, or null when the folder does
+ * not exist.
+ * @param {Config} config
+ * @param {string} dir The path of the folder, with "/" at the end.
+ */
+async function listRemote(config, dir) {
+  const response = await fetch(config.remote + encodePath(dir));
+  if (response.status === 404) {
+    await response.body?.cancel();
+    return null;
+  }
+  if (!response.ok) {
+    await response.body?.cancel();
+    throw new ChunkerError(`the list of ${dir} gave ${response.status}`, 502);
+  }
+  return await readListing(response, new URL(encodePath(dir), "http://remote"));
+}
+
+/**
+ * A file of the chunker: a file of the remote, or a composite file of data
+ * chunks.
+ * @typedef {Object} ChunkedFile
+ * @property {string} name
+ * @property {import("../../lib/listing.js").Entry | undefined} main The
+ *   file with the name on the remote: the file, or its metadata.
+ * @property {import("../../lib/listing.js").Entry[] | null} chunks The data
+ *   chunks in their order, or null for a file that is not composite.
+ * @property {number} size
+ * @property {string} modTime
+ */
+
+/**
+ * Groups the entries of a folder of the remote into folders and files, as
+ * `processEntries` of the chunker of rclone. A file with missing chunks is
+ * not in the result.
+ * @param {Config} config
+ * @param {import("../../lib/listing.js").Entry[]} entries
+ * @param {(name: string) => Promise<Metadata | null>} metadataOf Reads the
+ *   metadata of a file, for a composite file of a transaction.
+ */
+async function group(config, entries, metadataOf) {
+  /** @type {Map<string, import("../../lib/listing.js").Entry>} */
+  const mains = new Map();
+  /** @type {Map<string, Map<string, import("../../lib/listing.js").Entry[]>>} */
+  const chunks = new Map();
+  const folders = [];
+
+  for (const entry of entries) {
+    if (entry.IsDir) {
+      folders.push(entry);
+      continue;
+    }
+    const parsed = config.names.parse(entry.Name);
+    if (!parsed) {
+      mains.set(entry.Name, entry);
+    } else if (!parsed.ctrl) {
+      if (!chunks.has(parsed.main)) chunks.set(parsed.main, new Map());
+      const byXact = chunks.get(parsed.main);
+      if (!byXact.has(parsed.xact)) byXact.set(parsed.xact, []);
+      byXact.get(parsed.xact)[parsed.chunkNo] = entry;
     }
+  }
 
-    // Otherwise, the response should be less than or equal to the chunk size.
-    body = await response.arrayBuffer();
+  /** @type {ChunkedFile[]} */
+  const files = [];
+  const names = new Set([
+    ...mains.keys(),
+    ...(config.useMeta ? [] : chunks.keys()),
+  ]);
+  for (const name of names) {
+    const main = mains.get(name);
+    const byXact = chunks.get(name);
+    let active = byXact?.get("");
+
+    if (config.useMeta && byXact && !active && main.Size <= MAX_METADATA_SIZE) {
+      // The chunks of a "norename" transaction have its suffix.
+      const xact = (await metadataOf(name))?.txn;
+      if (xact) active = byXact.get(xact);
+    }
 
-    try {
-      // TODO: better way to handle this? Parsing a 2GB file is not ideal.
-      /**
-       * @type {Metadata}
-       */
-      const { size, nchunks } = JSON.parse(
-        new TextDecoder().decode(body),
-      );
+    if (!active) {
+      if (main) {
+        files.push({
+          name,
+          main,
+          chunks: null,
+          size: main.Size,
+          modTime: main.ModTime,
+        });
+      }
+      continue;
+    }
+    // The metadata of a composite file is small, and no chunk is missing.
+    if (config.useMeta && main.Size > MAX_METADATA_SIZE) continue;
+    if (active.length > MAX_CHUNKS || active.includes(undefined)) continue;
+    files.push({
+      name,
+      main,
+      chunks: active,
+      size: active.reduce((total, chunk) => total + chunk.Size, 0),
+      modTime: (main ?? active[0]).ModTime,
+    });
+  }
+  return { folders, files };
+}
 
-      headers.set("Content-Length", size.toString());
-
-      body = new ReadableStream({
-        async start(controller) {
-          let bytesProcessed = 0;
-          for (let i = startFrom; i < nchunks + startFrom; i++) {
-            const chunkName = formatName(fileName, i, nameFormat);
-            const { body } = await fetch(`${remote}/${chunkName}`);
-            const reader = body.getReader();
-
-            while (true) {
-              const { done, value } = await reader.read();
-              if (done) {
-                break;
-              }
-              controller.enqueue(value);
-              bytesProcessed += value.byteLength;
-              if (bytesProcessed >= size) {
-                break;
-              }
-            }
-
-            reader.releaseLock();
-
-            if (bytesProcessed >= size) {
-              break;
-            }
-          }
+/**
+ * Reads and checks metadata, as `unmarshalSimpleJSON` of rclone. It gives
+ * null for a file that rclone does not take as metadata.
+ * @param {Uint8Array} data
+ * @returns {Metadata | null}
+ * @throws {ChunkerError} For metadata of a newer version of rclone.
+ */
+function readMetadata(data) {
+  if (data.length > MAX_METADATA_SIZE_WRITTEN) return null;
+  if (data.length < 2 || data[0] !== 0x7b || data.at(-1) !== 0x7d) return null;
+  let metadata;
+  try {
+    metadata = JSON.parse(
+      new TextDecoder("utf-8", { fatal: true }).decode(data),
+    );
+  } catch {
+    return null;
+  }
+  if (typeof metadata !== "object" || metadata === null) return null;
+  const { ver, size, nchunks, md5, sha1, txn } = metadata;
+  const integer = (value) => Number.isInteger(value);
+  if (!integer(ver) || !integer(size) || !integer(nchunks)) return null;
+  if (ver < 1 || size < 0 || nchunks < 0) return null;
+  if (nchunks > MAX_CHUNKS) {
+    throw new ChunkerError("chunk number overflow", 500);
+  }
+  if (md5 !== undefined && md5 !== "" && !/^[0-9a-fA-F]{32}$/.test(md5)) {
+    return null;
+  }
+  if (sha1 !== undefined && sha1 !== "" && !/^[0-9a-fA-F]{40}$/.test(sha1)) {
+    return null;
+  }
+  if (nchunks < 1 && ver <= METADATA_VERSION) return null;
+  if (ver > METADATA_VERSION) {
+    throw new ChunkerError("unknown metadata, please upgrade rclone", 500);
+  }
+  return {
+    ver,
+    size,
+    nchunks,
+    md5,
+    sha1,
+    txn: typeof txn === "string" ? txn : "",
+  };
+}
 
-          controller.close();
-        },
-      })
-        .pipeThrough(
-          new TransformStream({
-            transform(chunk, controller) {
-              controller.enqueue(chunk);
-            },
-          }),
-        );
-    } catch (_error) { // Not a metadata file.
+/**
+ * Writes metadata, as `marshalSimpleJSON` of rclone.
+ * @param {number} size
+ * @param {number} nchunks
+ * @param {{ md5?: string, sha1?: string }} hashes
+ * @param {string} xact
+ */
+function writeMetadata(size, nchunks, { md5, sha1 }, xact) {
+  const metadata = { ver: xact ? METADATA_VERSION : 1, size, nchunks };
+  if (md5) metadata.md5 = md5;
+  if (sha1) metadata.sha1 = sha1;
+  if (xact) metadata.txn = xact;
+  return new TextEncoder().encode(JSON.stringify(metadata));
+}
+
+/**
+ * Gives a function that reads the metadata of the files of a folder.
+ * @param {Config} config
+ * @param {string} dir
+ */
+function metadataReader(config, dir) {
+  return async (name) => {
+    const response = await fetch(config.remote + encodePath(dir + name));
+    if (!response.ok) {
+      await response.body?.cancel();
+      return null;
     }
+    return readMetadata(new Uint8Array(await response.arrayBuffer()));
+  };
+}
+
+/**
+ * Gives the list of a folder, with the composite files and no chunk.
+ * @param {Config} config
+ * @param {string} path
+ * @param {string} method
+ * @param {string} query
+ */
+async function listFolder(config, path, method, query) {
+  let entries;
+  try {
+    entries = await listRemote(config, path);
+  } catch (error) {
+    if (!(error instanceof ChunkerError)) throw error;
+    return new Response(error.message, { status: error.status });
+  }
+  if (!entries) {
+    return new Response(null, { status: 404 });
+  }
+  const headers = { "Content-Type": "text/html;charset=utf-8" };
+  if (method === "HEAD") {
+    return new Response(null, { headers });
   }
+  const { folders, files } = await group(
+    config,
+    entries,
+    metadataReader(config, path),
+  );
+  const list = [
+    ...folders,
+    ...files.map(({ name, size, modTime }) => ({
+      Name: name,
+      IsDir: false,
+      Size: size,
+      MimeType: mimeType(name),
+      ModTime: modTime,
+    })),
+  ];
+  return new Response(renderListing(list, { query }), { headers });
+}
 
-  if (method === "PUT") {
-    let chunkIndex = startFrom;
-    let fileSize = 0;
+/**
+ * Gives the entries of the remote for a file: the file with the name, and
+ * its chunks.
+ * @param {Config} config
+ * @param {string} dir
+ * @param {string} name
+ */
+async function ownEntries(config, dir, name) {
+  return (await listRemote(config, dir) ?? []).filter((entry) =>
+    !entry.IsDir &&
+    (entry.Name === name || config.names.parse(entry.Name)?.main === name)
+  );
+}
 
-    const streams = metaFormat === "none" ? [request.body] : request.body.tee();
-    const digestStream = streams[1] && md5(streams[1]);
+/**
+ * Finds a file of the chunker in its folder, and checks the metadata of a
+ * composite file, as `readMetadata` of rclone.
+ * @param {Config} config
+ * @param {string} dir
+ * @param {string} name
+ * @returns {Promise<{ file: ChunkedFile | null }>}
+ */
+async function findFile(config, dir, name) {
+  const own = await ownEntries(config, dir, name);
+  const readMeta = metadataReader(config, dir);
+  /** @type {Map<string, Metadata | null>} */
+  const read = new Map();
+  const metadataOf = async (name) => {
+    if (!read.has(name)) read.set(name, await readMeta(name));
+    return read.get(name);
+  };
+
+  const { files } = await group(config, own, metadataOf);
+  let file = files.find((file) => file.name === name) ?? null;
+
+  if (file?.chunks && config.useMeta) {
+    const metadata = await metadataOf(name);
+    if (!metadata) {
+      throw new ChunkerError(`invalid metadata of ${name}`, 500);
+    }
+    if (
+      metadata.size !== file.size || metadata.nchunks !== file.chunks.length
+    ) {
+      throw new ChunkerError("metadata doesn't match file size", 500);
+    }
+  }
+  // A list does not show a composite file with a missing chunk, but a read
+  // of it is an error, as in rclone.
+  const main = own.some((entry) => entry.Name === name);
+  const chunks = own.some((entry) => {
+    const parsed = config.names.parse(entry.Name);
+    return parsed && !parsed.ctrl && !parsed.xact;
+  });
+  if (!file && chunks && (main || !config.useMeta)) {
+    throw new ChunkerError(`${name} has missing chunks`, 500);
+  }
+  return { file };
+}
 
-    /**
-     * @type {Uint8Array}
-     */
-    let previousChunk;
-
-    body = streams[0]
-      .pipeThrough(new Chunker(chunkSize))
-      .pipeThrough(
-        new TransformStream({
-          async transform(chunk) {
-            // In order to handle the last chunk, which is unknown in advance,
-            // we delay the upload by 1 iteration. The current iteration will
-            // upload the previous chunk, and let the flush() method upload the
-            // last chunk.
-            if (previousChunk) {
-              const chunkName = formatName(
-                fileName,
-                chunkIndex - 1,
-                nameFormat,
-              );
-              await upload(`${remote}/${chunkName}`, {
-                body: previousChunk,
-              });
-            }
-
-            previousChunk = chunk;
-            fileSize += chunk.length;
-            chunkIndex++;
-          },
-          // Finalizes the upload.
-          async flush() {
-            const chunked = fileSize > chunkSize;
-            // Uploads the last chunk here so we can control the file name whether
-            // the file is chunked or not.
-            if (previousChunk) {
-              const chunkName = chunked
-                ? formatName(fileName, chunkIndex - 1, nameFormat)
-                : fileName;
-              await upload(`${remote}/${chunkName}`, {
-                body: previousChunk,
-              });
-            }
-
-            // Skips if there is no metadata to upload.
-            if (!streams[1] || !chunked) {
-              return;
-            }
-
-            /**
-             * @type {Metadata}
-             */
-            const metadata = {
-              ver: METADATA_VERSION,
-              size: fileSize,
-              nchunks: chunkIndex - startFrom,
-              md5: await digestStream,
-            };
-            // Adds metadata.
-            await fetch(`${remote}/${fileName}`, {
-              method: "PUT",
-              headers: {
-                "Content-Type": "application/json; charset=UTF-8",
-              },
-              body: JSON.stringify(metadata),
-            });
-          },
-        }),
-      );
+/**
+ * @param {Config} config
+ * @param {string} dir
+ * @param {string} name
+ * @param {string} method
+ */
+async function getFile(config, dir, name, method) {
+  const { file } = await findFile(config, dir, name);
+  if (!file) {
+    return new Response(null, { status: 404 });
+  }
+  if (!file.chunks) {
+    // A file of the remote.
+    return await fetch(config.remote + encodePath(dir + name), { method });
+  }
 
-    status = 201;
-    headers.append("Content-Location", pathname);
+  const headers = new Headers({
+    "Content-Type": mimeType(name),
+    "Content-Length": `${file.size}`,
+  });
+  if (file.modTime) {
+    headers.set("Last-Modified", new Date(file.modTime).toUTCString());
+  }
+  if (method === "HEAD") {
+    return new Response(null, { headers });
   }
+  const urls = file.chunks.map((chunk) =>
+    config.remote + encodePath(dir + chunk.Name)
+  );
+  return new Response(sized(concatenate(urls), file.size), { headers });
+}
 
-  return new Response(body, {
-    status,
-    headers,
+/**
+ * Gives the data of files of the remote, one after the other.
+ * @param {string[]} urls
+ * @returns {ReadableStream<Uint8Array>}
+ */
+function concatenate(urls) {
+  let index = 0;
+  /** @type {ReadableStreamDefaultReader<Uint8Array> | null} */
+  let reader = null;
+  return new ReadableStream({
+    async pull(controller) {
+      while (true) {
+        if (!reader) {
+          if (index === urls.length) {
+            controller.close();
+            return;
+          }
+          const response = await fetch(urls[index++]);
+          if (!response.ok || !response.body) {
+            throw new Error(`chunker: chunk ${index} gave ${response.status}`);
+          }
+          reader = response.body.getReader();
+        }
+        const { done, value } = await reader.read();
+        if (done) {
+          reader = null;
+          continue;
+        }
+        controller.enqueue(value);
+        return;
+      }
+    },
+    cancel(reason) {
+      return reader?.cancel(reason);
+    },
   });
 }
 
 /**
- * Formats a chunk name
- *
- * The format uses `*` as a placeholder for the base file name and
- * one or more consecutive hash characters `#` as a placeholder for
- * sequential chunk number. There must be one and only one asterisk.
- * The number of consecutive hash characters defines the minimum
- * length of a string representing a chunk number. If decimal chunk
- * number has less digits than the number of hashes, it is
- * left-padded by zeros. If the decimal string is longer, it is left
- * intact. By default numbering starts from 1 but there is another
- * option that allows user to start from 0, e.g. for compatibility
- * with legacy software.
- *
- * For example, if name format is `big_*-##.part` and original file
- * name is `data.txt` and numbering starts from 0, then the first
- * chunk will be named `big_data.txt-00.part`, the 99th chunk will be
- * `big_data.txt-98.part` and the 302nd chunk will become
- * `big_data.txt-301.part`.
+ * Puts a file: a file of the remote when it fits in one chunk, else data
+ * chunks and metadata, as `put` of the chunker of rclone.
  *
- * @param {string} name - base file name
- * @param {number} index - chunk number
- * @param {string} format - format to use
- * @returns {string} formatted name
+ * rclone puts the chunks with temporary names and then renames them. The
+ * backends of rfetch cannot rename. Thus with the transactions "rename" the
+ * chunks get their last names at once, and a reader can see a file that is
+ * not complete. With "norename", the chunks have the suffix of the
+ * transaction, and the file changes only when the metadata changes.
+ * @param {Config} config
+ * @param {string} dir
+ * @param {string} name
+ * @param {Request} request
+ * @param {string} pathname
  */
-function formatName(name, index, format) {
-  return format.replace("*", name).replace(/([#])\1+/g, (hashes) => {
-    return `${index}`.padStart(hashes.length, "0");
+async function putFile(config, dir, name, request, pathname) {
+  const header = request.headers.get("Content-Length");
+  let length = header !== null && /^\d+$/.test(header) ? Number(header) : null;
+  const old = await ownEntries(config, dir, name);
+
+  const source = new Source(request.body);
+  if (length === null) {
+    // A small file of unknown size is a file of known size.
+    const head = await source.peek(Math.min(config.chunkSize, 2 ** 20) + 1);
+    if (head.done) length = head.size;
+  }
+
+  // A small file with the content of metadata needs metadata, else rclone
+  // takes it as metadata.
+  let single = length !== null && length <= config.chunkSize &&
+    config.useMeta && !config.hashAll;
+  if (single && length <= MAX_METADATA_SIZE) {
+    const head = await source.peek(length);
+    try {
+      single = readMetadata(head.bytes) === null;
+    } catch {
+      single = false;
+    }
+  }
+
+  /** @type {Set<string>} The names of the new version. */
+  const written = new Set();
+  if (single) {
+    const headers = new Headers();
+    const type = request.headers.get("Content-Type");
+    if (type) headers.set("Content-Type", type);
+    headers.set("Content-Length", `${length}`);
+    await put(
+      config.remote + encodePath(dir + name),
+      source.take(length),
+      headers,
+    );
+    await source.end(length);
+    written.add(name);
+  } else {
+    const xact = config.noRename ? newXactID() : "";
+    const hash = config.hash ? createHash(config.hash) : null;
+    let size = 0;
+    let chunkNo = 0;
+    do {
+      if (chunkNo >= MAX_CHUNKS) throw new ChunkerError("chunk overflow", 413);
+      const chunkName = config.names.make(name, chunkNo, xact);
+      const chunkSize = length === null
+        ? config.chunkSize
+        : Math.min(config.chunkSize, length - size);
+      const headers = new Headers();
+      if (length !== null) headers.set("Content-Length", `${chunkSize}`);
+      const before = source.count;
+      await put(
+        config.remote + encodePath(dir + chunkName),
+        source.take(chunkSize, hash),
+        headers,
+      );
+      size += source.count - before;
+      written.add(chunkName);
+      chunkNo++;
+    } while (length === null ? !(await source.peek(1)).done : size < length);
+    if (length !== null) await source.end(length);
+
+    if (config.useMeta) {
+      const hashes = hash ? { [config.hash]: hash.digest("hex") } : {};
+      const metadata = writeMetadata(size, chunkNo, hashes, xact);
+      await put(
+        config.remote + encodePath(dir + name),
+        new Blob([metadata]).stream(),
+        new Headers({
+          "Content-Type": "application/json",
+          "Content-Length": `${metadata.length}`,
+        }),
+      );
+      written.add(name);
+    }
+  }
+
+  // The chunks of the old version go away.
+  for (const entry of old) {
+    if (!written.has(entry.Name)) {
+      await remove(config.remote + encodePath(dir + entry.Name));
+    }
+  }
+
+  return new Response(null, {
+    status: 201,
+    headers: { "Content-Location": pathname },
   });
 }
 
 /**
- * @param {string | URL} url
- * @param {RequestInit} init
- * @returns
+ * @param {Config} config
+ * @param {string} dir
+ * @param {string} name
  */
-async function upload(url, init) {
-  const { headers, body } = init;
-  // Skips the chunk if it already exists.
-  const response = await fetch(url, {
-    method: "HEAD",
-    headers,
-  });
-  if (response.ok) {
-    //   return;
+async function deleteFile(config, dir, name) {
+  // No check of the chunks: a file with a missing chunk can go away too.
+  const entries = await ownEntries(config, dir, name);
+  if (!entries.length) {
+    return new Response(null, { status: 404 });
+  }
+  // The metadata first: then the file is not there, also when a chunk
+  // stays.
+  entries.sort((a, b) => (b.Name === name) - (a.Name === name));
+  for (const entry of entries) {
+    await remove(config.remote + encodePath(dir + entry.Name));
   }
+  return new Response(null, { status: 204 });
+}
 
-  // Sends the chunk to underlying remote.
-  return fetch(url, {
+/**
+ * Puts a body on the remote, or throws.
+ * @param {string} url
+ * @param {ReadableStream<Uint8Array>} body
+ * @param {Headers} headers
+ */
+async function put(url, body, headers) {
+  const response = await fetch(url, {
     method: "PUT",
     headers,
     body,
+    duplex: "half",
   });
+  await response.body?.cancel();
+  if (!response.ok) {
+    throw new ChunkerError(`PUT of a chunk gave ${response.status}`, 502);
+  }
 }
 
-export default {
-  fetch: chunker,
-};
+/** @param {string} url */
+async function remove(url) {
+  const response = await fetch(url, { method: "DELETE" });
+  await response.body?.cancel();
+}
+
+/**
+ * A transaction ID: 6 characters in base 36, as `newXactID` of rclone.
+ */
+function newXactID() {
+  const bytes = crypto.getRandomValues(new Uint8Array(6));
+  return [...bytes].map((byte) => (byte % 36).toString(36)).join("");
+}
 
 /**
- * Gives the MD5 of the stream, in hexadecimal.
- * @param {ReadableStream<Uint8Array>} stream
- * @returns {Promise<string>}
+ * The body of a request, which gives its bytes in parts of a size.
  */
-async function md5(stream) {
-  const hash = createHash("md5");
-  for await (const chunk of stream) {
-    hash.update(chunk);
+class Source {
+  /** @type {ReadableStreamDefaultReader<Uint8Array> | null} */
+  #reader;
+  /** @type {Uint8Array[]} The bytes that came back after a peek. */
+  #pending = [];
+  /** The number of bytes that `take` gave. */
+  count = 0;
+
+  /** @param {ReadableStream<Uint8Array> | null} body */
+  constructor(body) {
+    this.#reader = body?.getReader() ?? null;
+  }
+
+  /** @returns {Promise<Uint8Array | null>} */
+  async #read() {
+    if (this.#pending.length) return this.#pending.shift();
+    if (!this.#reader) return null;
+    const { done, value } = await this.#reader.read();
+    if (done) {
+      this.#reader = null;
+      return null;
+    }
+    return value;
+  }
+
+  /**
+   * Reads up to `size` bytes and gives them back to the source.
+   * @param {number} size
+   * @returns {Promise<{ bytes: Uint8Array, size: number, done: boolean }>}
+   */
+  async peek(size) {
+    const parts = [];
+    let total = 0;
+    let done = false;
+    while (total < size) {
+      const part = await this.#read();
+      if (!part) {
+        done = true;
+        break;
+      }
+      parts.push(part);
+      total += part.length;
+    }
+    this.#pending.unshift(...parts);
+    const bytes = new Uint8Array(total);
+    let offset = 0;
+    for (const part of parts) {
+      bytes.set(part, offset);
+      offset += part.length;
+    }
+    return { bytes: bytes.subarray(0, size), size: total, done };
+  }
+
+  /**
+   * Gives a stream of the next `size` bytes, or less at the end.
+   * @param {number} size
+   * @param {import("node:crypto").Hash | null} [hash]
+   * @returns {ReadableStream<Uint8Array>}
+   */
+  take(size, hash = null) {
+    let left = size;
+    return new ReadableStream({
+      pull: async (controller) => {
+        const part = left > 0 ? await this.#read() : null;
+        if (!part) {
+          controller.close();
+          return;
+        }
+        const bytes = part.length > left ? part.subarray(0, left) : part;
+        if (part.length > left) this.#pending.unshift(part.subarray(left));
+        left -= bytes.length;
+        this.count += bytes.length;
+        hash?.update(bytes);
+        controller.enqueue(bytes);
+      },
+    });
+  }
+
+  /**
+   * Makes sure that the body had the size of its Content-Length.
+   * @param {number} size
+   */
+  async end(size) {
+    if (this.count !== size || !(await this.peek(1)).done) {
+      throw new ChunkerError(
+        `incorrect upload size ${this.count} != ${size}`,
+        400,
+      );
+    }
   }
-  return hash.digest("hex");
 }
+
+export default {
+  fetch: chunker,
+};
diff --git a/backend/chunker/main_test.js b/backend/chunker/main_test.js
index 0981406..a02f6d9 100644
--- a/backend/chunker/main_test.js
+++ b/backend/chunker/main_test.js
@@ -1,345 +1,177 @@
-import { test } from "node:test";
-import { Buffer } from "node:buffer";
-import { createHash, randomBytes } from "node:crypto";
+import { describe, test } from "node:test";
 import assert from "node:assert/strict";
-import memory from "../memory/main.js";
+import { createHash } from "node:crypto";
+
+import { backendSuite } from "../../lib/testing/suite.js";
+import { remote } from "../../lib/testing/remote.js";
 import backend from "./main.js";
 
-/**
- * Tells if the two arrays have the same bytes.
- * @param {Uint8Array} a
- * @param {Uint8Array} b
- * @returns {boolean}
- */
-const sameBytes = (a, b) => Buffer.compare(a, b) === 0;
+// Small chunks, thus the files of the suite have more than one chunk.
+const CHUNK = "64k";
 
-const buffer = new Uint8Array(randomBytes(1024 * 1024 * 10)); // 10M
-const file = new File([buffer], "10M.bin", {
-  type: "application/octet-stream",
+backendSuite("chunker", backend, {
+  params: { remote: ":memory:/chunker", chunk_size: CHUNK },
+});
+// Without metadata, a name is always in chunks. rclone does not read the
+// name of a chunk with "\n": "." of Go does not match it.
+backendSuite("chunker meta_format=none", backend, {
+  params: {
+    remote: ":memory:/none",
+    chunk_size: CHUNK,
+    meta_format: "none",
+    hash_type: "none",
+  },
+  skipName: /\n/,
+});
+backendSuite("chunker transactions=norename", backend, {
+  params: {
+    remote: ":memory:/norename",
+    chunk_size: CHUNK,
+    transactions: "norename",
+  },
 });
-const MD5 = createHash("md5").update(buffer).digest("hex");
-
-let chunkSize = 1024 * 1024 * 4; // 4M
-
-const url = new URL(`/${file.name}`, "file:");
-url.searchParams.set("remote", ":memory:");
-url.searchParams.set("chunk_size", `${chunkSize}`);
 
-function cleanup(pathname = "/") {
-  return memory.fetch(
-    new Request(new URL(pathname, "memory:/"), {
-      method: "DELETE",
-    }),
-  );
+/** @param {number} size */
+function content(size) {
+  return new Uint8Array(size).map((_, index) => (index * 7 + 3) & 0xff);
 }
 
-test("PUT", async (t) => {
-  await t.test("new file", async () => {
-    let request = new Request(url, {
-      method: "PUT",
-      body: file,
-    });
-
-    let response = await backend.fetch(request);
-    await response.arrayBuffer(); // To kickstart the request.
-
-    // Checks the underlying remote to have the chunks.
-    request = new Request(new URL("/", "memory:/"), {
-      method: "HEAD",
-    });
-    response = await memory.fetch(request);
-    const links = response.headers.get("Link")?.split(/,\s*/);
-    const chunks = Math.ceil(file.size / chunkSize);
-
-    let startFrom = 1;
-    for (; startFrom < chunks; startFrom++) {
-      const link = links[startFrom - 1];
-      const chunkName = `${
-        encodeURIComponent(file.name)
-      }.rclone_chunk.00${startFrom}`;
-      assert.deepEqual(link, `<${chunkName}>`, `should have ${chunkName}`);
-
-      request = new Request(new URL(`/${chunkName}`, "memory:/"));
-      response = await memory.fetch(request);
-      const chunk = await response.arrayBuffer();
-
-      if (startFrom < chunks) {
-        assert.deepEqual(chunk.byteLength, chunkSize);
-      } else {
-        assert.deepEqual(chunk.byteLength, file.size % chunkSize);
-      }
-    }
-  });
-
-  await cleanup();
-
-  await t.test("chunk_size, name_format, start_from", async () => {
-    chunkSize = 100 * 1024; // 100K, so we can have hundreds of chunks
-    let startFrom = 0;
-
-    url.searchParams.set("chunk_size", `${chunkSize}`);
-    url.searchParams.set("name_format", `${file.name}.part##`);
-    url.searchParams.set("start_from", `${startFrom}`);
-
-    let request = new Request(url, {
-      method: "PUT",
-      body: file,
-    });
-
-    let response = await backend.fetch(request);
-    await response.arrayBuffer(); // To kickstart the request.
-
-    // Checks the underlying remote to have the chunks.
-    request = new Request(new URL("/", "memory:/"), {
-      method: "HEAD",
-    });
-    response = await memory.fetch(request);
-    const links = response.headers.get("Link")?.split(/,\s*/);
-    const chunks = Math.ceil(file.size / chunkSize);
-
-    for (; startFrom < chunks; startFrom++) {
-      const link = links[startFrom];
-
-      let chunkName = "";
-      if (startFrom < 10) {
-        chunkName = `${encodeURIComponent(file.name)}.part0${startFrom}`;
-      } else if (startFrom < 100) {
-        chunkName = `${encodeURIComponent(file.name)}.part${startFrom}`;
-      } else {
-        chunkName = `${encodeURIComponent(file.name)}.part${startFrom}`;
-      }
-      assert.deepEqual(
-        link,
-        `<${chunkName}>`,
-        `chunk ${startFrom} should have name of ${chunkName}, not ${link}`,
-      );
-
-      request = new Request(new URL(`/${chunkName}`, "memory:/"));
-      response = await memory.fetch(request);
-      const chunk = await response.arrayBuffer();
-
-      if (startFrom < chunks - 1) {
-        assert.deepEqual(chunk.byteLength, chunkSize);
-      } else {
-        assert.deepEqual(chunk.byteLength, file.size % chunkSize);
-      }
-    }
-  });
-
-  await cleanup();
-
-  await t.test("meta_format", async () => {
-    let request = new Request(url, {
-      method: "PUT",
-      body: file,
-    });
-
-    let response = await backend.fetch(request);
-    await response.arrayBuffer(); // To kickstart the request.
-
-    // Checks the underlying remote to have the chunks.
-    request = new Request(new URL("/", "memory:/"), {
-      method: "HEAD",
-    });
-    response = await memory.fetch(request);
-    const links = response.headers.get("Link")?.split(/,\s*/);
-    assert(
-      links.includes(`<${encodeURIComponent(file.name)}>`),
-      "should have the metadata file named after original file",
+describe("chunker", () => {
+  const root = ":memory:/layout";
+  const fs = remote(backend, { params: { remote: root, chunk_size: "1k" } });
+
+  /** The names of the files on the remote under the chunker. */
+  async function layout(path = "") {
+    const response = await globalThis.fetch(`${root}/${path}`);
+    const html = await response.text();
+    return [...html.matchAll(/<a href="([^"?]+)/g)]
+      .map(([, href]) => decodeURIComponent(href))
+      .filter((name) => name !== "../")
+      .sort();
+  }
+
+  /** @param {string} path */
+  async function text(path) {
+    return await globalThis.fetch(`${root}/${path}`).then((r) => r.text());
+  }
+
+  test("puts a small file as it is, and a large file in chunks", async () => {
+    await fs.put("small.bin", content(1024));
+    await fs.put("large.bin", content(2500));
+    assert.deepEqual(await layout(), [
+      "large.bin",
+      "large.bin.rclone_chunk.001",
+      "large.bin.rclone_chunk.002",
+      "large.bin.rclone_chunk.003",
+      "small.bin",
+    ]);
+    const md5 = createHash("md5").update(content(2500)).digest("hex");
+    assert.equal(
+      await text("large.bin"),
+      `{"ver":1,"size":2500,"nchunks":3,"md5":"${md5}"}`,
     );
-
-    request = new Request(new URL(`/${file.name}`, "memory:/"));
-    response = await memory.fetch(request);
-    const metadata = await response.json();
-    assert.deepEqual(metadata.ver, 1);
-    assert.deepEqual(metadata.size, file.size);
-    assert.deepEqual(metadata.nchunks, Math.ceil(file.size / chunkSize));
-    assert.deepEqual(metadata.md5, MD5);
   });
 
-  await cleanup();
-
-  await t.test("meta_format=none", async () => {
-    url.searchParams.set("meta_format", "none");
-    let request = new Request(url, {
-      method: "PUT",
-      body: file,
-    });
-
-    let response = await backend.fetch(request);
-    await response.arrayBuffer(); // To kickstart the request.
-
-    // Checks the underlying remote to have the chunks.
-    request = new Request(new URL("/", "memory:/"), {
-      method: "HEAD",
-    });
-    response = await memory.fetch(request);
-    const links = response.headers.get("Link")?.split(/,\s*/);
-    const chunks = Math.ceil(file.size / chunkSize);
-
-    assert.deepEqual(links.length, chunks);
-
-    request = new Request(new URL(`/${file.name}`, "memory:/"));
-    response = await memory.fetch(request);
-    assert.deepEqual(response.status, 404);
-  });
-
-  await cleanup();
-
-  await t.test("chunk_size>file_size", async () => {
-    url.searchParams.set("meta_format", "simplejson");
-    url.searchParams.delete("chunk_size"); // Default is 2G, > file size of 10M
-
-    let request = new Request(url, {
-      method: "PUT",
-      body: file,
-    });
-
-    let response = await backend.fetch(request);
-    await response.arrayBuffer(); // To kickstart the request.
-
-    // Checks the underlying remote to have the chunks.
-    request = new Request(new URL("/", "memory:/"), {
-      method: "HEAD",
-    });
-    response = await memory.fetch(request);
-    const links = response.headers.get("Link")?.split(/,\s*/);
-
-    assert.deepEqual(links.length, 1, "should only have 1 file");
+  test("removes the old chunks when a file changes", async () => {
+    await fs.put("large.bin", content(1500));
     assert.deepEqual(
-      links[0],
-      `<${encodeURIComponent(file.name)}>`,
-      "should have the original file name",
+      (await layout()).filter((name) => name.startsWith("large")),
+      [
+        "large.bin",
+        "large.bin.rclone_chunk.001",
+        "large.bin.rclone_chunk.002",
+      ],
     );
-
-    request = new Request(new URL(`/${file.name}`, "memory:/"));
-    response = await memory.fetch(request);
-    const body = await response.arrayBuffer();
-    assert(
-      sameBytes(new Uint8Array(body), buffer),
-      "should be the original file",
+    await fs.put("large.bin", content(10));
+    assert.deepEqual(
+      (await layout()).filter((name) => name.startsWith("large")),
+      [
+        "large.bin",
+      ],
     );
+    await fs.delete("large.bin");
+    await fs.delete("small.bin");
+    assert.deepEqual(await layout(), []);
   });
-});
 
-await cleanup();
-
-test("GET", async (t) => {
-  url.searchParams.set("chunk_size", `${chunkSize}`);
-  url.searchParams.set("start_from", `0`);
-
-  await t.test("file > chunk_size, start_from = 0", async () => {
-    let request = new Request(url, {
+  test("puts a file of unknown size in chunks with metadata", async () => {
+    const data = content(3000);
+    const body = new Blob([data]).stream();
+    const response = await fs.send("stream.bin", {
       method: "PUT",
-      body: file,
-    });
-    let response = await backend.fetch(request);
-    await response.arrayBuffer(); // To kickstart the request.
-
-    request = new Request(url);
-    response = await backend.fetch(request);
-    const body = await response.arrayBuffer();
-    assert(sameBytes(new Uint8Array(body), buffer));
+      body,
+      duplex: "half",
+    });
+    assert.equal(response.status, 201);
+    assert.deepEqual((await layout()).length, 4);
+    const back = await fs.get("stream.bin");
+    assert.deepEqual(new Uint8Array(await back.arrayBuffer()), data);
+    await fs.delete("stream.bin");
   });
 
-  await cleanup();
-
-  url.searchParams.delete("start_from");
-
-  await t.test("file > chunk_size, start_from = 1", async () => {
-    let request = new Request(url, {
-      method: "PUT",
-      body: file,
-    });
-    let response = await backend.fetch(request);
-    await response.arrayBuffer(); // To kickstart the request.
-
-    request = new Request(url);
-    response = await backend.fetch(request);
-    const body = await response.arrayBuffer();
-    assert(
-      sameBytes(new Uint8Array(body), buffer),
-      "should return original file",
-    );
+  test("keeps a small file with the content of metadata in a chunk", async () => {
+    const fake = new TextEncoder().encode(`{"ver":1,"size":5,"nchunks":1}`);
+    await fs.put("fake.json", fake);
+    assert.deepEqual(await layout(), [
+      "fake.json",
+      "fake.json.rclone_chunk.001",
+    ]);
+    const back = await fs.get("fake.json");
+    assert.deepEqual(new Uint8Array(await back.arrayBuffer()), fake);
+    await fs.delete("fake.json");
   });
 
-  await cleanup();
-
-  await t.test("file < chunk_size", async () => {
-    url.searchParams.delete("chunk_size");
-
-    let request = new Request(url, {
-      method: "PUT",
-      body: file,
+  test("hides a file with a missing chunk", async () => {
+    await fs.put("broken.bin", content(2500));
+    await globalThis.fetch(`${root}/broken.bin.rclone_chunk.002`, {
+      method: "DELETE",
     });
-    let response = await backend.fetch(request);
-    await response.arrayBuffer(); // To kickstart the request.
-
-    request = new Request(url);
-    response = await backend.fetch(request);
-    const body = await response.arrayBuffer();
-    assert(
-      sameBytes(new Uint8Array(body), buffer),
-      "should return original file",
-    );
+    assert.deepEqual(await fs.list(""), []);
+    const response = await fs.get("broken.bin");
+    assert.equal(response.status, 500);
+    await fs.delete("broken.bin");
   });
 
-  await cleanup();
-
-  await t.test("file = chunk_size", async () => {
-    url.searchParams.set("chunk_size", `${file.size}`);
-
-    let request = new Request(url, {
-      method: "PUT",
-      body: file,
-    });
-    let response = await backend.fetch(request);
-    await response.arrayBuffer(); // To kickstart the request.
-
-    request = new Request(url);
-    response = await fetch(request);
-    const body = await response.arrayBuffer();
-    assert(
-      sameBytes(new Uint8Array(body), buffer),
-      "should return original file",
-    );
+  test("gives 400 for options that rclone refuses", async () => {
+    for (
+      const params of [
+        {},
+        { remote: root, chunk_size: "1q" },
+        { remote: root, name_format: "no-asterisk.#" },
+        { remote: root, name_format: "*.chunk" },
+        { remote: root, meta_format: "xml" },
+        { remote: root, hash_type: "crc" },
+        { remote: root, meta_format: "none" },
+        {
+          remote: root,
+          meta_format: "none",
+          hash_type: "none",
+          transactions: "norename",
+        },
+      ]
+    ) {
+      const response = await remote(backend, { params }).get("");
+      assert.equal(response.status, 400, JSON.stringify(params));
+    }
   });
 
-  await cleanup();
-
-  await t.test("Non-metadata JSON file within chunk_size", async () => {
-    const json = { hello: "world" };
-    const file = new Blob([JSON.stringify(json)]);
-    url.searchParams.set("chunk_size", `${file.size}`);
-
-    let request = new Request(url, {
-      method: "PUT",
-      body: file,
-    });
-    let response = await backend.fetch(request);
-    await response.arrayBuffer(); // To kickstart the request.
-
-    request = new Request(url);
-    response = await backend.fetch(request);
-    let body = await response.json();
-    assert.deepEqual(body, json, "should return original file");
-
-    await cleanup();
-
-    url.searchParams.delete("chunk_size");
-    request = new Request(url, {
-      method: "PUT",
-      body: file,
-    });
-    response = await backend.fetch(request);
-    await response.arrayBuffer(); // To kickstart the request.
-
-    request = new Request(url);
-    response = await backend.fetch(request);
-    body = await response.json();
-    assert.deepEqual(body, json, "should return original file");
+  test("names the chunks with name_format and start_from", async () => {
+    const custom = remote(backend, {
+      params: {
+        remote: root,
+        chunk_size: "1k",
+        name_format: "*.part#",
+        start_from: "0",
+      },
+    });
+    await custom.put("a.bin", content(2048 + 1));
+    assert.deepEqual(await layout(), [
+      "a.bin",
+      "a.bin.part0",
+      "a.bin.part1",
+      "a.bin.part2",
+    ]);
+    assert.equal((await custom.list(""))[0].Size, 2049);
+    await custom.delete("a.bin");
   });
 });
-
-test("DELETE", async (_t) => {
-});
diff --git a/backend/chunker/rclone_test.js b/backend/chunker/rclone_test.js
new file mode 100644
index 0000000..c1d442d
--- /dev/null
+++ b/backend/chunker/rclone_test.js
@@ -0,0 +1,196 @@
+/**
+ * The tests of chunker against rclone, in the two directions, with the
+ * modes of rclone: the metadata `simplejson` or `none`, and the
+ * transactions `rename` or `norename`. The tests run when rclone is in the
+ * PATH, or when RCLONE is the path of rclone.
+ */
+import { after, before, describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import {
+  mkdirSync,
+  mkdtempSync,
+  readdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import process from "node:process";
+
+import { remote } from "../../lib/testing/remote.js";
+import chunker from "./main.js";
+
+const RCLONE = process.env.RCLONE || "rclone";
+const hasRclone = spawnSync(RCLONE, ["version"]).status === 0;
+
+/** The files: sizes at the ends of the chunks of 1 KiB, and hard names. */
+const FILES = {
+  "empty.bin": 0,
+  "one.bin": 1,
+  "a/1023.bin": 1023,
+  "a/1024.bin": 1024,
+  "a/b/1025.bin": 1025,
+  "file name #1.txt": 2048,
+  [`hello? sausage/êé/Hello, 世界/ " ' @ < > & ? + ≠/z.txt`]: 3000,
+};
+
+/** The modes, with their options. */
+const MODES = {
+  rename: { chunk_size: "1k" },
+  none: { chunk_size: "1k", meta_format: "none", hash_type: "none" },
+  norename: { chunk_size: "1k", transactions: "norename" },
+};
+
+/** @param {number} size */
+function content(size) {
+  return new Uint8Array(size).map((_, index) => (index * 13 + size) & 0xff);
+}
+
+/**
+ * The files in a folder and in its folders, with their paths.
+ * @param {string} folder
+ * @returns {string[]}
+ */
+function tree(folder) {
+  return readdirSync(folder, { recursive: true, withFileTypes: true })
+    .filter((entry) => entry.isFile())
+    .map((entry) =>
+      join(entry.parentPath ?? entry.path, entry.name).slice(folder.length + 1)
+    )
+    .sort();
+}
+
+describe("chunker and rclone", {
+  skip: !hasRclone && "rclone is not installed. Set RCLONE to its path.",
+}, () => {
+  const folder = mkdtempSync(join(tmpdir(), "rfetch-chunker-"));
+  const config = join(folder, "rclone.conf");
+
+  /** @param {string[]} args */
+  function rclone(...args) {
+    const { status, stdout, stderr } = spawnSync(
+      RCLONE,
+      ["--config", config, ...args],
+      { env: { PATH: process.env.PATH, HOME: folder } },
+    );
+    assert.equal(status, 0, `rclone ${args.join(" ")}: ${stderr}`);
+    return stdout;
+  }
+
+  before(() => {
+    // The local backend serves the current folder.
+    process.chdir(folder);
+    const sections = [];
+    for (const [mode, options] of Object.entries(MODES)) {
+      for (const side of ["by-rclone", "by-rfetch"]) {
+        const lines = Object.entries(options).map(([key, value]) =>
+          `${key} = ${value}`
+        );
+        sections.push(
+          `[${mode}-${side}]\ntype = chunker\n` +
+            `remote = ${join(folder, mode, side)}\n${lines.join("\n")}\n`,
+        );
+      }
+    }
+    writeFileSync(config, sections.join("\n"));
+    for (const [path, size] of Object.entries(FILES)) {
+      mkdirSync(dirname(join(folder, "plain", path)), { recursive: true });
+      writeFileSync(join(folder, "plain", path), content(size));
+    }
+  });
+  after(() => rmSync(folder, { recursive: true, force: true }));
+
+  for (const [mode, options] of Object.entries(MODES)) {
+    const rfetch = (side) =>
+      remote(chunker, { params: { remote: `${mode}/${side}`, ...options } });
+
+    test(`${mode}: rfetch reads what rclone writes`, async () => {
+      rclone("copy", join(folder, "plain"), `${mode}-by-rclone:`);
+      const fs = rfetch("by-rclone");
+      for (const [path, size] of Object.entries(FILES)) {
+        const response = await fs.get(path);
+        assert.equal(response.status, 200, path);
+        assert.equal(response.headers.get("Content-Length"), `${size}`, path);
+        assert.deepEqual(
+          new Uint8Array(await response.arrayBuffer()),
+          content(size),
+          path,
+        );
+      }
+
+      // The lists have the names and sizes of `rclone lsjson -R`.
+      const expected = JSON.parse(
+        rclone("lsjson", "-R", "--files-only", `${mode}-by-rclone:`),
+      )
+        .map(({ Path, Size }) => ({ Path, Size }));
+      const actual = [];
+      const walk = async (path) => {
+        for (const entry of await fs.list(path)) {
+          if (entry.IsDir) await walk(`${path}${entry.Name}/`);
+          else actual.push({ Path: `${path}${entry.Name}`, Size: entry.Size });
+        }
+      };
+      await walk("");
+      const sort = (entries) =>
+        entries.sort((a, b) => a.Path < b.Path ? -1 : +(a.Path > b.Path));
+      assert.deepEqual(sort(actual), sort(expected));
+    });
+
+    test(`${mode}: rclone reads what rfetch writes`, async () => {
+      const fs = rfetch("by-rfetch");
+      for (const [path, size] of Object.entries(FILES)) {
+        const response = await fs.put(path, content(size));
+        assert.equal(response.status, 201, path);
+      }
+      // rclone checks the files, with the hashes of the metadata.
+      rclone("check", join(folder, "plain"), `${mode}-by-rfetch:`);
+      rclone("copy", `${mode}-by-rfetch:`, join(folder, "out", mode));
+      for (const [path, size] of Object.entries(FILES)) {
+        assert.deepEqual(
+          new Uint8Array(readFileSync(join(folder, "out", mode, path))),
+          content(size),
+          path,
+        );
+      }
+    });
+
+    test(`${mode}: rclone and rfetch write the same files`, () => {
+      const byRclone = join(folder, mode, "by-rclone");
+      const byRfetch = join(folder, mode, "by-rfetch");
+      // A transaction has a random suffix of 6 characters.
+      const names = (side) =>
+        tree(side).map((name) => name.replace(/_[0-9a-z]{4,9}$/, "_XACT"));
+      assert.deepEqual(names(byRfetch), names(byRclone));
+      if (mode === "rename") {
+        // The same chunks and the same metadata, byte for byte.
+        for (const name of tree(byRclone)) {
+          assert.deepEqual(
+            readFileSync(join(byRfetch, name)),
+            readFileSync(join(byRclone, name)),
+            name,
+          );
+        }
+      }
+    });
+  }
+
+  test("rclone reads a file that rfetch writes with no Content-Length", async () => {
+    const fs = remote(chunker, {
+      params: { remote: "rename/by-rfetch", ...MODES.rename },
+    });
+    for (const size of [10, 3000]) {
+      const response = await fs.send(`stream-${size}.bin`, {
+        method: "PUT",
+        body: new Blob([content(size)]).stream(),
+        duplex: "half",
+      });
+      assert.equal(response.status, 201);
+      assert.deepEqual(
+        new Uint8Array(rclone("cat", `rename-by-rfetch:stream-${size}.bin`)),
+        content(size),
+      );
+    }
+  });
+});

From 29d123b4b00a0af5481bfae39aeff52c09ccd516 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sat, 17 Oct 2026 03:40:40 +0000
Subject: [PATCH 30/87] feat(lib): read the list options of rclone

parseList reads an option of the type CommaSepList or SpaceSepList of rclone. As in rclone, it reads one record with the CSV rules of Go: a value in quotes can have the separator, a line break, and "" for one quote.

A property test sends 5000 random texts to parseList and to encoding/csv of Go, and they must give the same values and the same errors. It runs when Go is installed.
---
 lib/list.js      |  84 +++++++++++++++++++++++++++++
 lib/list_test.js | 135 +++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 219 insertions(+)
 create mode 100644 lib/list.js
 create mode 100644 lib/list_test.js

diff --git a/lib/list.js b/lib/list.js
new file mode 100644
index 0000000..ea4cf07
--- /dev/null
+++ b/lib/list.js
@@ -0,0 +1,84 @@
+/**
+ * The list options of rclone, as `CommaSepList` and `SpaceSepList` of rclone
+ * (fs/config_list.go): one record of the CSV rules of the `encoding/csv`
+ * package of Go, with no comments and no lazy quotes.
+ */
+
+/**
+ * Reads the values of a list option.
+ *
+ * As in Go, a value in quotes can have the separator, a line break, and `""`
+ * for one quote. A value with no quotes cannot have a quote. Empty lines at
+ * the start are not a record, and the text after the first record is not a
+ * part of the list.
+ * @param {string} text For example `Cookie,"a=1, b=2"`.
+ * @param {string} [separator] `,` for `CommaSepList`, or ` ` for
+ *   `SpaceSepList`.
+ * @returns {string[]} For example `["Cookie", "a=1, b=2"]`, or `[]` for an
+ *   empty text.
+ * @throws {SyntaxError} When a quote is not correct.
+ */
+export function parseList(text, separator = ",") {
+  if (text === "") return [];
+
+  // As the reader of Go, "\r\n" at the end of a line is "\n", and the last
+  // line can end with no "\n".
+  const lines = text.split(/(?<=\n)/).map((line) =>
+    line.endsWith("\r\n") ? `${line.slice(0, -2)}\n` : line
+  );
+  if (lines.at(-1).endsWith("\r")) lines.push(lines.pop().slice(0, -1));
+
+  let index = 0;
+  while (index < lines.length && /^\n?$/.test(lines[index])) index++;
+  // As in rclone, a text of only empty lines is an error.
+  if (index === lines.length) throw new SyntaxError("EOF");
+
+  /** @type {string[]} */
+  const values = [];
+  let line = lines[index++];
+  for (;;) {
+    if (!line.startsWith('"')) {
+      // A value with no quotes.
+      const end = line.indexOf(separator);
+      const value = end === -1 ? line.replace(/\n$/, "") : line.slice(0, end);
+      if (value.includes('"')) {
+        throw new SyntaxError('bare " in non-quoted-field');
+      }
+      values.push(value);
+      if (end === -1) return values;
+      line = line.slice(end + separator.length);
+      continue;
+    }
+
+    // A value in quotes, on one line or more.
+    line = line.slice(1);
+    let value = "";
+    for (;;) {
+      const quote = line.indexOf('"');
+      if (quote === -1) {
+        value += line;
+        if (index === lines.length) {
+          throw new SyntaxError('extraneous or missing " in quoted-field');
+        }
+        line = lines[index++];
+        continue;
+      }
+      value += line.slice(0, quote);
+      line = line.slice(quote + 1);
+      if (line.startsWith('"')) {
+        // `""` is one quote.
+        value += '"';
+        line = line.slice(1);
+      } else if (line.startsWith(separator)) {
+        values.push(value);
+        line = line.slice(separator.length);
+        break;
+      } else if (line === "" || line === "\n") {
+        values.push(value);
+        return values;
+      } else {
+        throw new SyntaxError('extraneous or missing " in quoted-field');
+      }
+    }
+  }
+}
diff --git a/lib/list_test.js b/lib/list_test.js
new file mode 100644
index 0000000..d23c55d
--- /dev/null
+++ b/lib/list_test.js
@@ -0,0 +1,135 @@
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import process from "node:process";
+import fc from "fast-check";
+
+import { parseList } from "./list.js";
+
+test("parseList reads the values of a list", () => {
+  for (
+    const [text, values] of [
+      ["", []],
+      ["a", ["a"]],
+      ["a,b", ["a", "b"]],
+      ["a,", ["a", ""]],
+      [",", ["", ""]],
+      [" a , b ", [" a ", " b "]],
+      ['"a,b",c', ["a,b", "c"]],
+      ['"a ""b"" c"', ['a "b" c']],
+      ['""', [""]],
+      ['"a\nb",c', ["a\nb", "c"]],
+      ['"a\r\nb"', ["a\nb"]],
+      ["a,b\nc,d", ["a", "b"]],
+      ["\n\na,b", ["a", "b"]],
+      ["a\r\n", ["a"]],
+      ["a\r", ["a"]],
+      ["a\rb", ["a\rb"]],
+      ['Cookie,"a=1, b=2"', ["Cookie", "a=1, b=2"]],
+    ]
+  ) {
+    assert.deepEqual(parseList(text), values, JSON.stringify(text));
+  }
+  assert.deepEqual(parseList('a "b c" d', " "), ["a", "b c", "d"]);
+  for (const text of ['a"b', 'a,b"', '"a"b', '"a', "\n", "\r", '"a\n']) {
+    assert.throws(() => parseList(text), SyntaxError, JSON.stringify(text));
+  }
+});
+
+const GO = process.env.GO || "go";
+const hasGo = spawnSync(GO, ["version"]).status === 0;
+
+/** The code of `genericList.set` of rclone, for each text of the input. */
+const PROGRAM = `package main
+
+import (
+	"bytes"
+	"encoding/csv"
+	"encoding/json"
+	"os"
+)
+
+type input struct {
+	Text      string
+	Separator rune
+}
+
+type output struct {
+	Values []string
+	Error  bool
+}
+
+func set(sep rune, b []byte) ([]string, error) {
+	if len(b) == 0 {
+		return []string{}, nil
+	}
+	r := csv.NewReader(bytes.NewReader(b))
+	r.Comma = sep
+	return r.Read()
+}
+
+func main() {
+	var inputs []input
+	if err := json.NewDecoder(os.Stdin).Decode(&inputs); err != nil {
+		panic(err)
+	}
+	outputs := make([]output, len(inputs))
+	for i, in := range inputs {
+		values, err := set(in.Separator, []byte(in.Text))
+		outputs[i] = output{Values: values, Error: err != nil}
+	}
+	json.NewEncoder(os.Stdout).Encode(outputs)
+}
+`;
+
+describe("parseList and encoding/csv of Go", {
+  skip: !hasGo && "Go is not installed. Set GO to its path.",
+}, () => {
+  test("give the same values and the same errors", () => {
+    const inputs = fc.sample(
+      fc.record({
+        Text: fc.stringOf(
+          fc.constantFrom("a", "b", " ", ",", '"', "\n", "\r", "é"),
+          { maxLength: 12 },
+        ),
+        Separator: fc.constantFrom(",", " "),
+      }),
+      { numRuns: 5000, seed: 42 },
+    );
+
+    const folder = mkdtempSync(join(tmpdir(), "rfetch-list-"));
+    try {
+      writeFileSync(join(folder, "main.go"), PROGRAM);
+      const { status, stdout, stderr } = spawnSync(
+        GO,
+        ["run", join(folder, "main.go")],
+        {
+          input: JSON.stringify(
+            inputs.map(({ Text, Separator }) => ({
+              Text,
+              Separator: Separator.codePointAt(0),
+            })),
+          ),
+        },
+      );
+      assert.equal(status, 0, `${stderr}`);
+      const outputs = JSON.parse(stdout);
+      for (const [index, { Text, Separator }] of inputs.entries()) {
+        const { Values, Error } = outputs[index];
+        const what = `${JSON.stringify(Text)} with ${
+          JSON.stringify(Separator)
+        }`;
+        if (Error) {
+          assert.throws(() => parseList(Text, Separator), SyntaxError, what);
+        } else {
+          assert.deepEqual(parseList(Text, Separator), Values, what);
+        }
+      }
+    } finally {
+      rmSync(folder, { recursive: true, force: true });
+    }
+  });
+});

From 228e67288b42651d671838408bca41fea0be690d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sat, 17 Oct 2026 03:40:40 +0000
Subject: [PATCH 31/87] fix(http): the http backend of rclone, on the shared
 test suite

The http backend now:

- reads each link to a file or a folder directly in the folder, one time, as rclone. The rows of a table of rfetch also give the size, the type and the time;
- sends a HEAD request for each file with no size, at most 8 at the same time, as rclone. A file whose HEAD request fails is not in the list. With no_head=true, it sends no HEAD request;
- gives Content-Type, Content-Length and Last-Modified for a file, and no other header of the server;
- reads the headers option as rclone, with quotes, and gives 400 for an odd number of values;
- puts no headers option in the links of a list, because it can have a password;
- with the headers option, refuses a redirect from HTTPS to HTTP, and does not send the headers to a different host, as rclone;
- gives 400 for an url option that is not an http or https URL, and 405 for a method other than GET and HEAD;
- gives 502 when the server does not answer, or when the page of a folder is not HTML;
- asks the server for no content encoding, thus Content-Length is the size of the body.

The options method and no-slash are removed.

The tests run the shared suite: the memory backend writes the files, and the http backend reads them through a server. With rclone, the tests check that rclone lsjson and rfetch give the same files, for the lists of rfetch and for an index page of Apache.
---
 backend/http/main.js        | 576 ++++++++++++++++++++++++------------
 backend/http/main_test.js   | 327 ++++++++++++++++++--
 backend/http/rclone_test.js | 163 ++++++++++
 lib/testing/server.js       |  55 ++++
 4 files changed, 910 insertions(+), 211 deletions(-)
 create mode 100644 backend/http/rclone_test.js
 create mode 100644 lib/testing/server.js

diff --git a/backend/http/main.js b/backend/http/main.js
index cd7d4b9..2f24604 100644
--- a/backend/http/main.js
+++ b/backend/http/main.js
@@ -1,220 +1,416 @@
 /**
- * The HTTP remote is a read only remote for reading files of a webserver. The
- * webserver should provide file listings which rfetch will read and turn into
- * a remote.
+ * HTTP Backend
  *
- * Paths are specified as `remote:` or `remote:path`.
+ * The http backend reads the files of a web server, as the http backend of
+ * rclone. It is read only: a request other than GET or HEAD gets 405.
  *
- * The `remote:` represents the configured url, and any path following it will
- * be resolved relative to this url, according to the URL standard. This means
- * with remote url `https://beta.rfetch.com/branch` and path `fix`, the
- * resolved URL will be `https://beta.rfetch.com/branch/fix`, while with path
- * `/fix` the resolved URL will be `https://beta.rfetch.com/fix` as the
- * absolute path is resolved from the root of the domain.
+ * The options:
  *
- * If the path following the `remote:` ends with `/` it will be assumed to
- * point to a directory. If the path does not end with `/`, then a HEAD request
- * is sent and the response used to decide if it it is treated as a file or a
- * directory (run with `-vv` to see details). When --http-no-head is specified,
- * a path without ending `/` is always assumed to be a file. If rfetch
- * incorrectly assumes the path is a file, the solution is to specify the path
- * with ending `/`. When you know the path is a directory, ending it with `/`
- * is always better as it avoids the initial HEAD request.
+ * - `url`: the URL of the root folder on the server. The path of a request
+ *   goes after this URL. Thus with the URL `https://example.com/files` and
+ *   the path `/a b/c.txt`, the file is at
+ *   `https://example.com/files/a%20b/c.txt`.
+ * - `headers`: the HTTP headers for each request to the server, as a list of
+ *   names and values with commas, for example `Cookie,name=value`. The links
+ *   of a list do not have this option, because it can have a password.
+ * - `no_head`: when it is `true`, the list of a folder does not send a HEAD
+ *   request for each file. Thus the list does not have the size and the time
+ *   of a file that the index page does not give.
  *
- * To just download a single file it is easier to use [copyurl](../../cmd/copyurl/main.js).
+ * A path that ends with `/` is a folder. The list of a folder comes from its
+ * index page on the server: each link to a file or a folder directly in the
+ * folder. The query and the fragment of a link are not a part of the name.
+ *
+ * To get only one file, use [copyurl](../../cmd/copyurl/main.js).
  */
 
 import { HTMLRewriter } from "@sntran/html-rewriter";
-import { formatBytes } from "../../lib/format.js";
-import { toLocaleISOString } from "../../lib/time.js";
+import { parseList } from "../../lib/list.js";
+import { childOf, renderListing } from "../../lib/listing.js";
+import { mimeType } from "../../lib/mime.js";
+import { decodePath, encodePath } from "../../lib/path.js";
 
 export const options = {
   boolean: [
-    "no-head",
-    "no-slash",
+    "no_head",
   ],
   string: [
     "url",
-    "method",
+    "headers",
   ],
   default: {
-    "no-head": false,
-    "no-slash": false,
+    no_head: false,
   },
 };
 
+/** The options that are secret, as `headers` can have a password. */
+const SECRETS = ["headers"];
+
+/** The headers of a file that go to the client. */
+const FILE_HEADERS = ["Content-Type", "Content-Length", "Last-Modified"];
+
+/** The status codes of a redirect. */
+const REDIRECTS = [301, 302, 303, 307, 308];
+
+/** The maximum number of redirects, as the HTTP client of Go. */
+const MAX_REDIRECTS = 10;
+
+/** The number of HEAD requests at the same time, as `--checkers` of rclone. */
+const CHECKERS = 8;
+
+/** An error that has the status of the response. */
+class HTTPError extends Error {
+  /** @param {string} message @param {number} status */
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+  }
+}
+
 /**
- * Serves a HTTP remote.
+ * Serves a HTTP remote. It is read only, as the http backend of rclone.
  * @param {Request} request
  * @returns {Promise<Response>}
  */
 async function http(request) {
-  const { url, body } = request;
-  const { pathname, searchParams } = new URL(url);
-
-  const remote = searchParams.get("url");
-  if (!remote) {
-    return new Response("Missing URL", { status: 400 });
-  }
-  const method = searchParams.get("method") || request.method;
-
-  const headers = (searchParams.get("headers") || "").split(",").reduce(
-    (headers, header) => {
-      if (!header) return headers;
-      const [key, value] = header.split(",", 2);
-      headers.set(key, value);
-      return headers;
-    },
-    new Headers(),
-  );
-
-  /**
-   * @type {RequestInit}
-   */
+  const { method } = request;
+  const { pathname, searchParams } = new URL(request.url);
+
+  let base;
+  try {
+    base = new URL(searchParams.get("url") ?? "");
+  } catch {
+    return new Response("The url option is not a URL", { status: 400 });
+  }
+  if (base.protocol !== "http:" && base.protocol !== "https:") {
+    return new Response("The url option must be an http or https URL", {
+      status: 400,
+    });
+  }
+  // A path resolves relative to the URL of the remote, as a folder.
+  if (!base.pathname.endsWith("/")) base.pathname += "/";
+
+  const path = decodePath(pathname);
+  if (path === null) {
+    return new Response(null, { status: 400 });
+  }
+  if (method !== "GET" && method !== "HEAD") {
+    return new Response(null, { status: 405, headers: { Allow: "GET, HEAD" } });
+  }
+
+  let headers;
+  try {
+    headers = parseHeaders(searchParams.get("headers") ?? "");
+  } catch (error) {
+    return new Response(`The headers option is not correct: ${error.message}`, {
+      status: 400,
+    });
+  }
+
+  const target = new URL(encodePath(path).slice(1), base);
+  try {
+    if (!path.endsWith("/")) {
+      return await getFile(target, method, headers, path);
+    }
+    const noHead = searchParams.get("no_head") === "true";
+    const query = new URLSearchParams(searchParams);
+    for (const name of SECRETS) query.delete(name);
+    return await getFolder(target, method, headers, noHead, `${query}`);
+  } catch (error) {
+    if (error instanceof HTTPError) {
+      return new Response(error.message, { status: error.status });
+    }
+    throw error;
+  }
+}
+
+/**
+ * Reads the headers option of rclone: a list of names and values, for
+ * example `Cookie,name=value,Authorization,"Basic a2V5"`.
+ * @param {string} text
+ * @returns {Headers}
+ * @throws {SyntaxError | TypeError} When the list is not correct, or when a
+ *   name or a value is not correct for HTTP.
+ */
+function parseHeaders(text) {
+  const list = parseList(text);
+  if (list.length % 2 !== 0) {
+    throw new SyntaxError("odd number of headers supplied");
+  }
+  const headers = new Headers();
+  for (let index = 0; index < list.length; index += 2) {
+    headers.append(list[index], list[index + 1]);
+  }
+  return headers;
+}
+
+/**
+ * Gets a file, or only its headers for HEAD.
+ * @param {URL} url
+ * @param {string} method
+ * @param {Headers} headers
+ * @param {string} path
+ * @returns {Promise<Response>}
+ */
+async function getFile(url, method, headers, path) {
+  const response = await send(url, method, headers);
+  if (!response.ok) {
+    await response.body?.cancel();
+    return new Response(null, { status: response.status });
+  }
+
+  const result = new Headers();
+  for (const name of FILE_HEADERS) {
+    const value = response.headers.get(name);
+    if (value) result.set(name, value);
+  }
+  if (!result.has("Content-Type")) result.set("Content-Type", mimeType(path));
+  // The body of fetch has no content encoding, thus it has an other size.
+  if (isEncoded(response)) result.delete("Content-Length");
+
+  if (method === "HEAD") {
+    await response.body?.cancel();
+    return new Response(null, { headers: result });
+  }
+  return new Response(response.body, { headers: result });
+}
+
+/**
+ * Gets the list of a folder, from the index page of the server, or only the
+ * headers for HEAD.
+ * @param {URL} url
+ * @param {string} method
+ * @param {Headers} headers
+ * @param {boolean} noHead When it is false, a HEAD request gives the size,
+ *   the time and the type of each file that the index page does not give.
+ * @param {string} query The query for each link, with no secret.
+ * @returns {Promise<Response>}
+ */
+async function getFolder(url, method, headers, noHead, query) {
+  const response = await send(url, "GET", headers);
+  if (!response.ok) {
+    await response.body?.cancel();
+    return new Response(null, { status: response.status });
+  }
+  // As in rclone, only an HTML page can be the list of a folder.
+  const type = response.headers.get("Content-Type") ?? "";
+  if (type.split(";")[0].trim().toLowerCase() !== "text/html") {
+    await response.body?.cancel();
+    return new Response("The index page of the folder is not HTML", {
+      status: 502,
+    });
+  }
+
+  const result = { "Content-Type": "text/html;charset=utf-8" };
+  if (method === "HEAD") {
+    await response.body?.cancel();
+    return new Response(null, { headers: result });
+  }
+
+  let entries = await readIndex(response, url);
+  if (!noHead) entries = await head(entries, url, headers);
+  for (const entry of entries) {
+    if (!entry.IsDir) entry.MimeType ||= mimeType(entry.Name);
+  }
+  return new Response(renderListing(entries, { query }), { headers: result });
+}
+
+/**
+ * Reads the files and the folders of an index page, as `parse` of the http
+ * backend of rclone: each link to a child of the folder, one time. The rows
+ * of a table of rfetch also give the size and the time.
+ * @param {Response} response
+ * @param {URL} base The URL of the folder.
+ * @returns {Promise<import("../../lib/listing.js").Entry[]>}
+ */
+async function readIndex(response, base) {
+  /** @type {import("../../lib/listing.js").Entry[]} */
+  const entries = [];
+  const seen = new Set();
+  let inRow = false;
+  /** @type {import("../../lib/listing.js").Entry | null} */
+  let current = null;
+
+  await new HTMLRewriter()
+    .on("tr", {
+      element(element) {
+        inRow = true;
+        current = null;
+        element.onEndTag(() => {
+          inRow = false;
+          current = null;
+        });
+      },
+    })
+    .on("a[href]", {
+      element(element) {
+        const name = childOf(element.getAttribute("href"), base);
+        if (name === null || seen.has(name)) return;
+        seen.add(name);
+        const isDir = name.endsWith("/");
+        const entry = {
+          Name: isDir ? name.slice(0, -1) : name,
+          IsDir: isDir,
+          Size: -1,
+          MimeType: isDir ? "" : element.getAttribute("type") || "",
+          ModTime: "",
+        };
+        entries.push(entry);
+        if (inRow) current = entry;
+      },
+    })
+    .on("tr data[value]", {
+      element(element) {
+        const value = element.getAttribute("value");
+        if (current && /^\d+$/.test(value)) current.Size = Number(value);
+      },
+    })
+    .on("tr time[datetime]", {
+      element(element) {
+        const time = Date.parse(element.getAttribute("datetime"));
+        if (current && !isNaN(time)) {
+          current.ModTime = new Date(time).toISOString();
+        }
+      },
+    })
+    .transform(response)
+    .arrayBuffer();
+
+  return entries;
+}
+
+/**
+ * Sends a HEAD request for each file with no size, as rclone does for each
+ * file of a list. As in rclone, a file is not in the list when its HEAD
+ * request fails.
+ * @param {import("../../lib/listing.js").Entry[]} entries
+ * @param {URL} base The URL of the folder.
+ * @param {Headers} headers
+ * @returns {Promise<import("../../lib/listing.js").Entry[]>}
+ */
+async function head(entries, base, headers) {
+  const files = entries.filter((entry) => !entry.IsDir && entry.Size < 0);
+  const failed = new Set();
+  const next = async () => {
+    for (let entry = files.shift(); entry; entry = files.shift()) {
+      const url = new URL(encodeURIComponent(entry.Name), base);
+      let response;
+      try {
+        response = await send(url, "HEAD", headers);
+      } catch {
+        failed.add(entry);
+        continue;
+      }
+      await response.body?.cancel();
+      if (!response.ok) {
+        failed.add(entry);
+        continue;
+      }
+      entry.Size = isEncoded(response) ? -1 : sizeOf(response.headers);
+      const time = Date.parse(response.headers.get("Last-Modified") ?? "");
+      if (!isNaN(time)) entry.ModTime = new Date(time).toISOString();
+      entry.MimeType = response.headers.get("Content-Type") ?? "";
+    }
+  };
+  await Promise.all(Array.from({ length: CHECKERS }, next));
+  return entries.filter((entry) => !failed.has(entry));
+}
+
+/**
+ * The size of a file from the headers of a response, as
+ * `ParseSizeFromHeaders` of rclone: `Content-Length`, or the size at the end
+ * of `Content-Range`, or -1.
+ * @param {Headers} headers
+ * @returns {number}
+ */
+function sizeOf(headers) {
+  const range = headers.get("Content-Range");
+  if (range !== null) {
+    const match = range.match(/^bytes [^/]*\/(\d+)$/);
+    return match ? Number(match[1]) : -1;
+  }
+  const length = headers.get("Content-Length") ?? "";
+  return /^\d+$/.test(length) ? Number(length) : -1;
+}
+
+/**
+ * Tells if the body of a response has a content encoding, for example gzip.
+ * @param {Response} response
+ */
+function isEncoded(response) {
+  const encoding = response.headers.get("Content-Encoding");
+  return encoding !== null && encoding.toLowerCase() !== "identity";
+}
+
+/**
+ * Sends a request to the server, with the headers of the headers option.
+ *
+ * As in rclone, when there are such headers, a redirect from HTTPS to HTTP is
+ * an error, and the headers do not go to a server on a different host. After
+ * a redirect to a different host, the headers do not go to the next redirects
+ * too, as that host chose them.
+ * @param {URL} url
+ * @param {string} method GET or HEAD.
+ * @param {Headers} headers
+ * @returns {Promise<Response>}
+ * @throws {HTTPError} When the server does not answer, or when a redirect is
+ *   not permitted.
+ */
+async function send(url, method, headers) {
+  const names = [...headers.keys()];
   const init = {
-    method: searchParams.get("method") || method,
-    headers,
-    body,
+    method,
+    headers: new Headers(headers),
+    redirect: names.length > 0 ? "manual" : "follow",
   };
+  // The size of the file is the size of the body that the client gets.
+  if (!init.headers.has("Accept-Encoding")) {
+    init.headers.set("Accept-Encoding", "identity");
+  }
 
-  const response = await fetch(`${remote}${pathname}`, init);
-
-  if (!pathname.endsWith("/")) {
-    return response;
-  }
-
-  const listing = new ReadableStream({
-    start(controller) {
-      controller.enqueue(`
-        <table cellpadding="4">
-        <thead>
-          <tr>
-            <th></th>
-            <th>Name</th>
-            <th>Size</th>
-            <th>Modified</th>
-          </tr>
-        </thead>
-        <tbody>
-          <tr>
-            <td>📁</td>
-            <td><a href="../?${searchParams}">Go up</a></td>
-            <td>—</td>
-            <td>—</td>
-          </tr>
-      `);
-
-      /**
-       * @type {import("../../mod.js").File}
-       */
-      let item;
-
-      const rewriter = new HTMLRewriter();
-      rewriter.on(`tbody tr`, {
-        element(element) {
-          // Start a new item.
-          item = {
-            Path: "",
-            Name: "",
-            Size: 0,
-            MimeType: "",
-            ModTime: "",
-            IsDir: true,
-          };
-
-          element.onEndTag(() => {
-            if (!item) return;
-
-            let lastModified;
-            if (item.ModTime) {
-              lastModified = new Date(item.ModTime);
-            }
-            controller.enqueue(`<tr>
-              <td>${item.IsDir ? "📁" : "📄"}</td>
-              <td>
-                <a
-                  href="${item.Path}?${searchParams}"
-                >${item.Name}</a>
-              <td>
-                ${
-              item.Size
-                ? `<data
-                      value="${item.Size}"
-                    >${formatBytes(item.Size, { locale: true })}</data>`
-                : "—"
-            }
-              </td>
-              <td>
-                ${
-              lastModified
-                ? `<time
-                      datetime="${lastModified.toISOString()}"
-                    >${lastModified.toLocaleString()}</time>`
-                : "-"
-            }
-              </td>
-            </tr>`);
-          });
-        },
-      });
-
-      rewriter.on(`tbody tr a[href]`, {
-        element(element) {
-          const href = element.getAttribute("href");
-          if (href === "..") {
-            item = null;
-            return;
-          }
-
-          item.Path = href;
-          item.IsDir = href.endsWith("/");
-        },
-        text(chunk) {
-          if (!item) return;
-          item.Name += chunk.text;
-          if (chunk.lastInTextNode) {
-            item.Name = item.Name.trim();
-          }
-        },
-      });
-
-      rewriter.on(`tbody tr data[value], tr td[data-size]`, {
-        element(element) {
-          let size = element.getAttribute("value");
-          if (!size) {
-            size = element.getAttribute("data-size");
-          }
-          item.Size = Number(size);
-        },
-      });
-
-      rewriter.on(`tbody tr time[datetime]`, {
-        element(element) {
-          const value = element.getAttribute("datetime");
-          if (value) {
-            item.ModTime = toLocaleISOString(value);
-          }
-        },
-      });
-
-      rewriter.on(`tbody`, {
-        element(element) {
-          element.onEndTag(() => {
-            controller.enqueue("</tbody></table>");
-            controller.close();
-          });
-        },
-      });
-
-      rewriter.transform(response).body.pipeTo(new WritableStream());
-    },
-  }).pipeThrough(new TextEncoderStream());
-
-  return new Response(listing, {
-    headers: {
-      "Content-Type": "text/html;charset=utf-8",
-    },
-  });
+  const first = url;
+  for (let redirects = 0;; redirects++) {
+    let response;
+    try {
+      response = await fetch(url, init);
+    } catch {
+      throw new HTTPError("The server did not answer", 502);
+    }
+    const location = response.headers.get("Location");
+    if (
+      init.redirect === "follow" || !REDIRECTS.includes(response.status) ||
+      location === null
+    ) {
+      return response;
+    }
+    await response.body?.cancel();
+
+    if (redirects === MAX_REDIRECTS) {
+      throw new HTTPError(`stopped after ${MAX_REDIRECTS} redirects`, 502);
+    }
+    const next = new URL(location, url);
+    if (first.protocol === "https:" && next.protocol === "http:") {
+      throw new HTTPError(
+        "A redirect from HTTPS to HTTP is not permitted with the headers option",
+        502,
+      );
+    }
+    if (!sameHost(next, first)) {
+      for (const name of names) init.headers.delete(name);
+    }
+    url = next;
+  }
+}
+
+/**
+ * Tells if two URLs have the same host and port, as `SameHost` of rclone.
+ * @param {URL} a
+ * @param {URL} b
+ */
+function sameHost(a, b) {
+  const port = (url) =>
+    url.port || { "http:": "80", "https:": "443" }[url.protocol];
+  return a.hostname === b.hostname && port(a) === port(b);
 }
 
 export default {
diff --git a/backend/http/main_test.js b/backend/http/main_test.js
index 13f09cd..38a3eca 100644
--- a/backend/http/main_test.js
+++ b/backend/http/main_test.js
@@ -1,35 +1,320 @@
-import { test } from "node:test";
+import { after, describe, test } from "node:test";
 import assert from "node:assert/strict";
+import { gzipSync } from "node:zlib";
+
+import { mimeType } from "../../lib/mime.js";
+import { backendSuite } from "../../lib/testing/suite.js";
+import { remote } from "../../lib/testing/remote.js";
+import { listen } from "../../lib/testing/server.js";
+import memory from "../memory/main.js";
 import backend from "./main.js";
 
-test("GET", async (t) => {
-  await t.test("error without url searchParam", async () => {
-    const url = new URL("/", "file:");
-    const response = await backend.fetch(new Request(url));
-    assert.deepEqual(response.status, 400);
+/** A server of the memory backend, with the headers of each request. */
+const requests = [];
+const server = await listen((request) => {
+  requests.push(request);
+  return memory.fetch(request);
+});
+after(() => server.close());
+
+// The suite writes to the memory backend, and reads through the server.
+backendSuite("http", backend, {
+  params: { url: `${server.url}` },
+  writer: memory,
+});
+
+/** @param {string} text */
+const bytes = (text) => new TextEncoder().encode(text);
+
+describe("http", () => {
+  const fs = remote(backend, { params: { url: `${server.url}http-test` } });
+  const files = remote(memory, { root: "/http-test/" });
+
+  test("gives 400 for an url option that is not an http URL", async () => {
+    for (const url of [undefined, "", "a/b", "file:///etc/", "ftp://a/"]) {
+      const params = url === undefined ? {} : { url };
+      const response = await remote(backend, { params }).get("");
+      await response.body?.cancel();
+      assert.equal(response.status, 400, `${url}`);
+    }
+  });
+
+  test("is read only", async () => {
+    await files.put("a.txt", bytes("a"));
+    for (const method of ["PUT", "DELETE", "POST", "PROPFIND"]) {
+      const response = await fs.send("a.txt", { method });
+      assert.equal(response.status, 405, method);
+      assert.equal(response.headers.get("Allow"), "GET, HEAD");
+    }
+    assert.equal(await (await files.get("a.txt")).text(), "a");
+  });
+
+  test("resolves a path relative to the url option", async () => {
+    await files.put("a b/c?.txt", bytes("c"));
+    for (const url of [`${server.url}http-test`, `${server.url}http-test/`]) {
+      const response = await remote(backend, { params: { url } })
+        .get("a b/c?.txt");
+      assert.equal(await response.text(), "c", url);
+    }
+  });
+
+  test("sends the headers option to the server", async () => {
+    const headers = 'Cookie,"a=1, b=2",X-Key,secret';
+    const fs = remote(backend, {
+      params: { url: `${server.url}http-test`, headers },
+    });
+    requests.length = 0;
+    await (await fs.get("a.txt")).text();
+    const html = await (await fs.get("")).text();
+
+    assert.ok(requests.length >= 2);
+    for (const request of requests) {
+      assert.equal(request.headers.get("Cookie"), "a=1, b=2");
+      assert.equal(request.headers.get("X-Key"), "secret");
+    }
+    // The links of the list do not have the headers option.
+    assert.ok(html.includes(' href="a.txt?url='));
+    assert.ok(!html.includes("secret"));
+  });
+
+  test("gives 400 for a headers option that is not correct", async () => {
+    for (const headers of ["Cookie", "a,b,c", 'X-Key,"a', "Bad Name,a"]) {
+      const fs = remote(backend, {
+        params: { url: `${server.url}http-test`, headers },
+      });
+      const response = await fs.get("a.txt");
+      await response.body?.cancel();
+      assert.equal(response.status, 400, headers);
+    }
   });
 
-  await t.test("a file", async () => {
-    const remote = new URL("./", import.meta.url);
+  test("gives 404 for a file or a folder that is not on the server", async () => {
+    for (const path of ["missing.txt", "missing/"]) {
+      const response = await fs.get(path);
+      await response.body?.cancel();
+      assert.equal(response.status, 404, path);
+    }
+  });
 
-    const url = new URL("/main.js", "file:");
-    url.searchParams.set("url", remote.href);
+  test("gives 502 when the server does not answer", async () => {
+    const closed = await listen(() => new Response());
+    await closed.close();
+    const response = await remote(backend, { params: { url: `${closed.url}` } })
+      .get("a.txt");
+    await response.body?.cancel();
+    assert.equal(response.status, 502);
+  });
 
-    // Fetch the remote file directly
-    let response = await fetch(`${remote}/main.js`);
-    const expected = await response.text();
+  test("gives 502 for a folder that is not an HTML page", async () => {
+    const json = await listen(() => Response.json([]));
+    try {
+      const response = await remote(backend, { params: { url: `${json.url}` } })
+        .get("");
+      await response.body?.cancel();
+      assert.equal(response.status, 502);
+    } finally {
+      await json.close();
+    }
+  });
 
-    // Then compares with result from the backend
-    response = await backend.fetch(new Request(url));
-    const actual = await response.text();
+  test("gives the body of an encoded file with no Content-Length", async () => {
+    const gzip = await listen(() =>
+      new Response(gzipSync("hello"), {
+        headers: { "Content-Encoding": "gzip", "Content-Type": "text/plain" },
+      })
+    );
+    try {
+      const response = await remote(backend, { params: { url: `${gzip.url}` } })
+        .get("a.txt");
+      assert.equal(response.headers.get("Content-Length"), null);
+      assert.equal(await response.text(), "hello");
+    } finally {
+      await gzip.close();
+    }
+  });
+});
+
+describe("http with an index page that is not of rfetch", () => {
+  /** The files of the server, and an index page as Apache makes it. */
+  const FILES = {
+    "/files/a.txt": "a",
+    "/files/b c.json": "{}",
+    "/files/d.bin": "ddd",
+  };
+  const INDEX = `<!DOCTYPE html>
+<html><body><h1>Index of /files</h1><pre>
+<a href="?C=N;O=D">Name</a> <a href="?C=S;O=A">Size</a>
+<a href="/">Parent Directory</a>
+<a href="a.txt">a.txt</a>      17-Oct-2026 10:00    1
+<a href="./b%20c.json">b c.json</a> 17-Oct-2026 10:00    2
+<a href="http://127.0.0.1:1/files/x.txt">x.txt</a>
+<a href="/files/d.bin">d.bin</a>   17-Oct-2026 10:00    3
+<a href="d.bin">d.bin again</a>
+<a href="lost.txt">lost.txt</a>
+<a href="sub/">sub/</a>
+<a href="sub/deep.txt">sub/deep.txt</a>
+<a href="#top">top</a>
+</pre></body></html>`;
+  const LAST_MODIFIED = "Sat, 17 Oct 2026 10:00:00 GMT";
+
+  const requests = [];
+  let index;
+  let fs;
+
+  test("starts the server", async () => {
+    index = await listen((request) => {
+      const pathname = decodeURIComponent(new URL(request.url).pathname);
+      requests.push(`${request.method} ${pathname}`);
+      if (pathname === "/files/") {
+        return new Response(INDEX, {
+          headers: { "Content-Type": "text/html; charset=utf-8" },
+        });
+      }
+      if (pathname in FILES) {
+        // Bytes, thus the server sends no Content-Type.
+        const body = bytes(FILES[pathname]);
+        return new Response(request.method === "HEAD" ? null : body, {
+          headers: {
+            "Content-Length": `${body.length}`,
+            "Last-Modified": LAST_MODIFIED,
+          },
+        });
+      }
+      return new Response(null, { status: 404 });
+    });
+    fs = remote(backend, { params: { url: `${index.url}files/` } });
+  });
+  after(() => index?.close());
+
+  test("lists each link to a child of the folder one time", async () => {
+    const entries = await fs.list("");
+    const time = new Date(LAST_MODIFIED).toISOString();
     assert.deepEqual(
-      actual,
-      expected,
-      "should be the same as fetching the remote file directly",
+      entries.map(({ Name, IsDir, Size, ModTime }) => ({
+        Name,
+        IsDir,
+        Size,
+        ModTime,
+      })),
+      [
+        { Name: "a.txt", IsDir: false, Size: 1, ModTime: time },
+        { Name: "b c.json", IsDir: false, Size: 2, ModTime: time },
+        { Name: "d.bin", IsDir: false, Size: 3, ModTime: time },
+        // A file whose HEAD request fails is not in the list, as in rclone.
+        { Name: "sub", IsDir: true, Size: -1, ModTime: "" },
+      ],
     );
+    assert.equal(entries[1].MimeType, "application/json");
+  });
+
+  test("sends no HEAD request with no_head", async () => {
+    const fs = remote(backend, {
+      params: { url: `${index.url}files/`, no_head: "true" },
+    });
+    requests.length = 0;
+    const entries = await fs.list("");
+    assert.deepEqual(requests, ["GET /files/"]);
+    assert.deepEqual(
+      entries.map(({ Name, Size, MimeType }) => ({ Name, Size, MimeType })),
+      [
+        { Name: "a.txt", Size: -1, MimeType: mimeType("a.txt") },
+        { Name: "b c.json", Size: -1, MimeType: "application/json" },
+        { Name: "d.bin", Size: -1, MimeType: "application/octet-stream" },
+        { Name: "lost.txt", Size: -1, MimeType: mimeType("lost.txt") },
+        { Name: "sub", Size: -1, MimeType: "" },
+      ],
+    );
+  });
+
+  test("gets a file with the headers of the server", async () => {
+    const response = await fs.get("b c.json");
+    assert.equal(response.headers.get("Content-Length"), "2");
+    assert.equal(response.headers.get("Last-Modified"), LAST_MODIFIED);
+    assert.equal(response.headers.get("Content-Type"), "application/json");
+    assert.equal(await response.text(), "{}");
+  });
+});
+
+describe("http redirects with the headers option", () => {
+  test("do not send the headers to a different host", async () => {
+    /** The Cookie of each request, by the port of its server. */
+    const cookies = [];
+    const other = await listen((request) => {
+      cookies.push(["other", request.headers.get("Cookie")]);
+      // Back to the first server.
+      return Response.redirect(`${first.url}end.txt`, 302);
+    });
+    const first = await listen((request) => {
+      const { pathname } = new URL(request.url);
+      cookies.push([pathname, request.headers.get("Cookie")]);
+      if (pathname === "/same.txt") {
+        return Response.redirect(`${first.url}end.txt`, 301);
+      }
+      if (pathname === "/away.txt") {
+        return Response.redirect(`${other.url}x.txt`, 307);
+      }
+      return new Response("end");
+    });
+    try {
+      const fs = remote(backend, {
+        params: { url: `${first.url}`, headers: "Cookie,secret" },
+      });
+      assert.equal(await (await fs.get("same.txt")).text(), "end");
+      assert.deepEqual(cookies, [
+        ["/same.txt", "secret"],
+        ["/end.txt", "secret"],
+      ]);
+
+      cookies.length = 0;
+      assert.equal(await (await fs.get("away.txt")).text(), "end");
+      assert.deepEqual(cookies, [
+        ["/away.txt", "secret"],
+        ["other", null],
+        // The other host chose this URL, thus it gets no headers too.
+        ["/end.txt", null],
+      ]);
+    } finally {
+      await first.close();
+      await other.close();
+    }
+  });
+
+  test("stop at a redirect from HTTPS to HTTP", async (t) => {
+    const urls = [];
+    t.mock.method(globalThis, "fetch", (url) => {
+      urls.push(`${url}`);
+      return Promise.resolve(
+        new Response(null, {
+          status: 302,
+          headers: { Location: "http://example.com/a.txt" },
+        }),
+      );
+    });
+    const fs = remote(backend, {
+      params: { url: "https://example.com/", headers: "Cookie,secret" },
+    });
+    const response = await fs.get("a.txt");
+    await response.body?.cancel();
+    assert.equal(response.status, 502);
+    assert.deepEqual(urls, ["https://example.com/a.txt"]);
   });
 
-  await t.test("a directory", async () => {
-    // TODO: implement
+  test("stop after 10 redirects", async () => {
+    let count = 0;
+    const loop = await listen((request) => {
+      count++;
+      return Response.redirect(request.url, 302);
+    });
+    try {
+      const fs = remote(backend, {
+        params: { url: `${loop.url}`, headers: "Cookie,secret" },
+      });
+      const response = await fs.get("a.txt");
+      await response.body?.cancel();
+      assert.equal(response.status, 502);
+      assert.equal(count, 11);
+    } finally {
+      await loop.close();
+    }
   });
 });
diff --git a/backend/http/rclone_test.js b/backend/http/rclone_test.js
new file mode 100644
index 0000000..be70eac
--- /dev/null
+++ b/backend/http/rclone_test.js
@@ -0,0 +1,163 @@
+/**
+ * The tests of the http backend against the http backend of rclone: the two
+ * list the same server, and they must give the same files. The tests run
+ * when rclone is in the PATH, or when RCLONE is the path of rclone.
+ */
+import { after, before, describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { spawn, spawnSync } from "node:child_process";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import process from "node:process";
+
+import { remote } from "../../lib/testing/remote.js";
+import { listen } from "../../lib/testing/server.js";
+import memory from "../memory/main.js";
+import http from "./main.js";
+
+const RCLONE = process.env.RCLONE || "rclone";
+const hasRclone = spawnSync(RCLONE, ["version"]).status === 0;
+
+/** The files, with hard names. */
+const FILES = {
+  "empty.txt": 0,
+  "a/one.bin": 1,
+  "a/b/c.json": 100,
+  "file name #1.txt": 2048,
+  [`hello? sausage/êé/Hello, 世界/ " ' @ < > & ? + ≠/z.txt`]: 3000,
+};
+
+/** An index page as Apache makes it, at /index/. */
+const INDEX = `<!DOCTYPE html>
+<html><body><h1>Index of /index</h1><pre>
+<a href="?C=N;O=D">Name</a> <a href="?C=S;O=A">Size</a>
+<a href="/">Parent Directory</a>
+<a href="a.txt">a.txt</a>      17-Oct-2026 10:00    1
+<a href="./b%20c.json">b c.json</a> 17-Oct-2026 10:00    2
+<a href="http://127.0.0.1:1/index/x.txt">x.txt</a>
+<a href="/index/a.txt">a.txt again</a>
+<a href="lost.txt">lost.txt</a>
+<a href="sub/">sub/</a>
+<a href="sub/deep.txt">sub/deep.txt</a>
+<a href="#top">top</a>
+</pre></body></html>`;
+
+/** The files of the index page. */
+const INDEX_FILES = { "/index/a.txt": "a", "/index/b c.json": "{}" };
+
+/** @param {number} size */
+function content(size) {
+  return new Uint8Array(size).map((_, index) => (index * 11 + size) & 0xff);
+}
+
+describe("http and rclone", {
+  skip: !hasRclone && "rclone is not installed. Set RCLONE to its path.",
+}, () => {
+  const folder = mkdtempSync(join(tmpdir(), "rfetch-http-"));
+  let server;
+
+  before(async () => {
+    server = await listen((request) => {
+      const pathname = decodeURIComponent(new URL(request.url).pathname);
+      if (pathname === "/index/" || pathname === "/index/sub/") {
+        const html = pathname === "/index/" ? INDEX : "<html></html>";
+        return new Response(html, {
+          headers: { "Content-Type": "text/html; charset=utf-8" },
+        });
+      }
+      if (pathname in INDEX_FILES) {
+        const body = new TextEncoder().encode(INDEX_FILES[pathname]);
+        return new Response(request.method === "HEAD" ? null : body, {
+          headers: {
+            "Content-Length": `${body.length}`,
+            "Last-Modified": "Sat, 17 Oct 2026 10:00:00 GMT",
+          },
+        });
+      }
+      return memory.fetch(request);
+    });
+    const files = remote(memory, { root: "/rclone/" });
+    for (const [path, size] of Object.entries(FILES)) {
+      const response = await files.put(path, content(size));
+      assert.equal(response.status, 201, path);
+    }
+  });
+  after(async () => {
+    await server?.close();
+    rmSync(folder, { recursive: true, force: true });
+  });
+
+  /**
+   * The output of `rclone lsjson -R` for the http backend of rclone.
+   * Node does not answer the requests of rclone when spawnSync waits.
+   * @param {string} url
+   */
+  function lsjson(url) {
+    return new Promise((resolve, reject) => {
+      const child = spawn(
+        RCLONE,
+        ["lsjson", "-R", "--http-url", url, ":http:"],
+        { env: { PATH: process.env.PATH, HOME: folder } },
+      );
+      let stdout = "", stderr = "";
+      child.stdout.on("data", (data) => stdout += data);
+      child.stderr.on("data", (data) => stderr += data);
+      child.on("error", reject);
+      child.on("close", (status) => {
+        if (status === 0) resolve(JSON.parse(stdout));
+        else reject(new Error(`rclone lsjson ${url}: ${stderr}`));
+      });
+    });
+  }
+
+  /**
+   * The entries of all the folders, through the http backend of rfetch.
+   * @param {string} url
+   */
+  async function walk(url) {
+    const fs = remote(http, { params: { url } });
+    const entries = [];
+    const next = async (path) => {
+      for (const entry of await fs.list(path)) {
+        entries.push({ ...entry, Path: `${path}${entry.Name}` });
+        if (entry.IsDir) await next(`${path}${entry.Name}/`);
+      }
+    };
+    await next("");
+    return entries;
+  }
+
+  /** The fields to compare, in the order of the paths. */
+  function normalize(entries) {
+    return entries
+      .map(({ Path, IsDir, Size, MimeType, ModTime }) => ({
+        Path,
+        IsDir,
+        Size: IsDir ? -1 : Size,
+        MimeType: IsDir ? "" : MimeType,
+        // rclone has the time of Last-Modified, to the second.
+        ModTime: IsDir ? 0 : Math.floor(Date.parse(ModTime) / 1000),
+      }))
+      .sort((a, b) => a.Path < b.Path ? -1 : +(a.Path > b.Path));
+  }
+
+  test("list the lists of rfetch with the same files", async () => {
+    const url = `${server.url}rclone/`;
+    assert.deepEqual(
+      normalize(await walk(url)),
+      normalize(await lsjson(url)),
+    );
+  });
+
+  test("list an index page that is not of rfetch with the same files", async () => {
+    const url = `${server.url}index/`;
+    const expected = normalize(await lsjson(url));
+    assert.deepEqual(expected.map(({ Path }) => Path), [
+      "a.txt",
+      "b c.json",
+      "sub",
+    ]);
+    assert.deepEqual(normalize(await walk(url)), expected);
+  });
+});
diff --git a/lib/testing/server.js b/lib/testing/server.js
new file mode 100644
index 0000000..c3933cb
--- /dev/null
+++ b/lib/testing/server.js
@@ -0,0 +1,55 @@
+import { createServer } from "node:http";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+
+/**
+ * Serves a backend over HTTP on 127.0.0.1, for the tests of a backend that
+ * sends requests to a server.
+ * @param {(request: Request) => Response | Promise<Response>} handler
+ * @returns {Promise<{ url: URL, close: () => Promise<void> }>} `url` is the
+ *   root of the server, for example `http://127.0.0.1:40000/`.
+ */
+export async function listen(handler) {
+  const server = createServer(async (incoming, outgoing) => {
+    try {
+      const { method, headers } = incoming;
+      const request = new Request(
+        new URL(incoming.url, `http://${headers.host}`),
+        {
+          method,
+          headers: Object.entries(headers).flatMap(([name, value]) =>
+            [value].flat().map((value) => [name, value])
+          ),
+          body: method === "GET" || method === "HEAD"
+            ? null
+            : Readable.toWeb(incoming),
+          duplex: "half",
+        },
+      );
+      const response = await handler(request);
+      outgoing.writeHead(
+        response.status,
+        response.statusText,
+        [...response.headers].flat(),
+      );
+      if (response.body) {
+        await pipeline(Readable.fromWeb(response.body), outgoing);
+      } else {
+        outgoing.end();
+      }
+    } catch (error) {
+      if (!outgoing.headersSent) outgoing.writeHead(500);
+      outgoing.end(`${error}`);
+    }
+  });
+
+  await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
+  const { port } = server.address();
+  return {
+    url: new URL(`http://127.0.0.1:${port}/`),
+    close() {
+      server.closeAllConnections();
+      return new Promise((resolve) => server.close(() => resolve()));
+    },
+  };
+}

From 3b8fd8caf1a4720347c2436cb586d30995d9fe97 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sat, 17 Oct 2026 03:48:00 +0000
Subject: [PATCH 32/87] style: format main.js and _config.yml

deno fmt adds a comma in main.js and a line break at the end of _config.yml. Then deno fmt --check passes for all the files.
---
 _config.yml | 2 +-
 main.js     | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/_config.yml b/_config.yml
index fc24e7a..8bbf794 100644
--- a/_config.yml
+++ b/_config.yml
@@ -1 +1 @@
-theme: jekyll-theme-hacker
\ No newline at end of file
+theme: jekyll-theme-hacker
diff --git a/main.js b/main.js
index 0dd3257..d1014c4 100755
--- a/main.js
+++ b/main.js
@@ -44,7 +44,7 @@ const options = {
   "transfers": {
     type: "string",
     default: env["RCLONE_TRANSFERS"] || "4",
-  }
+  },
 };
 
 const {

From bda5f7ae723d68e4d6cd2828069c41cb0b1613be Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sat, 17 Oct 2026 03:48:00 +0000
Subject: [PATCH 33/87] fix: read the paths of remotes as rclone

lib/fspath.js reads a path as Parse of the package fs/fspath of rclone: remote:path, :backend:path, the options of a connection string, and a local path. fetch of mod.js uses it in place of a regular expression.

Thus, as in rclone:

- a value in quotes can have "," and ":", for example remote=':local,case_sensitive=true:/tmp'. Before, the value stopped at the first ",";
- the quotes are not a part of the value;
- a path in a remote can have ":";
- a path that is not correct gives a SyntaxError with the text of rclone;
- a value has no percent-decoding. Before, a value with "%" could give a URIError.

The tests have the cases of TestParse and TestCheckConfigName of rclone 1.75.1, and a property for the values in quotes. Two tests of main_test.js now expect the values of rclone. The config command uses the same name rule.
---
 cmd/config/main.js |   3 +-
 lib/fspath.js      | 213 +++++++++++++++++++++++++++++++++++++++++++
 lib/fspath_test.js | 220 +++++++++++++++++++++++++++++++++++++++++++++
 main_test.js       |   9 +-
 mod.js             |  30 +++----
 5 files changed, 455 insertions(+), 20 deletions(-)
 create mode 100644 lib/fspath.js
 create mode 100644 lib/fspath_test.js

diff --git a/cmd/config/main.js b/cmd/config/main.js
index 1eaebf9..4699f7f 100644
--- a/cmd/config/main.js
+++ b/cmd/config/main.js
@@ -1,6 +1,7 @@
 import { env } from "node:process";
 
 import { join } from "node:path";
+import { CONFIG_NAME } from "../../lib/fspath.js";
 import * as INI from "../../lib/ini.js";
 
 /**
@@ -8,7 +9,7 @@ import * as INI from "../../lib/ini.js";
  * letters, numbers, `_`, `-`, `.`, `+`, `@` and space, but not `-` or space
  * at the start, and not space at the end.
  */
-export const NAME_REGEX = /^[\w\p{L}\p{N}.+@]+(?:[ -]+[\w\p{L}\p{N}.+@-]+)*$/u;
+export const NAME_REGEX = new RegExp(`^${CONFIG_NAME}$`, "u");
 
 /**
  * @typedef {Object<string, string>} Options
diff --git a/lib/fspath.js b/lib/fspath.js
new file mode 100644
index 0000000..047f5a4
--- /dev/null
+++ b/lib/fspath.js
@@ -0,0 +1,213 @@
+/**
+ * The paths of rclone, as the package fs/fspath of rclone 1.75.1:
+ *
+ * - `remote:path` is a path of the remote `remote` of the config file.
+ * - `:backend:path` is a path of a remote of the type `backend`, with no
+ *   config file.
+ * - `remote,name=value,flag:path` sets the options `name` and `flag` of the
+ *   remote. A value in `'` or `"` quotes can have `,` and `:`, and two
+ *   quotes for one quote.
+ * - A path with no `:`, or with a `/` before the first `:` or `,`, is a local
+ *   path.
+ */
+
+/** The regular expression of the name of a remote in the config file. */
+export const CONFIG_NAME = String
+  .raw`[\w\p{L}\p{N}.+@]+(?:[ -]+[\w\p{L}\p{N}.+@-]+)*`;
+
+const CONFIG_NAME_MATCHER = new RegExp(`^${CONFIG_NAME}$`, "u");
+const REMOTE_NAME_MATCHER = new RegExp(`^:?${CONFIG_NAME}(?::$|,)`, "u");
+
+/** The errors, with the text of rclone. */
+export const Errors = {
+  INVALID_CHARACTERS:
+    "config name contains invalid characters - may only contain numbers, letters, `_`, `-`, `.`, `+`, `@` and space, while not start with `-` or space, and not end with space",
+  CANT_BE_EMPTY: "can't use empty string as a path",
+  BAD_CONFIG_PARAM:
+    "config parameters may only contain `0-9`, `A-Z`, `a-z`, `_` and `.`",
+  EMPTY_CONFIG_PARAM: "config parameters can't be empty",
+  CONFIG_NAME_EMPTY: "config name can't be empty",
+  CONFIG_NAME: "config name needs a trailing `:`",
+  PARAM: "config parameter must end with `,` or `:`",
+  VALUE: "unquoted config value must end with `,` or `:`",
+  QUOTED_VALUE: "unterminated quoted config value",
+  AFTER_QUOTE: "expecting `:` or `,` or another quote after a quote",
+};
+
+/**
+ * Tells if a text is a correct name of a remote in the config file.
+ * @param {string} name
+ */
+export function isConfigName(name) {
+  return CONFIG_NAME_MATCHER.test(name);
+}
+
+/**
+ * The parts of a path.
+ * @typedef {Object} Parsed
+ * @property {string} name The name of the remote, for example `remote`, or
+ *   `:backend` for a remote with no config file, or "" for a local path.
+ * @property {string} configString The text before the `:`, for example
+ *   `:backend,name=value`.
+ * @property {string} path The path in the remote, or the local path.
+ * @property {Record<string, string>} config The options of the connection
+ *   string, with no prototype.
+ */
+
+/**
+ * Reads a path of rclone, as `Parse` of rclone.
+ * @param {string} text For example `remote,name='a:b':path/to/file`.
+ * @returns {Parsed}
+ * @throws {SyntaxError} When the path is not correct.
+ */
+export function parse(text) {
+  /** @type {Parsed} */
+  const parsed = {
+    name: "",
+    configString: "",
+    path: text,
+    config: Object.create(null),
+  };
+  if (text === "") throw new SyntaxError(Errors.CANT_BE_EMPTY);
+  // A path with no ":" is a local path.
+  if (!text.includes(":")) return parsed;
+
+  const State = {
+    CONFIG_NAME: 0,
+    PARAM: 1,
+    VALUE: 2,
+    QUOTED_VALUE: 3,
+    AFTER_QUOTE: 4,
+    DONE: 5,
+  };
+  let state = State.CONFIG_NAME;
+  let index = 0;
+  // The start of the current part.
+  let start = 0;
+  let quote = "";
+  let param = "";
+  let doubled = false;
+
+  loop:
+  for (; index < text.length; index++) {
+    const c = text[index];
+    switch (state) {
+      case State.CONFIG_NAME:
+        if (index === 0 && c === ":") continue;
+        if (c === "/" || c === "\\") {
+          // A ":" or a "," after a "/" is a part of a local path. A path
+          // that starts with ":" is for a remote with no config file.
+          if (text[0] === ":") {
+            throw new SyntaxError(Errors.INVALID_CHARACTERS);
+          }
+          return parsed;
+        }
+        if (c === ":" || c === ",") {
+          parsed.name = text.slice(0, index);
+          checkRemoteName(`${parsed.name}:`);
+          start = index + 1;
+          if (c === ":") {
+            state = State.DONE;
+            break loop;
+          }
+          state = State.PARAM;
+        }
+        break;
+
+      case State.PARAM:
+        if (c === ":" || c === "," || c === "=") {
+          param = text.slice(start, index);
+          if (param === "") throw new SyntaxError(Errors.EMPTY_CONFIG_PARAM);
+          start = index + 1;
+          if (c === "=") {
+            state = State.VALUE;
+            break;
+          }
+          parsed.config[param] = "true";
+          if (c === ":") {
+            state = State.DONE;
+            break loop;
+          }
+        } else if (!/[\w.]/.test(c)) {
+          throw new SyntaxError(Errors.BAD_CONFIG_PARAM);
+        }
+        break;
+
+      case State.VALUE:
+        if (c === "'" || c === '"') {
+          // A quote starts a value in quotes only at the start of the value.
+          if (index === start) {
+            quote = c;
+            state = State.QUOTED_VALUE;
+            start = index + 1;
+            doubled = false;
+          }
+        } else if (c === ":" || c === ",") {
+          parsed.config[param] = text.slice(start, index);
+          start = index + 1;
+          if (c === ":") {
+            state = State.DONE;
+            break loop;
+          }
+          state = State.PARAM;
+        }
+        break;
+
+      case State.QUOTED_VALUE:
+        if (c === quote) state = State.AFTER_QUOTE;
+        break;
+
+      case State.AFTER_QUOTE:
+        if (c === ":" || c === ",") {
+          let value = text.slice(start, index - 1);
+          if (doubled) value = value.replaceAll(quote + quote, quote);
+          parsed.config[param] = value;
+          start = index + 1;
+          if (c === ":") {
+            state = State.DONE;
+            break loop;
+          }
+          state = State.PARAM;
+        } else if (c === quote) {
+          // Two quotes are one quote in the value.
+          state = State.QUOTED_VALUE;
+          doubled = true;
+        } else {
+          throw new SyntaxError(Errors.AFTER_QUOTE);
+        }
+        break;
+    }
+  }
+
+  switch (state) {
+    case State.CONFIG_NAME:
+      throw new SyntaxError(Errors.CONFIG_NAME);
+    case State.PARAM:
+      throw new SyntaxError(Errors.PARAM);
+    case State.VALUE:
+      throw new SyntaxError(Errors.VALUE);
+    case State.QUOTED_VALUE:
+      throw new SyntaxError(Errors.QUOTED_VALUE);
+    case State.AFTER_QUOTE:
+      throw new SyntaxError(Errors.AFTER_QUOTE);
+  }
+
+  parsed.configString = text.slice(0, index);
+  parsed.path = text.slice(index + 1);
+  return parsed;
+}
+
+/**
+ * Makes sure that the start of a path is a correct name of a remote, as
+ * `checkRemoteName` of rclone.
+ * @param {string} name For example `remote:` or `:backend,`.
+ * @throws {SyntaxError}
+ */
+function checkRemoteName(name) {
+  if (name === ":" || name === "::") {
+    throw new SyntaxError(Errors.CONFIG_NAME_EMPTY);
+  }
+  if (!REMOTE_NAME_MATCHER.test(name)) {
+    throw new SyntaxError(Errors.INVALID_CHARACTERS);
+  }
+}
diff --git a/lib/fspath_test.js b/lib/fspath_test.js
new file mode 100644
index 0000000..776594a
--- /dev/null
+++ b/lib/fspath_test.js
@@ -0,0 +1,220 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import fc from "fast-check";
+
+import { Errors, isConfigName, parse } from "./fspath.js";
+
+/**
+ * The cases of TestParse of rclone 1.75.1 (fs/fspath/path_test.go), with
+ * no case for Windows only: a path, and its parts or its error.
+ */
+const CASES = [
+  ["", Errors.CANT_BE_EMPTY],
+  [":", Errors.CONFIG_NAME],
+  ["::", Errors.CONFIG_NAME_EMPTY],
+  [":/:", Errors.INVALID_CHARACTERS],
+  ["/:", { name: "", configString: "", path: "/:" }],
+  ["\\backslash:", { name: "", configString: "", path: "\\backslash:" }],
+  ["/slash:", { name: "", configString: "", path: "/slash:" }],
+  ["with\\backslash:", {
+    name: "",
+    configString: "",
+    path: "with\\backslash:",
+  }],
+  ["with/slash:", { name: "", configString: "", path: "with/slash:" }],
+  ["/path/to/file", { name: "", configString: "", path: "/path/to/file" }],
+  ["/path:/to/file", { name: "", configString: "", path: "/path:/to/file" }],
+  ["./path:/to/file", { name: "", configString: "", path: "./path:/to/file" }],
+  ["./:colon.txt", { name: "", configString: "", path: "./:colon.txt" }],
+  ["path/to/file", { name: "", configString: "", path: "path/to/file" }],
+  [".:", { name: ".", configString: ".", path: "" }],
+  ["..:", { name: "..", configString: "..", path: "" }],
+  [".:colon.txt", { name: ".", configString: ".", path: "colon.txt" }],
+  ["remote:path/to/file", {
+    name: "remote",
+    configString: "remote",
+    path: "path/to/file",
+  }],
+  ["rem*ote:path/to/file", Errors.INVALID_CHARACTERS],
+  ["remote:/path/to/file", {
+    name: "remote",
+    configString: "remote",
+    path: "/path/to/file",
+  }],
+  ["rem.ote:/path/to/file", {
+    name: "rem.ote",
+    configString: "rem.ote",
+    path: "/path/to/file",
+  }],
+  ["rem ote:/path/to/file", {
+    name: "rem ote",
+    configString: "rem ote",
+    path: "/path/to/file",
+  }],
+  ["remote :/path/to/file", Errors.INVALID_CHARACTERS],
+  [" remote:/path/to/file", Errors.INVALID_CHARACTERS],
+  [" remote :/path/to/file", Errors.INVALID_CHARACTERS],
+  ["rem#ote:/path/to/file", Errors.INVALID_CHARACTERS],
+  [":backend:/path/to/file", {
+    name: ":backend",
+    configString: ":backend",
+    path: "/path/to/file",
+  }],
+  [":back.end:/path/to/file", {
+    name: ":back.end",
+    configString: ":back.end",
+    path: "/path/to/file",
+  }],
+  [":bac*kend:/path/to/file", Errors.INVALID_CHARACTERS],
+  ["C:\\path\\to\\file", {
+    name: "C",
+    configString: "C",
+    path: "\\path\\to\\file",
+  }],
+  ["\\path\\to\\file", {
+    name: "",
+    configString: "",
+    path: "\\path\\to\\file",
+  }],
+  [".", { name: "", configString: "", path: "." }],
+  ["..", { name: "", configString: "", path: ".." }],
+  ["remote:\\path\\to\\file", {
+    name: "remote",
+    configString: "remote",
+    path: "\\path\\to\\file",
+  }],
+  ["D:/path/to/file", { name: "D", configString: "D", path: "/path/to/file" }],
+  [":backend,param1:/path/to/file", {
+    name: ":backend",
+    configString: ":backend,param1",
+    path: "/path/to/file",
+    config: { param1: "true" },
+  }],
+  [":backend,param1=value:/path/to/file", {
+    name: ":backend",
+    configString: ":backend,param1=value",
+    path: "/path/to/file",
+    config: { param1: "value" },
+  }],
+  [":backend,param1=value1,param2,param3=value3:/path/to/file", {
+    name: ":backend",
+    configString: ":backend,param1=value1,param2,param3=value3",
+    path: "/path/to/file",
+    config: { param1: "value1", param2: "true", param3: "value3" },
+  }],
+  [":backend,param1=value1,param2=\"value2\",param3='value3':/path/to/file", {
+    name: ":backend",
+    configString: ":backend,param1=value1,param2=\"value2\",param3='value3'",
+    path: "/path/to/file",
+    config: { param1: "value1", param2: "value2", param3: "value3" },
+  }],
+  [":backend,param-1=value:/path/to/file", Errors.BAD_CONFIG_PARAM],
+  [':backend,param1="value"x:/path/to/file', Errors.AFTER_QUOTE],
+  [":backend,", Errors.PARAM],
+  [":backend,param=value", Errors.VALUE],
+  [":backend,param=\"value'", Errors.QUOTED_VALUE],
+  [':backend,param1="value"', Errors.AFTER_QUOTE],
+  [":backend,=value:", Errors.EMPTY_CONFIG_PARAM],
+  [":backend,:", Errors.EMPTY_CONFIG_PARAM],
+  [":backend,,:", Errors.EMPTY_CONFIG_PARAM],
+  [":backend,param=:path", {
+    name: ":backend",
+    configString: ":backend,param=",
+    path: "path",
+    config: { param: "" },
+  }],
+  [':backend,param="with""quote":path', {
+    name: ":backend",
+    configString: ':backend,param="with""quote"',
+    path: "path",
+    config: { param: 'with"quote' },
+  }],
+  [":backend,param='''''':", {
+    name: ":backend",
+    configString: ":backend,param=''''''",
+    path: "",
+    config: { param: "''" },
+  }],
+  [":backend,param=''bad'':", Errors.AFTER_QUOTE],
+];
+
+test("parse reads the paths of rclone (TestParse)", () => {
+  for (const [text, expected] of CASES) {
+    const what = JSON.stringify(text);
+    if (typeof expected === "string") {
+      assert.throws(() => parse(text), {
+        name: "SyntaxError",
+        message: expected,
+      }, what);
+      continue;
+    }
+    const { config = {}, ...parts } = expected;
+    const parsed = parse(text);
+    assert.deepEqual(
+      { ...parsed, config: { ...parsed.config } },
+      { ...parts, config },
+      what,
+    );
+  }
+});
+
+test("isConfigName accepts the names of rclone (TestCheckConfigName)", () => {
+  for (
+    const name of [
+      "remote",
+      "REMOTE",
+      "r-emote-",
+      "_rem_ote_",
+      ".",
+      "..",
+      ".r.e.m.o.t.e.",
+      "rem ote",
+      "user@example.com",
+      "user+junkmail@example.com",
+      "blåbær",
+      "chữ Quốc ngữ",
+    ]
+  ) {
+    assert.ok(isConfigName(name), name);
+  }
+  for (
+    const name of [
+      "",
+      ":remote:",
+      "remote:",
+      "rem:ote",
+      "rem/ote",
+      "rem\\ote",
+      "[remote",
+      "*",
+      "-remote",
+      "---rem:::ote???",
+      "remote ",
+      " remote",
+      " remote ",
+    ]
+  ) {
+    assert.ok(!isConfigName(name), name);
+  }
+});
+
+test("parse gives back the options of a connection string", () => {
+  const param = fc.stringMatching(/^[\w.]{1,8}$/);
+  const value = fc.string({ maxLength: 12 });
+  fc.assert(
+    fc.property(
+      fc.dictionary(param, value, { maxKeys: 4 }),
+      fc.constantFrom("'", '"'),
+      fc.string({ maxLength: 12 }),
+      (config, quote, path) => {
+        const options = Object.entries(config).map(([name, value]) =>
+          `,${name}=${quote}${value.replaceAll(quote, quote + quote)}${quote}`
+        );
+        const parsed = parse(`:backend${options.join("")}:${path}`);
+        assert.equal(parsed.name, ":backend");
+        assert.equal(parsed.path, path);
+        assert.deepEqual({ ...parsed.config }, { ...config });
+      },
+    ),
+  );
+});
diff --git a/main_test.js b/main_test.js
index eb2d909..a04d347 100644
--- a/main_test.js
+++ b/main_test.js
@@ -196,7 +196,8 @@ test("fetch", async (t) => {
         const { pathname, searchParams } = new URL(url, "file:");
 
         assert.deepEqual(pathname, "/");
-        assert.deepEqual(searchParams.get("remote"), `'${cwd}'`);
+        // As in rclone, the quotes are not a part of the value.
+        assert.deepEqual(searchParams.get("remote"), cwd);
       });
 
       await t.test(
@@ -214,7 +215,11 @@ test("fetch", async (t) => {
           const { pathname, searchParams } = new URL(url, "file:");
 
           assert.deepEqual(pathname, "/");
-          assert.deepEqual(searchParams.get("remote"), `':local:${cwd}'`);
+          // The value in quotes can have "," and ":", as in rclone.
+          assert.deepEqual(
+            searchParams.get("remote"),
+            `:local,case_sensitive=true:${cwd}`,
+          );
         },
       );
     });
diff --git a/mod.js b/mod.js
index 22b88df..2667e75 100644
--- a/mod.js
+++ b/mod.js
@@ -1,6 +1,7 @@
 import { env } from "node:process";
 import * as backends from "./backend/main.js";
 import * as commands from "./cmd/main.js";
+import { parse } from "./lib/fspath.js";
 
 export * from "./cmd/main.js";
 
@@ -35,9 +36,6 @@ export { Progress } from "./lib/streams/progress.js";
  * @property {Object} Metadata
  */
 
-const REMOTE_REGEX =
-  /^(:)?(?:([\w.][\w.\s-]*(?:,[\w=,"'*#.:@%-_\/]+)?):)?([^:]*)$/;
-
 const globalFetch = globalThis.fetch;
 
 /**
@@ -112,10 +110,9 @@ export async function fetch(input, init = {}) {
     return globalFetch(input, init);
   }
 
-  const [, colon, remote = "local", path] = input.match(REMOTE_REGEX) || [];
-  if (!remote && !path) {
-    return globalFetch(input, init);
-  }
+  // The parts of the path, as rclone reads them. It throws a SyntaxError
+  // for a path that is not correct.
+  const parsed = parse(input);
 
   // The final params.
   const params = new URLSearchParams();
@@ -130,16 +127,17 @@ export async function fetch(input, init = {}) {
     }
   }
 
-  // Remote can be connection string with arguments separated by commas.
-  let [name, ...args] = remote.split(",");
+  let { name } = parsed;
 
   /**
    * @type {Remote}
    */
   let config;
 
-  if (colon || remote === "local") { // the location has format `:type:path/to/file`
-    config = { type: name };
+  if (name === "") { // A local path.
+    config = { type: "local" };
+  } else if (name.startsWith(":")) { // `:type:path/to/file`
+    config = { type: name.slice(1) };
     name = "";
   } else {
     const response = await commands.config("show", name, undefined, {
@@ -186,7 +184,7 @@ export async function fetch(input, init = {}) {
   }
 
   // `searchParams` may contain other flags not for the current backend.
-  const { pathname, searchParams } = new URL(path, "file:");
+  const { pathname, searchParams } = new URL(parsed.path, "file:");
 
   // Overrides with flags in request's search params.
   searchParams.forEach((value, key) => {
@@ -196,11 +194,9 @@ export async function fetch(input, init = {}) {
   });
 
   // Overrides with parameters in connection string.
-  args.forEach((arg) => {
-    const [key, value = "true"] = arg.split("=");
-    // `value` can be encoded through URLSearchParams.
-    params.set(key, decodeURIComponent(value));
-  });
+  for (const [key, value] of Object.entries(parsed.config)) {
+    params.set(key, value);
+  }
 
   const headers = new Headers(init.headers);
 

From a4b1664d3547e103721d38c09122892c430ca902 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sat, 17 Oct 2026 03:48:00 +0000
Subject: [PATCH 34/87] ci: run the tests with rclone and Go, and check the
 format

The workflow runs for each push and each pull request:

- npm test with Node.js 22, 24 and 26. It installs rclone 1.75.1 and checks its SHA-256, and it installs Go. Thus the tests that compare rfetch with rclone and with Go run too.
- deno fmt --check with Deno 2.9.6.

It deploys nothing. CONTRIBUTING.md tells about the new options of the shared suite, the tests against rclone and Go, and the workflow.
---
 .github/workflows/ci.yml | 76 ++++++++++++++++++++++++++++++++++++++++
 CONTRIBUTING.md          | 24 +++++++++++--
 2 files changed, 98 insertions(+), 2 deletions(-)
 create mode 100644 .github/workflows/ci.yml

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
new file mode 100644
index 0000000..3323f5f
--- /dev/null
+++ b/.github/workflows/ci.yml
@@ -0,0 +1,76 @@
+# The checks of each push and of each pull request:
+#
+# - npm test: the tests, with the oldest Node.js of package.json and the
+#   newer versions. The job installs rclone and Go, thus the tests that
+#   compare rfetch with rclone and with Go run too.
+# - deno fmt --check: the format of the files.
+#
+# This workflow deploys nothing: the Pages project deploys the branches.
+name: CI
+
+on:
+  push:
+  pull_request:
+
+permissions:
+  contents: read
+
+# A new push to a branch stops the old run of that branch.
+concurrency:
+  group: ci-${{ github.ref }}
+  cancel-in-progress: true
+
+env:
+  RCLONE_VERSION: 1.75.1
+  RCLONE_SHA256: 982b5aa772841168f8e380f139e9e787b2a105403e32b94da8676a0e1c0a13ab
+  DENO_VERSION: 2.9.6
+
+jobs:
+  test:
+    runs-on: ubuntu-24.04
+    timeout-minutes: 15
+    strategy:
+      fail-fast: false
+      matrix:
+        node: [22, 24, 26]
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: ${{ matrix.node }}
+          cache: npm
+
+      # Go runs the tests of lib/list.js against encoding/csv.
+      - uses: actions/setup-go@v5
+        with:
+          go-version: stable
+          cache: false
+
+      - name: Install rclone
+        run: |
+          mkdir -p "$HOME/bin" "$RUNNER_TEMP/rclone"
+          cd "$RUNNER_TEMP/rclone"
+          zip="rclone-v$RCLONE_VERSION-linux-amd64.zip"
+          curl -fsSLO "https://downloads.rclone.org/v$RCLONE_VERSION/$zip"
+          echo "$RCLONE_SHA256  $zip" | sha256sum -c -
+          unzip -q "$zip"
+          install -m 755 "rclone-v$RCLONE_VERSION-linux-amd64/rclone" "$HOME/bin/rclone"
+          echo "$HOME/bin" >> "$GITHUB_PATH"
+          echo "RCLONE=$HOME/bin/rclone" >> "$GITHUB_ENV"
+
+      - run: npm ci
+
+      - run: npm test
+
+  format:
+    runs-on: ubuntu-24.04
+    timeout-minutes: 5
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: denoland/setup-deno@v2
+        with:
+          deno-version: ${{ env.DENO_VERSION }}
+
+      - run: deno fmt --check
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 07800db..40164cf 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -98,6 +98,9 @@ modification time.
 - `<data value>` is the size in bytes, for a file only.
 - `<time datetime>` is the time in ISO 8601.
 
+`renderListing` of `lib/listing.js` writes such a list from the entries of a
+folder, and `readListing` reads it.
+
 ## Tests of a backend
 
 Each backend must pass the shared tests of `lib/testing/suite.js`. These tests
@@ -131,6 +134,14 @@ and deletes it at the end. It tests:
 - `PUT` over a file, `DELETE` of a file, and `DELETE` of a folder with all that
   is in it.
 
+Two other options are for some backends only:
+
+- `skipName`: the suite skips the names that match this regular expression. Use
+  it only for a limit that the backend has in rclone too. For example, rclone
+  cannot read the name of a chunk with a line break.
+- `writer`: for a read only backend, for example `http`, the `PUT` and `DELETE`
+  requests go to this backend, and the backend under test reads the files.
+
 Put the tests for what only one backend does in the same file, after the suite.
 For example, the tests of the local backend make sure that a path cannot go out
 of the root folder.
@@ -139,5 +150,14 @@ Run all the tests with `npm test`, or the tests of one backend with
 `node --test backend/remote`.
 
 Some tests compare rfetch with rclone, for example the tests of `lib/ini.js` and
-`backend/crypt/rclone_test.js`. They run when `rclone` is in the `PATH`, or when
-the variable `RCLONE` is the path of rclone. Else they are skipped.
+the files `rclone_test.js` of the backends. They run when `rclone` is in the
+`PATH`, or when the variable `RCLONE` is the path of rclone. Else they are
+skipped. The tests of `lib/list.js` compare it with the `encoding/csv` package
+of Go, when `go` is in the `PATH` or when the variable `GO` is its path.
+
+## Continuous integration
+
+The workflow `.github/workflows/ci.yml` runs for each push and each pull
+request. It installs rclone and Go, runs `npm test` with Node.js 22, 24 and 26,
+and runs `deno fmt --check`. Before a push, run `npm test` and
+`deno fmt --check`.

From 2d743ca5fe4e55829aa5f0e85dce040ceae07f1e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sat, 17 Oct 2026 03:51:03 +0000
Subject: [PATCH 35/87] fix(ci): run the tests against rclone, and fail when
 they skip

The job had the variable RCLONE_VERSION. rclone reads each variable RCLONE_NAME as the flag --name, thus rclone version failed with "Invalid value when setting --version", and the tests against rclone skipped. The run was green with no test against rclone.

Now the version and the SHA-256 of rclone are only in the variables of the step that installs it, and the step runs rclone version. After npm test, a test that skipped because rclone or Go is not installed makes the job fail.
---
 .github/workflows/ci.yml | 33 ++++++++++++++++++++++-----------
 1 file changed, 22 insertions(+), 11 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 3323f5f..761d036 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -20,11 +20,6 @@ concurrency:
   group: ci-${{ github.ref }}
   cancel-in-progress: true
 
-env:
-  RCLONE_VERSION: 1.75.1
-  RCLONE_SHA256: 982b5aa772841168f8e380f139e9e787b2a105403e32b94da8676a0e1c0a13ab
-  DENO_VERSION: 2.9.6
-
 jobs:
   test:
     runs-on: ubuntu-24.04
@@ -47,21 +42,37 @@ jobs:
           go-version: stable
           cache: false
 
+      # rclone reads each variable RCLONE_NAME as the flag --name. Thus the
+      # version is not in a variable RCLONE_VERSION of the job: rclone reads
+      # it as the flag --version, and fails.
       - name: Install rclone
+        env:
+          VERSION: 1.75.1
+          SHA256: 982b5aa772841168f8e380f139e9e787b2a105403e32b94da8676a0e1c0a13ab
         run: |
           mkdir -p "$HOME/bin" "$RUNNER_TEMP/rclone"
           cd "$RUNNER_TEMP/rclone"
-          zip="rclone-v$RCLONE_VERSION-linux-amd64.zip"
-          curl -fsSLO "https://downloads.rclone.org/v$RCLONE_VERSION/$zip"
-          echo "$RCLONE_SHA256  $zip" | sha256sum -c -
+          zip="rclone-v$VERSION-linux-amd64.zip"
+          curl -fsSLO "https://downloads.rclone.org/v$VERSION/$zip"
+          echo "$SHA256  $zip" | sha256sum -c -
           unzip -q "$zip"
-          install -m 755 "rclone-v$RCLONE_VERSION-linux-amd64/rclone" "$HOME/bin/rclone"
+          install -m 755 "rclone-v$VERSION-linux-amd64/rclone" "$HOME/bin/rclone"
+          "$HOME/bin/rclone" version
           echo "$HOME/bin" >> "$GITHUB_PATH"
           echo "RCLONE=$HOME/bin/rclone" >> "$GITHUB_ENV"
 
       - run: npm ci
 
-      - run: npm test
+      # A test against rclone or Go skips when the tool is not installed.
+      # Here the tools are installed, thus such a skip is an error.
+      - name: npm test
+        shell: bash
+        run: |
+          npm test 2>&1 | tee "$RUNNER_TEMP/test.log"
+          if grep -E "(rclone|Go) is not installed" "$RUNNER_TEMP/test.log"; then
+            echo "::error::A test skipped because a tool is not installed."
+            exit 1
+          fi
 
   format:
     runs-on: ubuntu-24.04
@@ -71,6 +82,6 @@ jobs:
 
       - uses: denoland/setup-deno@v2
         with:
-          deno-version: ${{ env.DENO_VERSION }}
+          deno-version: 2.9.6
 
       - run: deno fmt --check

From 6841fb85a55f2e5bee53265dd49322d0c7406769 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sat, 17 Oct 2026 03:57:04 +0000
Subject: [PATCH 36/87] refactor: the backends import nothing of rfetch

Before, alias, chunker and crypt imported the fetch of mod.js, and mod.js put its fetch in place of the global fetch. Now a backend is a Worker of Cloudflare: it gets all from the request and from env, the second argument of fetch.

- alias, chunker and crypt send their requests to the remote under them with env.REMOTE.fetch, as a service binding. With no REMOTE, they use the global fetch, for example for a remote with an https URL.
- The fetch of mod.js gives REMOTE to each backend. _worker.js gives it too, when env has no REMOTE.
- mod.js does not change the global fetch. The commands and the tests import the fetch of mod.js.
- lib/testing/remote.js and the shared suite have the option env.

The tests, the commands and the Worker give the same results as before.
---
 CONTRIBUTING.md                | 17 +++++++
 _worker.js                     |  7 ++-
 backend/alias/main.js          |  9 ++--
 backend/alias/main_test.js     | 10 +++--
 backend/chunker/main.js        | 82 +++++++++++++++++++---------------
 backend/chunker/main_test.js   | 21 ++++++---
 backend/chunker/rclone_test.js | 10 ++++-
 backend/crypt/main.js          | 13 +++---
 backend/crypt/main_test.js     | 17 ++++---
 backend/crypt/rclone_test.js   |  5 +++
 backend/main.js                | 15 ++++++-
 cmd/backend/main.js            |  2 +
 cmd/lsjson/main_test.js        |  1 +
 lib/testing/remote.js          | 10 +++--
 lib/testing/suite.js           |  8 ++--
 main_test.js                   |  2 +-
 mod.js                         | 13 ++++--
 17 files changed, 169 insertions(+), 73 deletions(-)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 40164cf..a888d38 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -61,6 +61,23 @@ export default {
 };
 ```
 
+A backend imports nothing of rfetch, for example `mod.js`. It is a Worker of
+Cloudflare: it gets all from the request and from `env`, the second argument of
+`fetch`. A backend on top of another remote, for example `crypt` or `chunker`,
+sends its requests to that remote with `env.REMOTE.fetch`, as a service binding.
+With no `REMOTE`, it uses the global `fetch`. The `fetch` of `mod.js` and
+`_worker.js` give `REMOTE`: it reads remotes as `:memory:/path`. In the tests,
+give the same `env` to the suite:
+
+```js
+import { fetch } from "../../mod.js";
+
+backendSuite("crypt", crypt, {
+  env: { REMOTE: { fetch } },
+  params: { remote: ":memory:/crypt", password },
+});
+```
+
 ## Architecture
 
 - `GET /folder/`: displays HTML page with folder content.
diff --git a/_worker.js b/_worker.js
index 15d4889..39cdbf8 100644
--- a/_worker.js
+++ b/_worker.js
@@ -1,4 +1,5 @@
 import * as backends from "./backend/main.js";
+import { fetch } from "./mod.js";
 
 /**
  * A handler
@@ -21,7 +22,7 @@ import * as backends from "./backend/main.js";
  * @param {string} [params.path]
  * @returns {Promise<Response}
  */
-function remote(request, _env, params) {
+function remote(request, env, params) {
   let { remote, path = "/" } = params;
 
   const backend = backends[remote];
@@ -38,7 +39,9 @@ function remote(request, _env, params) {
 
   request = new Request(url, request);
 
-  return backend.fetch(request);
+  // A backend on top of other remotes, for example crypt, sends its
+  // requests to them with the fetch of rfetch, as REMOTE.
+  return backend.fetch(request, { ...env, REMOTE: env.REMOTE ?? { fetch } });
 }
 
 const routes = {
diff --git a/backend/alias/main.js b/backend/alias/main.js
index fd238fb..8169fea 100644
--- a/backend/alias/main.js
+++ b/backend/alias/main.js
@@ -21,13 +21,15 @@
 
 import { relink } from "../../lib/listing.js";
 import { decodePath, encodePath } from "../../lib/path.js";
-import { fetch } from "../../mod.js";
 
 /**
  * @param {Request} request
+ * @param {{ REMOTE?: { fetch: typeof fetch } }} [env] `REMOTE` gets the
+ *   requests to the remote of the alias, as a service binding of Cloudflare.
+ *   With no `REMOTE`, the global `fetch` gets them.
  * @returns {Promise<Response>}
  */
-async function alias(request) {
+async function alias(request, env = {}) {
   const { method } = request;
   const { pathname, searchParams } = new URL(request.url);
 
@@ -47,7 +49,8 @@ async function alias(request) {
     init.body = request.body;
     init.duplex = "half";
   }
-  const response = await fetch(remote + encodePath(path), init);
+  const fetcher = env.REMOTE ?? globalThis;
+  const response = await fetcher.fetch(remote + encodePath(path), init);
   if (!response.ok) {
     return response;
   }
diff --git a/backend/alias/main_test.js b/backend/alias/main_test.js
index 9b2432d..44abfc0 100644
--- a/backend/alias/main_test.js
+++ b/backend/alias/main_test.js
@@ -6,8 +6,12 @@ import assert from "node:assert/strict";
 
 import { backendSuite } from "../../lib/testing/suite.js";
 import { remote } from "../../lib/testing/remote.js";
+import { fetch } from "../../mod.js";
 import backend from "./main.js";
 
+/** The remotes under the backend, through the fetch of rfetch. */
+const env = { REMOTE: { fetch } };
+
 test("local path", async () => {
   const requestInit = {
     method: "GET",
@@ -17,7 +21,7 @@ test("local path", async () => {
   const url = new URL(`/backend/?remote=.`, import.meta.url);
 
   const request = new Request(url, requestInit);
-  const response = await backend.fetch(request);
+  const response = await backend.fetch(request, env);
   const html = await response.text();
 
   const entries = await readdir(join(cwd, "backend"), { withFileTypes: true });
@@ -33,10 +37,10 @@ test("local path", async () => {
   }
 });
 
-backendSuite("alias", backend, { params: { remote: ":memory:/alias" } });
+backendSuite("alias", backend, { env, params: { remote: ":memory:/alias" } });
 
 test("the links of a list are in the alias", async () => {
-  const fs = remote(backend, { params: { remote: ":memory:/links" } });
+  const fs = remote(backend, { env, params: { remote: ":memory:/links" } });
   await fs.put("a b.txt", new TextEncoder().encode("a"));
   const html = await fs.get("").then((response) => response.text());
   assert.ok(html.includes(` href="a%20b.txt?remote=%3Amemory%3A%2Flinks"`));
diff --git a/backend/chunker/main.js b/backend/chunker/main.js
index bab864a..49b15dd 100644
--- a/backend/chunker/main.js
+++ b/backend/chunker/main.js
@@ -106,7 +106,6 @@ import { mimeType } from "../../lib/mime.js";
 import { decodePath, encodePath } from "../../lib/path.js";
 import { parseSize } from "../../lib/size.js";
 import { sized } from "../../lib/streams/sized.js";
-import { fetch } from "../../mod.js";
 
 /** The largest metadata that rclone reads, and that it writes, in bytes. */
 const MAX_METADATA_SIZE = 1023;
@@ -164,20 +163,25 @@ export const options = {
  * @property {boolean} noRename True for the transactions "norename".
  * @property {boolean} failHard
  * @property {ReturnType<typeof nameFormat>} names
+ * @property {{ fetch: typeof fetch }} fetcher The remote under the chunker:
+ *   `env.REMOTE`, or the global `fetch`.
  */
 
 /**
  * @param {Request} request
+ * @param {{ REMOTE?: { fetch: typeof fetch } }} [env] `REMOTE` gets the
+ *   requests to the remote under the chunker, as a service binding of
+ *   Cloudflare. With no `REMOTE`, the global `fetch` gets them.
  * @returns {Promise<Response>}
  */
-async function chunker(request) {
+async function chunker(request, env = {}) {
   const { method } = request;
   const { pathname, searchParams } = new URL(request.url);
 
   /** @type {Config} */
   let config;
   try {
-    config = configOf(searchParams);
+    config = configOf(searchParams, env);
   } catch (error) {
     return new Response(error.message, { status: 400 });
   }
@@ -195,7 +199,7 @@ async function chunker(request) {
       return await listFolder(config, path, method, `${searchParams}`);
     }
     // A folder is a folder of the remote.
-    const response = await fetch(config.remote + encodePath(path), {
+    const response = await send(config, path, {
       method,
       headers: request.headers,
     });
@@ -239,9 +243,10 @@ class ChunkerError extends Error {
 /**
  * Reads the options, as `NewFs` of the chunker of rclone.
  * @param {URLSearchParams} searchParams
+ * @param {{ REMOTE?: { fetch: typeof fetch } }} env
  * @returns {Config}
  */
-function configOf(searchParams) {
+function configOf(searchParams, env) {
   const get = (name) => searchParams.get(name) ?? options.default[name];
 
   const remote = searchParams.get("remote")?.replace(/\/$/, "");
@@ -299,6 +304,7 @@ function configOf(searchParams) {
     noRename,
     failHard: get("fail_hard") === "true",
     names: nameFormat(get("name_format"), startFrom),
+    fetcher: env.REMOTE ?? globalThis,
   };
 }
 
@@ -379,7 +385,7 @@ function nameFormat(pattern, startFrom) {
  * @param {string} dir The path of the folder, with "/" at the end.
  */
 async function listRemote(config, dir) {
-  const response = await fetch(config.remote + encodePath(dir));
+  const response = await send(config, dir);
   if (response.status === 404) {
     await response.body?.cancel();
     return null;
@@ -547,7 +553,7 @@ function writeMetadata(size, nchunks, { md5, sha1 }, xact) {
  */
 function metadataReader(config, dir) {
   return async (name) => {
-    const response = await fetch(config.remote + encodePath(dir + name));
+    const response = await send(config, dir + name);
     if (!response.ok) {
       await response.body?.cancel();
       return null;
@@ -668,7 +674,7 @@ async function getFile(config, dir, name, method) {
   }
   if (!file.chunks) {
     // A file of the remote.
-    return await fetch(config.remote + encodePath(dir + name), { method });
+    return await send(config, dir + name, { method });
   }
 
   const headers = new Headers({
@@ -681,18 +687,19 @@ async function getFile(config, dir, name, method) {
   if (method === "HEAD") {
     return new Response(null, { headers });
   }
-  const urls = file.chunks.map((chunk) =>
-    config.remote + encodePath(dir + chunk.Name)
-  );
-  return new Response(sized(concatenate(urls), file.size), { headers });
+  const paths = file.chunks.map((chunk) => dir + chunk.Name);
+  return new Response(sized(concatenate(config, paths), file.size), {
+    headers,
+  });
 }
 
 /**
  * Gives the data of files of the remote, one after the other.
- * @param {string[]} urls
+ * @param {Config} config
+ * @param {string[]} paths
  * @returns {ReadableStream<Uint8Array>}
  */
-function concatenate(urls) {
+function concatenate(config, paths) {
   let index = 0;
   /** @type {ReadableStreamDefaultReader<Uint8Array> | null} */
   let reader = null;
@@ -700,11 +707,11 @@ function concatenate(urls) {
     async pull(controller) {
       while (true) {
         if (!reader) {
-          if (index === urls.length) {
+          if (index === paths.length) {
             controller.close();
             return;
           }
-          const response = await fetch(urls[index++]);
+          const response = await send(config, paths[index++]);
           if (!response.ok || !response.body) {
             throw new Error(`chunker: chunk ${index} gave ${response.status}`);
           }
@@ -772,11 +779,7 @@ async function putFile(config, dir, name, request, pathname) {
     const type = request.headers.get("Content-Type");
     if (type) headers.set("Content-Type", type);
     headers.set("Content-Length", `${length}`);
-    await put(
-      config.remote + encodePath(dir + name),
-      source.take(length),
-      headers,
-    );
+    await put(config, dir + name, source.take(length), headers);
     await source.end(length);
     written.add(name);
   } else {
@@ -793,11 +796,7 @@ async function putFile(config, dir, name, request, pathname) {
       const headers = new Headers();
       if (length !== null) headers.set("Content-Length", `${chunkSize}`);
       const before = source.count;
-      await put(
-        config.remote + encodePath(dir + chunkName),
-        source.take(chunkSize, hash),
-        headers,
-      );
+      await put(config, dir + chunkName, source.take(chunkSize, hash), headers);
       size += source.count - before;
       written.add(chunkName);
       chunkNo++;
@@ -808,7 +807,8 @@ async function putFile(config, dir, name, request, pathname) {
       const hashes = hash ? { [config.hash]: hash.digest("hex") } : {};
       const metadata = writeMetadata(size, chunkNo, hashes, xact);
       await put(
-        config.remote + encodePath(dir + name),
+        config,
+        dir + name,
         new Blob([metadata]).stream(),
         new Headers({
           "Content-Type": "application/json",
@@ -822,7 +822,7 @@ async function putFile(config, dir, name, request, pathname) {
   // The chunks of the old version go away.
   for (const entry of old) {
     if (!written.has(entry.Name)) {
-      await remove(config.remote + encodePath(dir + entry.Name));
+      await remove(config, dir + entry.Name);
     }
   }
 
@@ -847,19 +847,31 @@ async function deleteFile(config, dir, name) {
   // stays.
   entries.sort((a, b) => (b.Name === name) - (a.Name === name));
   for (const entry of entries) {
-    await remove(config.remote + encodePath(dir + entry.Name));
+    await remove(config, dir + entry.Name);
   }
   return new Response(null, { status: 204 });
 }
 
+/**
+ * Sends a request to the remote under the chunker.
+ * @param {Config} config
+ * @param {string} path The path in the remote, with no percent-encoding.
+ * @param {RequestInit} [init]
+ * @returns {Promise<Response>}
+ */
+function send(config, path, init) {
+  return config.fetcher.fetch(config.remote + encodePath(path), init);
+}
+
 /**
  * Puts a body on the remote, or throws.
- * @param {string} url
+ * @param {Config} config
+ * @param {string} path
  * @param {ReadableStream<Uint8Array>} body
  * @param {Headers} headers
  */
-async function put(url, body, headers) {
-  const response = await fetch(url, {
+async function put(config, path, body, headers) {
+  const response = await send(config, path, {
     method: "PUT",
     headers,
     body,
@@ -871,9 +883,9 @@ async function put(url, body, headers) {
   }
 }
 
-/** @param {string} url */
-async function remove(url) {
-  const response = await fetch(url, { method: "DELETE" });
+/** @param {Config} config @param {string} path */
+async function remove(config, path) {
+  const response = await send(config, path, { method: "DELETE" });
   await response.body?.cancel();
 }
 
diff --git a/backend/chunker/main_test.js b/backend/chunker/main_test.js
index a02f6d9..fe98e67 100644
--- a/backend/chunker/main_test.js
+++ b/backend/chunker/main_test.js
@@ -4,17 +4,23 @@ import { createHash } from "node:crypto";
 
 import { backendSuite } from "../../lib/testing/suite.js";
 import { remote } from "../../lib/testing/remote.js";
+import { fetch } from "../../mod.js";
 import backend from "./main.js";
 
+/** The remotes under the backend, through the fetch of rfetch. */
+const env = { REMOTE: { fetch } };
+
 // Small chunks, thus the files of the suite have more than one chunk.
 const CHUNK = "64k";
 
 backendSuite("chunker", backend, {
+  env,
   params: { remote: ":memory:/chunker", chunk_size: CHUNK },
 });
 // Without metadata, a name is always in chunks. rclone does not read the
 // name of a chunk with "\n": "." of Go does not match it.
 backendSuite("chunker meta_format=none", backend, {
+  env,
   params: {
     remote: ":memory:/none",
     chunk_size: CHUNK,
@@ -24,6 +30,7 @@ backendSuite("chunker meta_format=none", backend, {
   skipName: /\n/,
 });
 backendSuite("chunker transactions=norename", backend, {
+  env,
   params: {
     remote: ":memory:/norename",
     chunk_size: CHUNK,
@@ -38,11 +45,14 @@ function content(size) {
 
 describe("chunker", () => {
   const root = ":memory:/layout";
-  const fs = remote(backend, { params: { remote: root, chunk_size: "1k" } });
+  const fs = remote(backend, {
+    env,
+    params: { remote: root, chunk_size: "1k" },
+  });
 
   /** The names of the files on the remote under the chunker. */
   async function layout(path = "") {
-    const response = await globalThis.fetch(`${root}/${path}`);
+    const response = await fetch(`${root}/${path}`);
     const html = await response.text();
     return [...html.matchAll(/<a href="([^"?]+)/g)]
       .map(([, href]) => decodeURIComponent(href))
@@ -52,7 +62,7 @@ describe("chunker", () => {
 
   /** @param {string} path */
   async function text(path) {
-    return await globalThis.fetch(`${root}/${path}`).then((r) => r.text());
+    return await fetch(`${root}/${path}`).then((r) => r.text());
   }
 
   test("puts a small file as it is, and a large file in chunks", async () => {
@@ -123,7 +133,7 @@ describe("chunker", () => {
 
   test("hides a file with a missing chunk", async () => {
     await fs.put("broken.bin", content(2500));
-    await globalThis.fetch(`${root}/broken.bin.rclone_chunk.002`, {
+    await fetch(`${root}/broken.bin.rclone_chunk.002`, {
       method: "DELETE",
     });
     assert.deepEqual(await fs.list(""), []);
@@ -150,13 +160,14 @@ describe("chunker", () => {
         },
       ]
     ) {
-      const response = await remote(backend, { params }).get("");
+      const response = await remote(backend, { env, params }).get("");
       assert.equal(response.status, 400, JSON.stringify(params));
     }
   });
 
   test("names the chunks with name_format and start_from", async () => {
     const custom = remote(backend, {
+      env,
       params: {
         remote: root,
         chunk_size: "1k",
diff --git a/backend/chunker/rclone_test.js b/backend/chunker/rclone_test.js
index c1d442d..919ee94 100644
--- a/backend/chunker/rclone_test.js
+++ b/backend/chunker/rclone_test.js
@@ -20,8 +20,12 @@ import { dirname, join } from "node:path";
 import process from "node:process";
 
 import { remote } from "../../lib/testing/remote.js";
+import { fetch } from "../../mod.js";
 import chunker from "./main.js";
 
+/** The remotes under the backend, through the fetch of rfetch. */
+const env = { REMOTE: { fetch } };
+
 const RCLONE = process.env.RCLONE || "rclone";
 const hasRclone = spawnSync(RCLONE, ["version"]).status === 0;
 
@@ -104,7 +108,10 @@ describe("chunker and rclone", {
 
   for (const [mode, options] of Object.entries(MODES)) {
     const rfetch = (side) =>
-      remote(chunker, { params: { remote: `${mode}/${side}`, ...options } });
+      remote(chunker, {
+        env,
+        params: { remote: `${mode}/${side}`, ...options },
+      });
 
     test(`${mode}: rfetch reads what rclone writes`, async () => {
       rclone("copy", join(folder, "plain"), `${mode}-by-rclone:`);
@@ -178,6 +185,7 @@ describe("chunker and rclone", {
 
   test("rclone reads a file that rfetch writes with no Content-Length", async () => {
     const fs = remote(chunker, {
+      env,
       params: { remote: "rename/by-rfetch", ...MODES.rename },
     });
     for (const size of [10, 3000]) {
diff --git a/backend/crypt/main.js b/backend/crypt/main.js
index a8cccdd..eff96c1 100644
--- a/backend/crypt/main.js
+++ b/backend/crypt/main.js
@@ -99,7 +99,6 @@ import { formatBytes } from "../../lib/format.js";
 import { mimeType } from "../../lib/mime.js";
 import { decodePath } from "../../lib/path.js";
 import { sized } from "../../lib/streams/sized.js";
-import { fetch } from "../../mod.js";
 import { reveal } from "../../cmd/obscure/main.js";
 import PathCipher from "./PathCipher.js";
 import {
@@ -150,9 +149,12 @@ const SECRETS = ["password", "password2"];
 /**
  * Serves a crypted remote.
  * @param {Request} request
+ * @param {{ REMOTE?: { fetch: typeof fetch } }} [env] `REMOTE` gets the
+ *   requests to the remote under crypt, as a service binding of Cloudflare.
+ *   With no `REMOTE`, the global `fetch` gets them.
  * @returns {Promise<Response>}
  */
-async function crypt(request) {
+async function crypt(request, env = {}) {
   const { method } = request;
   const { pathname, searchParams } = new URL(request.url);
 
@@ -179,6 +181,7 @@ async function crypt(request) {
     return new Response("The password is not obscured", { status: 400 });
   }
 
+  const fetcher = env.REMOTE ?? globalThis;
   const isDirectory = path.endsWith("/");
   const target = remote + cipher.names.encrypt(path);
 
@@ -188,7 +191,7 @@ async function crypt(request) {
   headers.delete("Range");
 
   if (method === "GET" || method === "HEAD") {
-    const response = await fetch(target, { method, headers });
+    const response = await fetcher.fetch(target, { method, headers });
     if (!response.ok) {
       return response;
     }
@@ -240,7 +243,7 @@ async function crypt(request) {
       init.duplex = "half";
     }
 
-    const response = await fetch(target, init);
+    const response = await fetcher.fetch(target, init);
     await response.body?.cancel();
     const result = new Headers();
     if (response.ok) {
@@ -250,7 +253,7 @@ async function crypt(request) {
   }
 
   if (method === "DELETE") {
-    const response = await fetch(target, { method, headers });
+    const response = await fetcher.fetch(target, { method, headers });
     await response.body?.cancel();
     return new Response(null, { status: response.status });
   }
diff --git a/backend/crypt/main_test.js b/backend/crypt/main_test.js
index 0d1956a..5cd0fae 100644
--- a/backend/crypt/main_test.js
+++ b/backend/crypt/main_test.js
@@ -7,9 +7,13 @@ import fc from "fast-check";
 
 import { backendSuite } from "../../lib/testing/suite.js";
 import { remote } from "../../lib/testing/remote.js";
+import { fetch } from "../../mod.js";
 import { mimeType } from "../../lib/mime.js";
 import { decode, default as crypt, deriveKey, encode } from "./main.js";
 
+/** The remotes under the backend, through the fetch of rfetch. */
+const env = { REMOTE: { fetch } };
+
 // The password "123456" and the salt, obscured.
 const PASSWORD = "UmyLSdRHfew6aual28-ggx78qHqSfQ";
 const SALT = "Cj3gLa5PVwc2aot0QpKiOZ3YEzs3Sw";
@@ -120,6 +124,7 @@ test("encode", async () => {
 
 test("GET of the fixtures", async () => {
   const fs = remote(crypt, {
+    env,
     params: { remote: "crypt", password: PASSWORD, password2: SALT },
   });
   for (const name of Object.keys(CRYPT)) {
@@ -144,10 +149,10 @@ const params = {
   password2: SALT,
 };
 
-backendSuite("crypt", crypt, { params });
+backendSuite("crypt", crypt, { env, params });
 
 describe("crypt", () => {
-  const fs = remote(crypt, { params });
+  const fs = remote(crypt, { env, params });
 
   test("puts no password in the links of a list", async () => {
     await fs.put("secret/a b.txt", new TextEncoder().encode("a"));
@@ -163,7 +168,7 @@ describe("crypt", () => {
 
   test("lists no file with a name that does not decrypt", async () => {
     // A file that is not encrypted, next to the encrypted files.
-    await globalThis.fetch(":memory:/crypt/plain.txt", {
+    await fetch(":memory:/crypt/plain.txt", {
       method: "PUT",
       body: "plain",
     });
@@ -173,11 +178,11 @@ describe("crypt", () => {
     assert.ok(!names.includes("plain.txt"));
     assert.equal(names.length, 1);
     await fs.delete("encrypted.txt");
-    await globalThis.fetch(":memory:/crypt/plain.txt", { method: "DELETE" });
+    await fetch(":memory:/crypt/plain.txt", { method: "DELETE" });
   });
 
   test("gives 400 for a password that is not obscured", async () => {
-    const bad = remote(crypt, { params: { ...params, password: "!!" } });
+    const bad = remote(crypt, { env, params: { ...params, password: "!!" } });
     const response = await bad.get("");
     assert.equal(response.status, 400);
     assert.ok(!(await response.text()).includes("!!"));
@@ -188,7 +193,7 @@ describe("crypt", () => {
       encode({ password: PASSWORD, password2: SALT }, "plain2.txt"),
     );
     // The name is encrypted, but the data is not.
-    await globalThis.fetch(`:memory:/crypt/${encrypted}`, {
+    await fetch(`:memory:/crypt/${encrypted}`, {
       method: "PUT",
       body: "not encrypted data, longer than a header of 32 bytes",
     });
diff --git a/backend/crypt/rclone_test.js b/backend/crypt/rclone_test.js
index e7e9d2c..022c483 100644
--- a/backend/crypt/rclone_test.js
+++ b/backend/crypt/rclone_test.js
@@ -19,8 +19,12 @@ import process from "node:process";
 import fc from "fast-check";
 
 import { remote } from "../../lib/testing/remote.js";
+import { fetch } from "../../mod.js";
 import crypt from "./main.js";
 
+/** The remotes under the backend, through the fetch of rfetch. */
+const env = { REMOTE: { fetch } };
+
 const RCLONE = process.env.RCLONE || "rclone";
 const hasRclone = spawnSync(RCLONE, ["version"]).status === 0;
 
@@ -69,6 +73,7 @@ describe("crypt and rclone", {
    */
   const rfetch = (name) =>
     remote(crypt, {
+      env,
       params: { remote: name, password: PASSWORD, password2: SALT },
     });
 
diff --git a/backend/main.js b/backend/main.js
index b3d7954..eb1271d 100644
--- a/backend/main.js
+++ b/backend/main.js
@@ -2,10 +2,21 @@
  * A backend is an interface to remote storage provider.
  *
  * Each backend implements the `fetch` method which takes a request and returns
- * a response, or a promise of a response.
+ * a response, or a promise of a response, as a Worker of Cloudflare. A backend
+ * imports nothing of rfetch: it gets all from the request and from `env`.
+ *
+ * A backend on top of another remote, for example crypt, sends its requests
+ * to that remote with `env.REMOTE.fetch`, as a service binding of
+ * Cloudflare. With no `REMOTE`, it uses the global `fetch`.
  *
  * @typedef {Object} Backend
- * @property {(request: Request) => Response | Promise<Response>} fetch
+ * @property {(request: Request, env?: Env) => Response | Promise<Response>} fetch
+ */
+
+/**
+ * @typedef {Object} Env
+ * @property {{ fetch: typeof fetch }} [REMOTE] Gets the requests to the
+ *   remote under the backend.
  */
 
 export { default as alias } from "./alias/main.js";
diff --git a/cmd/backend/main.js b/cmd/backend/main.js
index 255de00..7140603 100644
--- a/cmd/backend/main.js
+++ b/cmd/backend/main.js
@@ -1,3 +1,5 @@
+import { fetch } from "../../mod.js";
+
 /**
  * Run a backend-specific command.
  *
diff --git a/cmd/lsjson/main_test.js b/cmd/lsjson/main_test.js
index ac1b834..878db8a 100644
--- a/cmd/lsjson/main_test.js
+++ b/cmd/lsjson/main_test.js
@@ -1,5 +1,6 @@
 import { test } from "node:test";
 import assert from "node:assert/strict";
+import { fetch } from "../../mod.js";
 import { lsjson } from "./main.js";
 
 const encoder = new TextEncoder();
diff --git a/lib/testing/remote.js b/lib/testing/remote.js
index 6180632..26c73ba 100644
--- a/lib/testing/remote.js
+++ b/lib/testing/remote.js
@@ -8,11 +8,12 @@ const ORIGIN = "http://rfetch.test";
  * text, with `/` between the names and at the end of a folder. The client
  * puts the percent-encoding in each name, and the parameters of the backend
  * in the query.
- * @param {{ fetch: (request: Request) => Response | Promise<Response> }} backend
- * @param {{ params?: Record<string, string>, root?: string }} [options] `root`
- *   is a folder, for example `/rfetch-test-abc/`, under which all paths go.
+ * @param {{ fetch: (request: Request, env?: object) => Response | Promise<Response> }} backend
+ * @param {{ params?: Record<string, string>, root?: string, env?: object }} [options]
+ *   `root` is a folder, for example `/rfetch-test-abc/`, under which all
+ *   paths go. `env` is the env of the backend, for example `REMOTE`.
  */
-export function remote(backend, { params = {}, root = "/" } = {}) {
+export function remote(backend, { params = {}, root = "/", env = {} } = {}) {
   /**
    * Gives the URL of the path under the root.
    * @param {string} path
@@ -37,6 +38,7 @@ export function remote(backend, { params = {}, root = "/" } = {}) {
   async function send(path, init = {}) {
     return await backend.fetch(
       new Request(url(path), { duplex: "half", ...init }),
+      env,
     );
   }
 
diff --git a/lib/testing/suite.js b/lib/testing/suite.js
index 197ebe8..818c994 100644
--- a/lib/testing/suite.js
+++ b/lib/testing/suite.js
@@ -50,10 +50,12 @@ const FILE2 = `hello? sausage/êé/Hello, 世界/ " ' @ < > & ? + ≠/z.txt`;
  * @param {{ fetch: (request: Request) => Response | Promise<Response> }} backend
  * @param {{
  *   params?: Record<string, string>,
+ *   env?: object,
  *   skipName?: RegExp,
  *   writer?: { fetch: (request: Request) => Response | Promise<Response> },
  * }} [options] `params` go in the query of each request, for example the
- *   options of the backend. The tests skip the names that match `skipName`,
+ *   options of the backend. `env` is the env of the backend, for example
+ *   `REMOTE`. The tests skip the names that match `skipName`,
  *   for a limit that the backend has in rclone too. For a backend that is
  *   read only, the PUT and DELETE requests go to `writer`, with no `params`:
  *   a backend that writes the files that the backend under test reads.
@@ -61,10 +63,10 @@ const FILE2 = `hello? sausage/êé/Hello, 世界/ " ' @ < > & ? + ≠/z.txt`;
 export function backendSuite(
   name,
   backend,
-  { params = {}, skipName, writer } = {},
+  { params = {}, env = {}, skipName, writer } = {},
 ) {
   const root = `/rfetch-test-${randomBytes(6).toString("hex")}/`;
-  const fs = remote(backend, { params, root });
+  const fs = remote(backend, { params, root, env });
   if (writer) {
     const { put, delete: remove } = remote(writer, { root });
     Object.assign(fs, { put, delete: remove });
diff --git a/main_test.js b/main_test.js
index a04d347..7a0861d 100644
--- a/main_test.js
+++ b/main_test.js
@@ -4,7 +4,7 @@ import { unlink, writeFile } from "node:fs/promises";
 import { serve } from "@sntran/serve";
 import assert from "node:assert/strict";
 
-import { config } from "./mod.js";
+import { config, fetch } from "./mod.js";
 
 test("fetch", async (t) => {
   await t.test("global", () => {
diff --git a/mod.js b/mod.js
index 2667e75..8b66cc2 100644
--- a/mod.js
+++ b/mod.js
@@ -39,7 +39,8 @@ export { Progress } from "./lib/streams/progress.js";
 const globalFetch = globalThis.fetch;
 
 /**
- * Extended global `fetch` with support for remote URL.
+ * A `fetch` with support for remote URL. It does not replace the global
+ * `fetch`: import it.
  *
  * The syntax of the paths passed to the rfetch command are as follows.
  *
@@ -228,12 +229,18 @@ export async function fetch(input, init = {}) {
   const url = new URL(`${pathname}?${params}`, import.meta.url || `file:`);
   // Creates a new request with the initial init.
   const request = new Request(url, init);
-  // Clones that request and updates the headers.
+  // Clones that request and updates the headers. A backend on top of other
+  // remotes, for example crypt, sends its requests to them with this fetch.
   return backend.fetch(
     new Request(request, {
       headers,
     }),
+    REMOTE,
   );
 }
 
-globalThis.fetch = fetch;
+/**
+ * The env of a backend: `REMOTE` gets the requests of a backend to the
+ * remote under it, for example `:memory:/path` for crypt.
+ */
+const REMOTE = { REMOTE: { fetch } };

From ffad9dc2ff5b8450b0ab8dbeec3f222fe565736c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sat, 17 Oct 2026 04:04:44 +0000
Subject: [PATCH 37/87] feat(lib): ranges of bytes, as RFC 9110

parseRange reads the header Range of a request for a file of a size: one range bytes=START-END, bytes=START- or bytes=-LENGTH. It gives null to send all the file, for more ranges or a range that is not correct, and it throws a RangeError when no byte of the file is in the range. partialHeaders and notSatisfiable give the answers 206 and 416. sliceStream gives a part of a stream, and a property test checks it for any chunks.
---
 lib/range.js      | 108 ++++++++++++++++++++++++++++++++++++++++++++++
 lib/range_test.js |  81 ++++++++++++++++++++++++++++++++++
 2 files changed, 189 insertions(+)
 create mode 100644 lib/range.js
 create mode 100644 lib/range_test.js

diff --git a/lib/range.js b/lib/range.js
new file mode 100644
index 0000000..66ba956
--- /dev/null
+++ b/lib/range.js
@@ -0,0 +1,108 @@
+/**
+ * The ranges of bytes of a file, as RFC 9110 (section 14): the header
+ * `Range: bytes=START-END` of a GET request, and the answer 206 with
+ * `Content-Range`, or 416 when no byte of the file is in the range.
+ *
+ * Only one range is supported. A server can send all the file for a
+ * request with more ranges, or with a range that it cannot read.
+ */
+
+/**
+ * Reads the range of a request, for a file of a size.
+ * @param {string | null} header The value of `Range`, for example
+ *   `bytes=0-99`, `bytes=100-` or `bytes=-100`.
+ * @param {number} size The size of the file.
+ * @returns {{ start: number, end: number } | null} The first byte and the
+ *   last byte, or null to send all the file: for no range, for more ranges,
+ *   and for a range that is not correct.
+ * @throws {RangeError} When no byte of the file is in the range. Then the
+ *   answer is 416.
+ */
+export function parseRange(header, size) {
+  const match = header?.trim().match(/^bytes=(\d*)-(\d*)$/i);
+  if (!match) return null;
+  const [, first, last] = match;
+
+  if (first === "") {
+    // The last bytes of the file.
+    if (last === "") return null;
+    const length = Number(last);
+    if (length === 0 || size === 0) {
+      throw new RangeError("Range Not Satisfiable");
+    }
+    return { start: Math.max(0, size - length), end: size - 1 };
+  }
+
+  const start = Number(first);
+  const end = last === "" ? size - 1 : Math.min(Number(last), size - 1);
+  if (last !== "" && Number(last) < start) return null;
+  if (start >= size) throw new RangeError("Range Not Satisfiable");
+  return { start, end };
+}
+
+/**
+ * The headers of an answer 206, for a range of a file.
+ * @param {{ start: number, end: number }} range
+ * @param {number} size The size of the file.
+ * @returns {Record<string, string>}
+ */
+export function partialHeaders({ start, end }, size) {
+  return {
+    "Content-Range": `bytes ${start}-${end}/${size}`,
+    "Content-Length": `${end - start + 1}`,
+  };
+}
+
+/**
+ * The answer 416, when no byte of the file is in the range.
+ * @param {number} size The size of the file.
+ * @returns {Response}
+ */
+export function notSatisfiable(size) {
+  return new Response(null, {
+    status: 416,
+    headers: { "Content-Range": `bytes */${size}` },
+  });
+}
+
+/**
+ * Gives a part of a stream: the bytes after the first `skip` bytes, at most
+ * `length` bytes. It cancels the stream after the part.
+ * @param {ReadableStream<Uint8Array>} stream
+ * @param {number} skip
+ * @param {number} length
+ * @returns {ReadableStream<Uint8Array>}
+ */
+export function sliceStream(stream, skip, length) {
+  const reader = stream.getReader();
+  return new ReadableStream({
+    async pull(controller) {
+      while (true) {
+        if (length <= 0) {
+          controller.close();
+          await reader.cancel();
+          return;
+        }
+        const { done, value } = await reader.read();
+        if (done) {
+          controller.close();
+          return;
+        }
+        let chunk = value;
+        if (skip > 0) {
+          const dropped = Math.min(skip, chunk.length);
+          skip -= dropped;
+          chunk = chunk.subarray(dropped);
+        }
+        if (chunk.length === 0) continue;
+        if (chunk.length > length) chunk = chunk.subarray(0, length);
+        length -= chunk.length;
+        controller.enqueue(chunk);
+        return;
+      }
+    },
+    cancel(reason) {
+      return reader.cancel(reason);
+    },
+  });
+}
diff --git a/lib/range_test.js b/lib/range_test.js
new file mode 100644
index 0000000..97ad105
--- /dev/null
+++ b/lib/range_test.js
@@ -0,0 +1,81 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import fc from "fast-check";
+
+import { parseRange, sliceStream } from "./range.js";
+
+test("parseRange reads one range of bytes", () => {
+  const size = 1000;
+  for (
+    const [header, range] of [
+      ["bytes=0-0", { start: 0, end: 0 }],
+      ["bytes=0-99", { start: 0, end: 99 }],
+      ["bytes=100-", { start: 100, end: 999 }],
+      ["bytes=999-", { start: 999, end: 999 }],
+      ["bytes=500-5000", { start: 500, end: 999 }],
+      ["bytes=-1", { start: 999, end: 999 }],
+      ["bytes=-100", { start: 900, end: 999 }],
+      ["bytes=-5000", { start: 0, end: 999 }],
+      ["Bytes=1-2", { start: 1, end: 2 }],
+      [" bytes=1-2 ", { start: 1, end: 2 }],
+    ]
+  ) {
+    assert.deepEqual(parseRange(header, size), range, header);
+  }
+});
+
+test("parseRange gives null to send all the file", () => {
+  for (
+    const header of [
+      null,
+      "",
+      "bytes=",
+      "bytes=-",
+      "bytes=5-1",
+      "bytes=0-1,5-6",
+      "items=0-1",
+      "bytes=a-b",
+      "bytes=1.5-2",
+    ]
+  ) {
+    assert.equal(parseRange(header, 1000), null, JSON.stringify(header));
+  }
+});
+
+test("parseRange throws when no byte is in the range", () => {
+  for (
+    const [header, size] of [
+      ["bytes=1000-", 1000],
+      ["bytes=1000-2000", 1000],
+      ["bytes=-0", 1000],
+      ["bytes=0-", 0],
+      ["bytes=-1", 0],
+    ]
+  ) {
+    assert.throws(() => parseRange(header, size), RangeError, header);
+  }
+});
+
+test("sliceStream gives the bytes of the part, for any chunks", async () => {
+  await fc.assert(
+    fc.asyncProperty(
+      fc.uint8Array({ maxLength: 300 }),
+      fc.array(fc.nat(50), { maxLength: 20 }),
+      fc.nat(320),
+      fc.nat(320),
+      async (data, cuts, skip, length) => {
+        // The data in chunks of the sizes of `cuts`, then the rest.
+        const chunks = [];
+        let offset = 0;
+        for (const cut of cuts) {
+          chunks.push(data.subarray(offset, offset + cut));
+          offset += cut;
+        }
+        chunks.push(data.subarray(offset));
+        const part = sliceStream(ReadableStream.from(chunks), skip, length);
+        const bytes = new Uint8Array(await new Response(part).arrayBuffer());
+        assert.deepEqual(bytes, data.slice(skip, skip + length));
+      },
+    ),
+  );
+});

From 2c1d0138dbc29d1d07e455400abcf49c5099ffce Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sat, 17 Oct 2026 04:04:44 +0000
Subject: [PATCH 38/87] feat: ranges in the backends memory, local, http and
 chunker

A GET with Range gives 206 with the bytes of the range, Content-Range and the size of the range, or 416. A file gives Accept-Ranges: bytes.

- memory: a slice of the Blob.
- local: a read from the position of the first byte.
- http: the server gets the Range, and the client gets the answer 206 or 416. A redirect to a different host keeps the Range, but not the headers option.
- alias: the remote gives the answer.
- chunker: only the chunks in the range, with a range of the first and the last chunk. When the remote sends all of a chunk, only the part goes out.

The shared suite checks the ranges at the start, at the end and at the ends of blocks of 64 KiB, 416, and ranges that a backend does not read. CONTRIBUTING.md tells the rules.
---
 CONTRIBUTING.md              | 11 ++++-
 backend/chunker/main.js      | 78 ++++++++++++++++++++++++++++++------
 backend/chunker/main_test.js | 51 +++++++++++++++++++++++
 backend/http/main.js         | 45 ++++++++++++++++-----
 backend/local/main.js        | 29 +++++++++++++-
 backend/memory/main.js       | 19 +++++++++
 lib/testing/suite.js         | 56 ++++++++++++++++++++++++++
 7 files changed, 264 insertions(+), 25 deletions(-)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index a888d38..4a82f8d 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -92,8 +92,13 @@ The answers:
 
 - `PUT` gives 201 with the path in `Content-Location`. `DELETE` gives 204.
 - A file or a folder that does not exist gives 404.
-- `GET` of a file gives the headers `Content-Type`, `Content-Length` and
-  `Last-Modified`.
+- `GET` of a file gives the headers `Content-Type`, `Content-Length`,
+  `Last-Modified` and `Accept-Ranges: bytes`.
+- `GET` with `Range: bytes=START-END` gives 206 with the bytes of the range,
+  `Content-Range` and the `Content-Length` of the range, as RFC 9110. A range
+  with no byte of the file gives 416. A request with more ranges, or with a
+  range that is not correct, gets all the file. Use `parseRange` of
+  `lib/range.js`.
 
 The path of a request has percent-encoding. Use `decodePath` of `lib/path.js` to
 get the path with no percent-encoding. It gives `null` for a path that is not
@@ -148,6 +153,8 @@ and deletes it at the end. It tests:
 - The list of each folder: the name, the type, the size and the time of each
   file.
 - `GET` and `HEAD` of a file: the bytes, and the headers.
+- Ranges of a file: at the start, at the end, at the ends of blocks of 64 KiB,
+  416, and ranges that the backend does not read.
 - `PUT` over a file, `DELETE` of a file, and `DELETE` of a folder with all that
   is in it.
 
diff --git a/backend/chunker/main.js b/backend/chunker/main.js
index 49b15dd..c550ffc 100644
--- a/backend/chunker/main.js
+++ b/backend/chunker/main.js
@@ -104,6 +104,12 @@ import { createHash } from "node:crypto";
 import { readListing, renderListing } from "../../lib/listing.js";
 import { mimeType } from "../../lib/mime.js";
 import { decodePath, encodePath } from "../../lib/path.js";
+import {
+  notSatisfiable,
+  parseRange,
+  partialHeaders,
+  sliceStream,
+} from "../../lib/range.js";
 import { parseSize } from "../../lib/size.js";
 import { sized } from "../../lib/streams/sized.js";
 
@@ -215,7 +221,7 @@ async function chunker(request, env = {}) {
     switch (method) {
       case "GET":
       case "HEAD":
-        return await getFile(config, dir, name, method);
+        return await getFile(config, dir, name, method, request);
       case "PUT":
         return await putFile(config, dir, name, request, pathname);
       case "DELETE":
@@ -666,20 +672,26 @@ async function findFile(config, dir, name) {
  * @param {string} dir
  * @param {string} name
  * @param {string} method
+ * @param {Request} request Its `Range` gives a range of the file.
  */
-async function getFile(config, dir, name, method) {
+async function getFile(config, dir, name, method, request) {
   const { file } = await findFile(config, dir, name);
   if (!file) {
     return new Response(null, { status: 404 });
   }
+  const header = method === "GET" ? request.headers.get("Range") : null;
   if (!file.chunks) {
-    // A file of the remote.
-    return await send(config, dir + name, { method });
+    // A file of the remote, with the range of the request.
+    return await send(config, dir + name, {
+      method,
+      headers: header === null ? {} : { Range: header },
+    });
   }
 
   const headers = new Headers({
     "Content-Type": mimeType(name),
     "Content-Length": `${file.size}`,
+    "Accept-Ranges": "bytes",
   });
   if (file.modTime) {
     headers.set("Last-Modified", new Date(file.modTime).toUTCString());
@@ -687,19 +699,53 @@ async function getFile(config, dir, name, method) {
   if (method === "HEAD") {
     return new Response(null, { headers });
   }
-  const paths = file.chunks.map((chunk) => dir + chunk.Name);
-  return new Response(sized(concatenate(config, paths), file.size), {
+
+  let range;
+  try {
+    range = parseRange(header, file.size);
+  } catch {
+    return notSatisfiable(file.size);
+  }
+  const { start, end } = range ?? { start: 0, end: file.size - 1 };
+  // The chunks in the range, with the part of each chunk in the range.
+  /** @type {Array<{ path: string, from: number, to: number, size: number }>} */
+  const parts = [];
+  let offset = 0;
+  for (const chunk of file.chunks) {
+    const first = offset;
+    const last = offset + chunk.Size - 1;
+    offset += chunk.Size;
+    if (last < start || first > end) continue;
+    parts.push({
+      path: dir + chunk.Name,
+      from: Math.max(start, first) - first,
+      to: Math.min(end, last) - first,
+      size: chunk.Size,
+    });
+  }
+  if (range) {
+    for (
+      const [name, value] of Object.entries(partialHeaders(range, file.size))
+    ) {
+      headers.set(name, value);
+    }
+  }
+  const length = file.size === 0 ? 0 : end - start + 1;
+  return new Response(sized(concatenate(config, parts), length), {
+    status: range ? 206 : 200,
     headers,
   });
 }
 
 /**
- * Gives the data of files of the remote, one after the other.
+ * Gives the data of files of the remote, one after the other: from the byte
+ * `from` to the byte `to` of each file. A part of a file is a range of the
+ * request. When the remote sends all the file, only the part goes out.
  * @param {Config} config
- * @param {string[]} paths
+ * @param {Array<{ path: string, from: number, to: number, size: number }>} parts
  * @returns {ReadableStream<Uint8Array>}
  */
-function concatenate(config, paths) {
+function concatenate(config, parts) {
   let index = 0;
   /** @type {ReadableStreamDefaultReader<Uint8Array> | null} */
   let reader = null;
@@ -707,15 +753,23 @@ function concatenate(config, paths) {
     async pull(controller) {
       while (true) {
         if (!reader) {
-          if (index === paths.length) {
+          if (index === parts.length) {
             controller.close();
             return;
           }
-          const response = await send(config, paths[index++]);
+          const { path, from, to, size } = parts[index++];
+          const whole = from === 0 && to === size - 1;
+          const response = await send(config, path, {
+            headers: whole ? {} : { Range: `bytes=${from}-${to}` },
+          });
           if (!response.ok || !response.body) {
             throw new Error(`chunker: chunk ${index} gave ${response.status}`);
           }
-          reader = response.body.getReader();
+          let body = response.body;
+          if (!whole && response.status !== 206) {
+            body = sliceStream(body, from, to - from + 1);
+          }
+          reader = body.getReader();
         }
         const { done, value } = await reader.read();
         if (done) {
diff --git a/backend/chunker/main_test.js b/backend/chunker/main_test.js
index fe98e67..e8eae64 100644
--- a/backend/chunker/main_test.js
+++ b/backend/chunker/main_test.js
@@ -185,4 +185,55 @@ describe("chunker", () => {
     assert.equal((await custom.list(""))[0].Size, 2049);
     await custom.delete("a.bin");
   });
+
+  test("reads only the chunks of a range", async () => {
+    /** The chunk and the `Range` of each GET of a chunk. */
+    const reads = [];
+    const counted = remote(backend, {
+      params: { remote: root, chunk_size: "1k" },
+      env: {
+        REMOTE: {
+          fetch(input, init = {}) {
+            const name = decodeURIComponent(
+              input.slice(input.lastIndexOf("/") + 1),
+            );
+            if (/_chunk\.\d+$/.test(name) && (init.method ?? "GET") === "GET") {
+              reads.push([name, new Headers(init.headers).get("Range")]);
+            }
+            return fetch(input, init);
+          },
+        },
+      },
+    });
+    const data = content(3000);
+    await counted.put("range.bin", data);
+
+    for (
+      const [header, start, end, expected] of [
+        // In the second chunk only.
+        ["bytes=1500-1600", 1500, 1600, [["002", "bytes=476-576"]]],
+        // The end of the first chunk and all the second chunk.
+        ["bytes=1000-2047", 1000, 2047, [["001", "bytes=1000-1023"], [
+          "002",
+          null,
+        ]]],
+        ["bytes=-1", 2999, 2999, [["003", "bytes=951-951"]]],
+      ]
+    ) {
+      reads.length = 0;
+      const response = await counted.get("range.bin", { Range: header });
+      assert.equal(response.status, 206, header);
+      assert.deepEqual(
+        new Uint8Array(await response.arrayBuffer()),
+        data.subarray(start, end + 1),
+        header,
+      );
+      assert.deepEqual(
+        reads,
+        expected.map(([n, range]) => [`range.bin.rclone_chunk.${n}`, range]),
+        header,
+      );
+    }
+    await counted.delete("range.bin");
+  });
 });
diff --git a/backend/http/main.js b/backend/http/main.js
index 2f24604..0698902 100644
--- a/backend/http/main.js
+++ b/backend/http/main.js
@@ -47,7 +47,13 @@ export const options = {
 const SECRETS = ["headers"];
 
 /** The headers of a file that go to the client. */
-const FILE_HEADERS = ["Content-Type", "Content-Length", "Last-Modified"];
+const FILE_HEADERS = [
+  "Content-Type",
+  "Content-Length",
+  "Last-Modified",
+  "Accept-Ranges",
+  "Content-Range",
+];
 
 /** The status codes of a redirect. */
 const REDIRECTS = [301, 302, 303, 307, 308];
@@ -110,7 +116,7 @@ async function http(request) {
   const target = new URL(encodePath(path).slice(1), base);
   try {
     if (!path.endsWith("/")) {
-      return await getFile(target, method, headers, path);
+      return await getFile(target, method, headers, path, request);
     }
     const noHead = searchParams.get("no_head") === "true";
     const query = new URLSearchParams(searchParams);
@@ -145,18 +151,31 @@ function parseHeaders(text) {
 }
 
 /**
- * Gets a file, or only its headers for HEAD.
+ * Gets a file, or only its headers for HEAD. The server gets the `Range` of
+ * the request, and the client gets the answer 206 or 416 of the server.
  * @param {URL} url
  * @param {string} method
  * @param {Headers} headers
  * @param {string} path
+ * @param {Request} request
  * @returns {Promise<Response>}
  */
-async function getFile(url, method, headers, path) {
-  const response = await send(url, method, headers);
+async function getFile(url, method, headers, path, request) {
+  const range = request.headers.get("Range");
+  const response = await send(
+    url,
+    method,
+    headers,
+    method === "GET" && range !== null ? { Range: range } : {},
+  );
   if (!response.ok) {
     await response.body?.cancel();
-    return new Response(null, { status: response.status });
+    const result = new Headers();
+    const contentRange = response.headers.get("Content-Range");
+    if (response.status === 416 && contentRange) {
+      result.set("Content-Range", contentRange);
+    }
+    return new Response(null, { status: response.status, headers: result });
   }
 
   const result = new Headers();
@@ -172,7 +191,10 @@ async function getFile(url, method, headers, path) {
     await response.body?.cancel();
     return new Response(null, { headers: result });
   }
-  return new Response(response.body, { headers: result });
+  return new Response(response.body, {
+    status: response.status,
+    headers: result,
+  });
 }
 
 /**
@@ -351,18 +373,23 @@ function isEncoded(response) {
  * too, as that host chose them.
  * @param {URL} url
  * @param {string} method GET or HEAD.
- * @param {Headers} headers
+ * @param {Headers} headers The headers of the headers option.
+ * @param {Record<string, string>} [others] Other headers, for example
+ *   `Range`, which go to each server.
  * @returns {Promise<Response>}
  * @throws {HTTPError} When the server does not answer, or when a redirect is
  *   not permitted.
  */
-async function send(url, method, headers) {
+async function send(url, method, headers, others = {}) {
   const names = [...headers.keys()];
   const init = {
     method,
     headers: new Headers(headers),
     redirect: names.length > 0 ? "manual" : "follow",
   };
+  for (const [name, value] of Object.entries(others)) {
+    init.headers.set(name, value);
+  }
   // The size of the file is the size of the body that the client gets.
   if (!init.headers.has("Accept-Encoding")) {
     init.headers.set("Accept-Encoding", "identity");
diff --git a/backend/local/main.js b/backend/local/main.js
index 4f05bda..bf9d2e2 100644
--- a/backend/local/main.js
+++ b/backend/local/main.js
@@ -4,6 +4,7 @@ import { formatBytes } from "../../lib/format.js";
 import { escapeHTML } from "../../lib/html.js";
 import { mimeType } from "../../lib/mime.js";
 import { decodePath } from "../../lib/path.js";
+import { notSatisfiable, parseRange, partialHeaders } from "../../lib/range.js";
 
 /**
  * Serves a local remote: the files and the folders in the current folder.
@@ -123,19 +124,43 @@ async function local(request) {
     } else {
       headers.append("Content-Type", mimeType(path));
       headers.append("Content-Length", stats.size.toString());
+      headers.set("Accept-Ranges", "bytes");
 
       if (method === "GET") {
+        let range;
+        try {
+          range = parseRange(request.headers.get("Range"), stats.size);
+        } catch {
+          return notSatisfiable(stats.size);
+        }
+        if (range) {
+          status = 206;
+          for (
+            const [name, value] of Object.entries(
+              partialHeaders(range, stats.size),
+            )
+          ) {
+            headers.set(name, value);
+          }
+        }
+        // The position of the next byte, and the number of bytes to read.
+        let position = range?.start ?? 0;
+        let remaining = range ? range.end - range.start + 1 : stats.size;
         const file = await open(absolutePath);
 
         body = new ReadableStream({
           async pull(controller) {
-            const chunk = new Uint8Array(64 * 1024);
-            const { bytesRead } = await file.read(chunk, 0);
+            const chunk = new Uint8Array(Math.min(64 * 1024, remaining));
+            const { bytesRead } = remaining > 0
+              ? await file.read(chunk, 0, chunk.length, position)
+              : { bytesRead: 0 };
             if (bytesRead === 0) {
               controller.close();
               await file.close();
               return;
             }
+            position += bytesRead;
+            remaining -= bytesRead;
             controller.enqueue(chunk.subarray(0, bytesRead));
           },
           async cancel() {
diff --git a/backend/memory/main.js b/backend/memory/main.js
index dac68f1..bbfdfb6 100644
--- a/backend/memory/main.js
+++ b/backend/memory/main.js
@@ -10,6 +10,7 @@
 import { renderListing } from "../../lib/listing.js";
 import { mimeType } from "../../lib/mime.js";
 import { decodePath } from "../../lib/path.js";
+import { notSatisfiable, parseRange, partialHeaders } from "../../lib/range.js";
 
 /**
  * The files and the folders, by their path with no percent-encoding. The path
@@ -47,9 +48,27 @@ async function memory(request) {
       headers.set("Content-Type", file.type || mimeType(path));
       headers.set("Content-Length", `${file.size}`);
       headers.set("Last-Modified", new Date(file.lastModified).toUTCString());
+      headers.set("Accept-Ranges", "bytes");
       // A Blob has a size, thus a Worker sends its Content-Length.
       if (method === "GET") {
+        let range;
+        try {
+          range = parseRange(request.headers.get("Range"), file.size);
+        } catch {
+          return notSatisfiable(file.size);
+        }
         body = file;
+        if (range) {
+          status = 206;
+          for (
+            const [name, value] of Object.entries(
+              partialHeaders(range, file.size),
+            )
+          ) {
+            headers.set(name, value);
+          }
+          body = file.slice(range.start, range.end + 1);
+        }
       }
     } else {
       headers.set("Content-Type", "text/html;charset=utf-8");
diff --git a/lib/testing/suite.js b/lib/testing/suite.js
index 818c994..e5637cc 100644
--- a/lib/testing/suite.js
+++ b/lib/testing/suite.js
@@ -183,6 +183,61 @@ export function backendSuite(
         }
       });
 
+      it("gives a range of a file", async () => {
+        const { path, content } = file2;
+        const size = content.length;
+        for (
+          const [header, start, end] of [
+            ["bytes=0-0", 0, 0],
+            ["bytes=0-99", 0, 99],
+            // The ends of the blocks and of the chunks of 64 KiB.
+            ["bytes=65535-65536", 65535, 65536],
+            ["bytes=65536-131071", 65536, 131071],
+            ["bytes=100-", 100, size - 1],
+            [`bytes=${size - 1}-`, size - 1, size - 1],
+            ["bytes=-1", size - 1, size - 1],
+            ["bytes=-70000", size - 70000, size - 1],
+            ["bytes=-999999", 0, size - 1],
+            ["bytes=150000-999999", 150000, size - 1],
+          ]
+        ) {
+          const response = await fs.get(path, { Range: header });
+          assert.equal(response.status, 206, header);
+          assert.equal(
+            response.headers.get("Content-Range"),
+            `bytes ${start}-${end}/${size}`,
+            header,
+          );
+          assert.equal(
+            response.headers.get("Content-Length"),
+            `${end - start + 1}`,
+            header,
+          );
+          const bytes = new Uint8Array(await response.arrayBuffer());
+          assert.ok(
+            Buffer.from(bytes).equals(content.subarray(start, end + 1)),
+            `the bytes of the range ${header}`,
+          );
+        }
+      });
+
+      it("gives 416 for a range with no byte of the file", async () => {
+        const size = file2.content.length;
+        const response = await fs.get(file2.path, { Range: `bytes=${size}-` });
+        await response.body?.cancel();
+        assert.equal(response.status, 416);
+        assert.equal(response.headers.get("Content-Range"), `bytes */${size}`);
+      });
+
+      it("gives all the file for a range that it does not read", async () => {
+        for (const header of ["bytes=5-1", "bytes=0-1,5-6", "items=0-1"]) {
+          const response = await fs.get(file1.path, { Range: header });
+          assert.equal(response.status, 200, header);
+          const bytes = new Uint8Array(await response.arrayBuffer());
+          assert.ok(Buffer.from(bytes).equals(file1.content), header);
+        }
+      });
+
       it("gives the headers and no body for HEAD", async () => {
         for (const { path, content } of files) {
           const response = await fs.head(path);
@@ -281,6 +336,7 @@ export function backendSuite(
     const { headers } = response;
     assert.equal(headers.get("Content-Type"), mimeType(path), what);
     assert.equal(headers.get("Content-Length"), `${content.length}`, what);
+    assert.equal(headers.get("Accept-Ranges"), "bytes", what);
     const lastModified = Date.parse(headers.get("Last-Modified"));
     assertTime(lastModified, start, end, `Last-Modified of ${what}`);
 

From efa8d8eac6fc6e6a580d7308224bbdb6f2d76195 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sat, 17 Oct 2026 04:04:44 +0000
Subject: [PATCH 39/87] feat(crypt): ranges with the seek of rclone

A range of a crypt file reads only the header of the encrypted file and the blocks of the range, as the seek of rclone. The header gives the nonce and the size. DecryptionStream has the options nonce and block: the nonce of the header goes up by the number of the block, as nonce.add of rclone. When the remote sends all the file, crypt decrypts all of it and gives the range only.

The tests check the requests to the remote for a range, a remote that does not read ranges, and the nonce for each number. With rclone, rclone cat --offset --count reads ranges of crypt and chunker files through the http backend of rclone.
---
 backend/crypt/main.js           | 145 +++++++++++++++++++++++++++++++-
 backend/crypt/main_test.js      |  72 ++++++++++++++++
 backend/crypt/secretbox.js      |  29 ++++++-
 backend/crypt/secretbox_test.js |  47 +++++++++++
 backend/http/rclone_test.js     | 105 +++++++++++++++++++++++
 5 files changed, 394 insertions(+), 4 deletions(-)

diff --git a/backend/crypt/main.js b/backend/crypt/main.js
index eff96c1..621b5b6 100644
--- a/backend/crypt/main.js
+++ b/backend/crypt/main.js
@@ -98,6 +98,12 @@ import { HTMLRewriter } from "@sntran/html-rewriter";
 import { formatBytes } from "../../lib/format.js";
 import { mimeType } from "../../lib/mime.js";
 import { decodePath } from "../../lib/path.js";
+import {
+  notSatisfiable,
+  parseRange,
+  partialHeaders,
+  sliceStream,
+} from "../../lib/range.js";
 import { sized } from "../../lib/streams/sized.js";
 import { reveal } from "../../cmd/obscure/main.js";
 import PathCipher from "./PathCipher.js";
@@ -106,6 +112,7 @@ import {
   DecryptionStream,
   encryptedSize,
   EncryptionStream,
+  Errors,
 } from "./secretbox.js";
 
 const encoder = new TextEncoder();
@@ -190,6 +197,11 @@ async function crypt(request, env = {}) {
   const headers = new Headers(request.headers);
   headers.delete("Range");
 
+  const range = request.headers.get("Range");
+  if (method === "GET" && !isDirectory && range !== null) {
+    return await getRange(fetcher, target, headers, cipher, path, range);
+  }
+
   if (method === "GET" || method === "HEAD") {
     const response = await fetcher.fetch(target, { method, headers });
     if (!response.ok) {
@@ -199,7 +211,10 @@ async function crypt(request, env = {}) {
       return listing(response, cipher, searchParams);
     }
 
-    const result = new Headers({ "Content-Type": mimeType(path) });
+    const result = new Headers({
+      "Content-Type": mimeType(path),
+      "Accept-Ranges": "bytes",
+    });
     const size = sizeOf(response.headers.get("Content-Length"));
     if (size >= 0) {
       result.set("Content-Length", `${size}`);
@@ -264,6 +279,134 @@ async function crypt(request, env = {}) {
   });
 }
 
+/**
+ * Gets a range of a file, as the seek of rclone: the header of the
+ * encrypted file gives its nonce and its size, then only the blocks of the
+ * range are read and decrypted. When the remote sends all the file for a
+ * range, all the file is decrypted, and the answer has the range only.
+ * @param {{ fetch: typeof fetch }} fetcher The remote.
+ * @param {string} target The encrypted path on the remote.
+ * @param {Headers} headers The headers of the request, with no `Range`.
+ * @param {{ dataKey: Uint8Array }} cipher
+ * @param {string} path The path of the file.
+ * @param {string} header The `Range` of the request.
+ * @returns {Promise<Response>}
+ */
+async function getRange(fetcher, target, headers, cipher, path, header) {
+  const { magic, blockSize } = SECRETBOX_OPTIONS;
+  const headerSize = magic.length + 24;
+  const blockLength = blockSize + 16;
+
+  const init = { headers: new Headers(headers) };
+  init.headers.set("Range", `bytes=0-${headerSize - 1}`);
+  const first = await fetcher.fetch(target, init);
+  if (first.status === 416) {
+    // The encrypted file is shorter than its header.
+    return new Response(Errors.TOO_SHORT, { status: 500 });
+  }
+  if (!first.ok) {
+    return first;
+  }
+
+  // The size of the encrypted file.
+  const total = first.status === 206
+    ? first.headers.get("Content-Range")?.match(/\/(\d+)$/)?.[1] ?? null
+    : first.headers.get("Content-Length");
+  const size = sizeOf(total);
+  if (size < 0) {
+    await first.body?.cancel();
+    return new Response("The size of the encrypted file is not correct", {
+      status: 500,
+    });
+  }
+
+  let range;
+  try {
+    range = parseRange(header, size);
+  } catch {
+    await first.body?.cancel();
+    return notSatisfiable(size);
+  }
+
+  const result = new Headers({
+    "Content-Type": mimeType(path),
+    "Accept-Ranges": "bytes",
+  });
+  const lastModified = first.headers.get("Last-Modified");
+  if (lastModified) result.set("Last-Modified", lastModified);
+  const decrypt = (options) =>
+    new DecryptionStream(cipher.dataKey, { ...SECRETBOX_OPTIONS, ...options });
+
+  if (first.status !== 206) {
+    // The remote sent all the file.
+    let body = first.body.pipeThrough(decrypt());
+    let length = size;
+    if (range) {
+      length = range.end - range.start + 1;
+      body = sliceStream(body, range.start, length);
+      for (const [name, value] of Object.entries(partialHeaders(range, size))) {
+        result.set(name, value);
+      }
+    } else {
+      result.set("Content-Length", `${size}`);
+    }
+    return new Response(sized(body, length), {
+      status: range ? 206 : 200,
+      headers: result,
+    });
+  }
+
+  const bytes = new Uint8Array(await first.arrayBuffer());
+  if (
+    bytes.length < headerSize ||
+    magic.some((byte, index) => bytes[index] !== byte)
+  ) {
+    return new Response(Errors.BAD_MAGIC, { status: 500 });
+  }
+  const nonce = bytes.slice(magic.length, headerSize);
+  const { start, end } = range ?? { start: 0, end: size - 1 };
+  const length = size === 0 ? 0 : end - start + 1;
+  if (length === 0) {
+    result.set("Content-Length", "0");
+    return new Response(null, { headers: result });
+  }
+
+  // The blocks of the range.
+  const block = Math.floor(start / blockSize);
+  const lastBlock = Math.floor(end / blockSize);
+  const from = headerSize + block * blockLength;
+  const to = Math.min(
+    headerSize + (lastBlock + 1) * blockLength,
+    Number(total),
+  ) - 1;
+  init.headers.set("Range", `bytes=${from}-${to}`);
+  const second = await fetcher.fetch(target, init);
+  if (!second.ok) {
+    await second.body?.cancel();
+    return new Response(null, { status: 502 });
+  }
+  // A remote that sends all the file sends the blocks before the range too.
+  let data = second.body;
+  if (second.status !== 206) data = sliceStream(data, from, to - from + 1);
+  const body = sliceStream(
+    data.pipeThrough(decrypt({ nonce, block })),
+    start - block * blockSize,
+    length,
+  );
+
+  if (range) {
+    for (const [name, value] of Object.entries(partialHeaders(range, size))) {
+      result.set(name, value);
+    }
+  } else {
+    result.set("Content-Length", `${size}`);
+  }
+  return new Response(sized(body, length), {
+    status: range ? 206 : 200,
+    headers: result,
+  });
+}
+
 /**
  * Gives the list of a folder with the names, the sizes and the types of the
  * files, from the list of the encrypted folder on the remote.
diff --git a/backend/crypt/main_test.js b/backend/crypt/main_test.js
index 5cd0fae..3382b01 100644
--- a/backend/crypt/main_test.js
+++ b/backend/crypt/main_test.js
@@ -200,4 +200,76 @@ describe("crypt", () => {
     const response = await fs.get("plain2.txt");
     await assert.rejects(response.arrayBuffer(), /bad magic/);
   });
+
+  /** A file of 3 blocks and a part of a block. */
+  const content = new Uint8Array(3 * 65536 + 100).map((_, i) => i * 7 + 1);
+
+  test("reads only the header and the blocks of a range", async () => {
+    /** The `Range` of each request to the remote. */
+    const ranges = [];
+    const counted = remote(crypt, {
+      params,
+      env: {
+        REMOTE: {
+          fetch(input, init = {}) {
+            ranges.push(new Headers(init.headers).get("Range"));
+            return fetch(input, init);
+          },
+        },
+      },
+    });
+    await counted.put("blocks.bin", content);
+
+    ranges.length = 0;
+    const response = await counted.get("blocks.bin", {
+      Range: "bytes=65536-65536",
+    });
+    assert.equal(response.status, 206);
+    assert.deepEqual(
+      new Uint8Array(await response.arrayBuffer()),
+      content.subarray(65536, 65537),
+    );
+    // The header is 32 bytes, and a block is 65536 + 16 bytes.
+    assert.deepEqual(ranges, ["bytes=0-31", "bytes=65584-131135"]);
+
+    ranges.length = 0;
+    const last = await counted.get("blocks.bin", { Range: "bytes=-1" });
+    assert.deepEqual(
+      new Uint8Array(await last.arrayBuffer()),
+      content.subarray(-1),
+    );
+    const size = 32 + 3 * 65552 + 116;
+    assert.deepEqual(ranges, ["bytes=0-31", `bytes=196688-${size - 1}`]);
+  });
+
+  test("gives a range when the remote sends all the file", async () => {
+    // A remote that does not read the ranges.
+    const full = remote(crypt, {
+      params,
+      env: {
+        REMOTE: {
+          fetch(input, init = {}) {
+            const headers = new Headers(init.headers);
+            headers.delete("Range");
+            return fetch(input, { ...init, headers });
+          },
+        },
+      },
+    });
+    await full.put("full.bin", content);
+    for (
+      const [header, start, end] of [["bytes=70000-140000", 70000, 140000]]
+    ) {
+      const response = await full.get("full.bin", { Range: header });
+      assert.equal(response.status, 206);
+      assert.equal(
+        response.headers.get("Content-Range"),
+        `bytes ${start}-${end}/${content.length}`,
+      );
+      assert.deepEqual(
+        new Uint8Array(await response.arrayBuffer()),
+        content.subarray(start, end + 1),
+      );
+    }
+  });
 });
diff --git a/backend/crypt/secretbox.js b/backend/crypt/secretbox.js
index dcc8f7d..a19927f 100644
--- a/backend/crypt/secretbox.js
+++ b/backend/crypt/secretbox.js
@@ -69,8 +69,13 @@ export class DecryptionStream extends TransformStream {
   /**
    * Creates a new decryption stream. It reads the header and the blocks from
    * chunks of any size. An error of the stream has a message of `Errors`.
+   *
+   * With the option `nonce`, the stream reads blocks with no header, from the
+   * block `block` of the file: the nonce of the header goes up by `block`, as
+   * `newDecrypterSeek` of rclone. Thus a range of a file needs only its
+   * header and its blocks in the range.
    * @param {Uint8Array} key
-   * @param {Options} [options]
+   * @param {Options & { nonce?: Uint8Array, block?: number }} [options]
    */
   constructor(key, options = {}) {
     const { magic = DEFAULT_MAGIC, blockSize = DEFAULT_BLOCK_SIZE } = options;
@@ -78,7 +83,9 @@ export class DecryptionStream extends TransformStream {
     const blockLength = blockSize + TAG_SIZE;
 
     /** @type {Uint8Array | null} */
-    let nonce = null;
+    let nonce = options.nonce
+      ? add(options.nonce.slice(), options.block ?? 0)
+      : null;
     /** The data that is not a full header or block yet. */
     let pending = new Uint8Array(0);
 
@@ -190,11 +197,27 @@ function concat(a, b) {
   return result;
 }
 
+/**
+ * Adds a number to the nonce, in place, as `nonce.add` of rclone: the first
+ * byte is the lowest.
+ * @param {Uint8Array} nonce
+ * @param {number} number
+ */
+export function add(nonce, number) {
+  let carry = BigInt(number);
+  for (let offset = 0; offset < nonce.length && carry > 0n; offset++) {
+    const sum = BigInt(nonce[offset]) + (carry & 0xffn);
+    nonce[offset] = Number(sum & 0xffn);
+    carry = (carry >> 8n) + (sum >> 8n);
+  }
+  return nonce;
+}
+
 /**
  * Adds 1 to the nonce, in place: the first byte is the lowest.
  * @param {Uint8Array} nonce
  */
-function increment(nonce) {
+export function increment(nonce) {
   for (let offset = 0; offset < nonce.length; offset++) {
     nonce[offset] = (nonce[offset] + 1) & 0xff;
     // No carry when the byte is not 0 after the addition.
diff --git a/backend/crypt/secretbox_test.js b/backend/crypt/secretbox_test.js
index 66e65b6..876cab9 100644
--- a/backend/crypt/secretbox_test.js
+++ b/backend/crypt/secretbox_test.js
@@ -3,11 +3,13 @@ import assert from "node:assert/strict";
 import fc from "fast-check";
 
 import {
+  add,
   decryptedSize,
   DecryptionStream,
   encryptedSize,
   EncryptionStream,
   Errors,
+  increment,
 } from "./secretbox.js";
 
 /** The options of rclone crypt. */
@@ -268,3 +270,48 @@ test("decrypts what it encrypts, at the size of the blocks of rclone", async ()
     );
   }
 });
+
+test("adds a number to a nonce as the same number of increments", () => {
+  // Bytes of 0xff make carries into the next bytes.
+  const byte = fc.oneof(fc.constant(0xff), fc.integer({ min: 0, max: 255 }));
+  fc.assert(
+    fc.property(
+      fc.array(byte, { minLength: 24, maxLength: 24 }),
+      fc.nat(700),
+      (bytes, number) => {
+        const expected = Uint8Array.from(bytes);
+        for (let index = 0; index < number; index++) increment(expected);
+        assert.deepEqual(add(Uint8Array.from(bytes), number), expected);
+      },
+    ),
+  );
+  // A carry out of the last byte goes away, as in rclone.
+  assert.deepEqual(add(new Uint8Array(24).fill(0xff), 1), new Uint8Array(24));
+});
+
+test("decrypts the blocks of a file from any block", async () => {
+  await fc.assert(
+    fc.asyncProperty(
+      fc.uint8Array({ minLength: 32, maxLength: 32 }),
+      fc.integer({ min: 1, max: 16 }),
+      fc.uint8Array({ maxLength: 300 }),
+      fc.nat(),
+      async (key, blockSize, content, choice) => {
+        const options = { magic: RCLONE.magic, blockSize };
+        const encrypted = await through(
+          [content],
+          new EncryptionStream(key, options),
+        );
+        const headerSize = RCLONE.magic.length + 24;
+        const nonce = encrypted.slice(RCLONE.magic.length, headerSize);
+        const blocks = Math.ceil(content.length / blockSize);
+        const block = blocks ? choice % blocks : 0;
+        const decrypted = await through(
+          [encrypted.subarray(headerSize + block * (blockSize + 16))],
+          new DecryptionStream(key, { ...options, nonce, block }),
+        );
+        assert.deepEqual(decrypted, content.subarray(block * blockSize));
+      },
+    ),
+  );
+});
diff --git a/backend/http/rclone_test.js b/backend/http/rclone_test.js
index be70eac..a598e9f 100644
--- a/backend/http/rclone_test.js
+++ b/backend/http/rclone_test.js
@@ -13,6 +13,9 @@ import process from "node:process";
 
 import { remote } from "../../lib/testing/remote.js";
 import { listen } from "../../lib/testing/server.js";
+import { fetch } from "../../mod.js";
+import chunker from "../chunker/main.js";
+import crypt from "../crypt/main.js";
 import memory from "../memory/main.js";
 import http from "./main.js";
 
@@ -161,3 +164,105 @@ describe("http and rclone", {
     assert.deepEqual(normalize(await walk(url)), expected);
   });
 });
+
+describe("rclone reads ranges of rfetch", {
+  skip: !hasRclone && "rclone is not installed. Set RCLONE to its path.",
+}, () => {
+  const folder = mkdtempSync(join(tmpdir(), "rfetch-range-"));
+  /** The backends under the server, with their options. */
+  const BACKENDS = {
+    crypt: [crypt, {
+      remote: ":memory:/rclone-range-crypt",
+      // "test-password", obscured by rclone.
+      password: "4OSlj-ZYMGdEIGjcWg_gc-DL4O3TFAvr4ct_yV4",
+    }],
+    chunker: [chunker, {
+      remote: ":memory:/rclone-range-chunker",
+      chunk_size: "64k",
+    }],
+  };
+  const env = { REMOTE: { fetch } };
+  const data = content(3 * 65536 + 1000);
+  let server;
+
+  before(async () => {
+    server = await listen((request) => {
+      const url = new URL(request.url);
+      const [, name] = url.pathname.split("/");
+      const [backend, params] = BACKENDS[name];
+      url.pathname = url.pathname.slice(name.length + 1);
+      for (const [key, value] of Object.entries(params)) {
+        url.searchParams.set(key, value);
+      }
+      return backend.fetch(new Request(url, request), env);
+    });
+    for (const [backend, params] of Object.values(BACKENDS)) {
+      const response = await remote(backend, { params, env }).put(
+        "data.bin",
+        data,
+      );
+      assert.equal(response.status, 201);
+    }
+  });
+  after(async () => {
+    await server?.close();
+    rmSync(folder, { recursive: true, force: true });
+  });
+
+  /**
+   * The output of `rclone cat` for a range of a file of the server.
+   * @param {string} url
+   * @param {number} offset
+   * @param {number} count
+   */
+  function cat(url, offset, count) {
+    return new Promise((resolve, reject) => {
+      const child = spawn(
+        RCLONE,
+        [
+          "cat",
+          "--http-url",
+          url,
+          ":http:data.bin",
+          "--offset",
+          `${offset}`,
+          "--count",
+          `${count}`,
+        ],
+        { env: { PATH: process.env.PATH, HOME: folder } },
+      );
+      const chunks = [];
+      let stderr = "";
+      child.stdout.on("data", (chunk) => chunks.push(chunk));
+      child.stderr.on("data", (chunk) => stderr += chunk);
+      child.on("error", reject);
+      child.on("close", (status) => {
+        if (status === 0) resolve(new Uint8Array(Buffer.concat(chunks)));
+        else reject(new Error(`rclone cat ${url}: ${stderr}`));
+      });
+    });
+  }
+
+  for (const name of Object.keys(BACKENDS)) {
+    test(`${name}: rclone cat --offset --count gives the bytes`, async () => {
+      const url = `${server.url}${name}/`;
+      for (
+        const [offset, count] of [
+          [0, 1],
+          [65535, 2],
+          [65536, 65536],
+          [100000, 70000],
+          [data.length - 1, 1],
+          [70000, -1],
+        ]
+      ) {
+        const end = count < 0 ? data.length : offset + count;
+        assert.deepEqual(
+          await cat(url, offset, count),
+          data.subarray(offset, end),
+          `${name} --offset ${offset} --count ${count}`,
+        );
+      }
+    });
+  }
+});

From 95c941d515f3ab20cb1b2907824029f6e0f59531 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sat, 17 Oct 2026 04:08:23 +0000
Subject: [PATCH 40/87] fix(lib): write times as rclone lsjson

toLocaleISOString writes a time in the format 2006-01-02T15:04:05.000Z07:00 of Go, the format of rclone lsjson for a remote with a precision of 1 ms: Z for UTC, else +hh:mm or -hh:mm, and always 3 digits for the milliseconds.

Before, an offset of 10 hours or more had 3 digits, a negative offset with minutes, for example -09:30, had a wrong hour, and a time with 0 ms had no milliseconds.
---
 lib/time.js      | 37 +++++++++++++++++++++----------------
 lib/time_test.js | 28 ++++++++++++++++++++++++++++
 2 files changed, 49 insertions(+), 16 deletions(-)
 create mode 100644 lib/time_test.js

diff --git a/lib/time.js b/lib/time.js
index 80320bb..a64c67b 100644
--- a/lib/time.js
+++ b/lib/time.js
@@ -1,20 +1,25 @@
 /**
- * Converts a date string to a locale ISO string.
- * @param {string | null} value
- * @returns {string}
+ * Writes a time as the ModTime of `rclone lsjson` for a remote with a
+ * precision of 1 ms: the format `2006-01-02T15:04:05.000Z07:00` of Go, in the
+ * local time zone. The time zone is `Z` for UTC, else `+hh:mm` or `-hh:mm`.
+ * @param {string | number | Date | null | undefined} value
+ * @param {number} [offset] The minutes after UTC of the time zone. By
+ *   default, the offset of the local time zone at that time.
+ * @returns {string | undefined} No string for no time, or for a time that is
+ *   not correct.
  */
-export function toLocaleISOString(value) {
-  if (!value) return undefined;
+export function toLocaleISOString(value, offset) {
+  if (value === null || value === undefined || value === "") return undefined;
+  const date = new Date(value);
+  if (isNaN(date.getTime())) return undefined;
 
-  let date = new Date(value);
-  const off = date.getTimezoneOffset() * -1;
-  const del = date.getMilliseconds() ? "Z" : "."; // have milliseconds ?
-  date = new Date(date.getTime() + off * 60000); // add or subtract time zone
-  return date
-    .toISOString()
-    .split(del)[0] +
-    (off < 0 ? "-" : "+") +
-    ("0" + Math.abs(Math.floor(off / 60))).substring(-2) +
-    ":" +
-    ("0" + Math.abs(off % 60)).substring(-2);
+  offset ??= -date.getTimezoneOffset();
+  const local = new Date(date.getTime() + offset * 60000).toISOString()
+    .slice(0, -1);
+  if (offset === 0) return `${local}Z`;
+  const minutes = Math.abs(offset);
+  const pad = (number) => String(number).padStart(2, "0");
+  return `${local}${offset < 0 ? "-" : "+"}${pad(Math.floor(minutes / 60))}:${
+    pad(minutes % 60)
+  }`;
 }
diff --git a/lib/time_test.js b/lib/time_test.js
new file mode 100644
index 0000000..b6ade4d
--- /dev/null
+++ b/lib/time_test.js
@@ -0,0 +1,28 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+
+import { toLocaleISOString } from "./time.js";
+
+test("toLocaleISOString writes the times of rclone lsjson", () => {
+  const time = "2026-10-17T03:56:05.819Z";
+  for (
+    const [offset, expected] of [
+      [0, "2026-10-17T03:56:05.819Z"],
+      [60, "2026-10-17T04:56:05.819+01:00"],
+      [-300, "2026-10-16T22:56:05.819-05:00"],
+      [330, "2026-10-17T09:26:05.819+05:30"],
+      [-570, "2026-10-16T18:26:05.819-09:30"],
+      [840, "2026-10-17T17:56:05.819+14:00"],
+    ]
+  ) {
+    assert.equal(toLocaleISOString(time, offset), expected, `${offset}`);
+  }
+  // The milliseconds stay, also when they are zero.
+  assert.equal(
+    toLocaleISOString("2026-10-17T03:56:05Z", 0),
+    "2026-10-17T03:56:05.000Z",
+  );
+  for (const value of [null, undefined, "", "not a time"]) {
+    assert.equal(toLocaleISOString(value), undefined);
+  }
+});

From 475c3d50b88b7fbdb69ef0bac3e46f950dcad0a3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sat, 17 Oct 2026 04:08:23 +0000
Subject: [PATCH 41/87] fix(local): cut the times of files to the millisecond

The mtime of Node.js is rounded to the nearest millisecond, but Go cuts a time. Thus the time of a file in a list and in Last-Modified was 1 ms after the time of rclone for half of the files. Now the local backend uses mtimeMs, cut to the millisecond.
---
 backend/local/main.js | 18 +++++++++++++++---
 1 file changed, 15 insertions(+), 3 deletions(-)

diff --git a/backend/local/main.js b/backend/local/main.js
index bf9d2e2..fb6ef5c 100644
--- a/backend/local/main.js
+++ b/backend/local/main.js
@@ -87,7 +87,8 @@ async function local(request) {
                 isDirectory ? "/" : ""
               }`;
 
-              const { size, mtime } = await stat(join(absolutePath, name));
+              const { size, mtimeMs } = await stat(join(absolutePath, name));
+              const mtime = timeOf(mtimeMs);
 
               controller.enqueue(`<tr>
                 <td>${isDirectory ? "📁" : "📄"}</td>
@@ -170,8 +171,9 @@ async function local(request) {
       }
     }
 
-    const mtime = stats.mtime?.toUTCString();
-    if (mtime) headers.append("Last-Modified", mtime);
+    if (stats.mtimeMs !== undefined) {
+      headers.append("Last-Modified", timeOf(stats.mtimeMs).toUTCString());
+    }
   } else if (method === "PUT") {
     // Folder ending with trailing slash.
     if (path.endsWith("/")) {
@@ -223,6 +225,16 @@ function isOutside(root, path) {
   return rest === ".." || rest.startsWith(`..${sep}`) || isAbsolute(rest);
 }
 
+/**
+ * The time of a file to the millisecond. As in Go, the time is cut, not
+ * rounded: the `mtime` of Node.js is rounded to the nearest millisecond.
+ * @param {number} mtimeMs
+ * @returns {Date}
+ */
+function timeOf(mtimeMs) {
+  return new Date(Math.floor(mtimeMs));
+}
+
 export default {
   fetch: local,
 };

From 55bd7c72e6a1dad83e7a73a00520d8714f83811c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sat, 17 Oct 2026 04:08:23 +0000
Subject: [PATCH 42/87] fix(lsjson): names with ? and # with --recursive, and
 connection strings

lsjson --recursive put the name of a folder in the next path with no percent-encoding. Thus a "?" in the name started a query, and a "#" a fragment, and the files in the folder were not in the list. Now the name has percent-encoding.

lsjson also split all the location at each "/", also in a value of a connection string, for example :crypt,remote='a/b':path. Now it reads the location with lib/fspath.js, and only the path has folders. The name of a file to list has no percent-encoding, as a backend reads it. A location with an empty path, for example remote:, is a folder.

With rclone, a test compares lsjson --recursive with rclone lsjson -R on a local folder with hard names: the paths, the names, the sizes, the types and the times are the same.
---
 cmd/lsjson/main.js        | 38 ++++++++++++++++----
 cmd/lsjson/main_test.js   | 66 ++++++++++++++++++++++++++++++++++
 cmd/lsjson/rclone_test.js | 74 +++++++++++++++++++++++++++++++++++++++
 3 files changed, 172 insertions(+), 6 deletions(-)
 create mode 100644 cmd/lsjson/rclone_test.js

diff --git a/cmd/lsjson/main.js b/cmd/lsjson/main.js
index 894fe78..f29f35a 100644
--- a/cmd/lsjson/main.js
+++ b/cmd/lsjson/main.js
@@ -1,5 +1,6 @@
 import { basename } from "node:path";
 import { HTMLRewriter } from "@sntran/html-rewriter";
+import { parse } from "../../lib/fspath.js";
 import { toLocaleISOString } from "../../lib/time.js";
 
 import { fetch } from "../../mod.js";
@@ -55,16 +56,23 @@ const decoder = new TextDecoder();
  * @returns {Promise<Response>}
  */
 export async function lsjson(location, flags = {}) {
-  const isDirectory = location.endsWith("/");
+  // Only the path in the remote has folders: a value of the connection
+  // string can have a "/" too, for example `:crypt,remote='a/b':path`.
+  const parsed = parse(location);
+  const prefix = location.slice(0, location.length - parsed.path.length);
+  const path = parsed.path;
+  const isDirectory = path === "" || path.endsWith("/");
   const init = { method: "GET" };
-  const segments = location.split("/");
+  let folder = path;
   let filename;
-  // If file, remove the last segment to query the parent directory.
+  // If file, list the parent directory and keep only the file.
   if (!isDirectory) {
-    filename = segments.pop();
+    const slash = path.lastIndexOf("/") + 1;
+    folder = path.slice(0, slash);
+    filename = nameOf(path.slice(slash));
   }
   const params = new URLSearchParams(flags);
-  const url = `${segments.join("/")}?${params}`;
+  const url = `${prefix}${folder}?${params}`;
   let response = await fetch(url, init);
 
   if (!response.ok) {
@@ -176,7 +184,10 @@ export async function lsjson(location, flags = {}) {
               // Inside, we await for the `done` promise to be resolved
               // before enqueueing the next item.
               const promise = (async () => {
-                const response = await lsjson(`${location}${name}/`, {
+                // The name of the folder in the path has percent-encoding,
+                // else a "?" or a "#" in the name starts a query.
+                const child = `${location}${encodeURIComponent(name)}/`;
+                const response = await lsjson(child, {
                   ...flags,
                   max_depth: String(maxDepth - 1),
                 });
@@ -279,3 +290,18 @@ function concat(a, b) {
   result.set(b, a.byteLength);
   return result;
 }
+
+/**
+ * The name of a file in the path of a location, as a backend reads it: with
+ * no percent-encoding.
+ * @param {string} segment For example `a%20b.txt` or `a b.txt`.
+ * @returns {string}
+ */
+function nameOf(segment) {
+  const { pathname } = new URL(segment, "file:///");
+  try {
+    return decodeURIComponent(pathname.slice(1));
+  } catch {
+    return pathname.slice(1);
+  }
+}
diff --git a/cmd/lsjson/main_test.js b/cmd/lsjson/main_test.js
index 878db8a..81065c6 100644
--- a/cmd/lsjson/main_test.js
+++ b/cmd/lsjson/main_test.js
@@ -146,3 +146,69 @@ test("lsjson gives the names with no percent-encoding", async () => {
     { Name: name, Path: name },
   ]);
 });
+
+/** Puts the files, with percent-encoding in each name of each path. */
+async function putAll(location, paths) {
+  for (const path of paths) {
+    const encoded = path.split("/").map(encodeURIComponent).join("/");
+    const response = await fetch(`${location}${encoded}`, {
+      method: "PUT",
+      headers: { "Content-Length": `${encoder.encode(path).byteLength}` },
+      body: path,
+    });
+    assert.equal(response.status, 201, path);
+  }
+}
+
+/** The paths of the entries of `lsjson --recursive`, in order. */
+async function walk(location) {
+  const result = await lsjson(location, { recursive: "true" })
+    .then((response) => response.json());
+  return result.map(({ Path, IsDir, Size }) => ({ Path, IsDir, Size }))
+    .sort((a, b) => a.Path < b.Path ? -1 : +(a.Path > b.Path));
+}
+
+/** Folders and files with names that have "?", "#", "%" and spaces. */
+const HARD = ["a?b/c#d/e%f.txt", "a?b/g h.txt", "i%20j/k?.txt", "l#/m"];
+
+/** The entries of the files of HARD and of their folders. */
+function entries(paths) {
+  const all = new Map();
+  for (const path of paths) {
+    const names = path.split("/");
+    for (let i = 1; i < names.length; i++) {
+      const folder = names.slice(0, i).join("/");
+      all.set(folder, { Path: folder, IsDir: true, Size: -1 });
+    }
+    all.set(path, {
+      Path: path,
+      IsDir: false,
+      Size: encoder.encode(path).length,
+    });
+  }
+  return [...all.values()].sort((a, b) =>
+    a.Path < b.Path ? -1 : +(a.Path > b.Path)
+  );
+}
+
+test("lsjson --recursive keeps the names with ? and # in folders", async () => {
+  await putAll(":memory:/recursive/", HARD);
+  assert.deepEqual(await walk(":memory:/recursive/"), entries(HARD));
+});
+
+test("lsjson lists one file with a hard name", async () => {
+  const result = await lsjson(
+    `:memory:/recursive/a%3Fb/${encodeURIComponent("g h.txt")}`,
+  )
+    .then((response) => response.json());
+  assert.deepEqual(result.map(({ Name }) => Name), ["g h.txt"]);
+});
+
+test("lsjson reads a connection string with a / in a value", async () => {
+  // "test-password", obscured by rclone.
+  const password = "4OSlj-ZYMGdEIGjcWg_gc-DL4O3TFAvr4ct_yV4";
+  const location =
+    `:crypt,remote=':memory:/lsjson/crypt',password=${password}:`;
+  await putAll(location, HARD);
+  assert.deepEqual(await walk(location), entries(HARD));
+});
diff --git a/cmd/lsjson/rclone_test.js b/cmd/lsjson/rclone_test.js
new file mode 100644
index 0000000..8401015
--- /dev/null
+++ b/cmd/lsjson/rclone_test.js
@@ -0,0 +1,74 @@
+/**
+ * The tests of lsjson against rclone lsjson, on the same local folder. The
+ * tests run when rclone is in the PATH, or when RCLONE is the path of rclone.
+ */
+import { after, before, describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import process from "node:process";
+
+import { lsjson } from "./main.js";
+
+const RCLONE = process.env.RCLONE || "rclone";
+const hasRclone = spawnSync(RCLONE, ["version"]).status === 0;
+
+/** The files, with names that have "?", "#", "%", spaces and Unicode. */
+const FILES = [
+  "a?b/c#d/e%f.txt",
+  "a?b/g h.json",
+  "i%20j/k?.html",
+  "l#/m",
+  "n o/ê é/Hello, 世界.bin",
+  "p.txt",
+];
+
+describe("lsjson and rclone lsjson", {
+  skip: !hasRclone && "rclone is not installed. Set RCLONE to its path.",
+}, () => {
+  const folder = mkdtempSync(join(tmpdir(), "rfetch-lsjson-"));
+  const cwd = process.cwd();
+
+  before(() => {
+    for (const [index, path] of FILES.entries()) {
+      mkdirSync(dirname(join(folder, "tree", path)), { recursive: true });
+      writeFileSync(join(folder, "tree", path), "x".repeat(index * 10));
+    }
+    // The local backend serves the current folder.
+    process.chdir(folder);
+  });
+  after(() => {
+    process.chdir(cwd);
+    rmSync(folder, { recursive: true, force: true });
+  });
+
+  /** The fields to compare, in the order of the paths. */
+  function normalize(entries) {
+    return entries
+      .map(({ Path, Name, Size, IsDir, MimeType, ModTime }) => ({
+        Path,
+        Name,
+        // rclone gives the size of a local folder on the disk.
+        Size: IsDir ? -1 : Size,
+        IsDir,
+        MimeType,
+        // rclone has nanoseconds, and the lists of rfetch milliseconds.
+        ModTime: IsDir ? 0 : Math.floor(Date.parse(ModTime)),
+      }))
+      .sort((a, b) => a.Path < b.Path ? -1 : +(a.Path > b.Path));
+  }
+
+  test("lsjson --recursive gives the entries of rclone lsjson -R", async () => {
+    const { status, stdout, stderr } = spawnSync(
+      RCLONE,
+      ["lsjson", "-R", join(folder, "tree")],
+      { env: { PATH: process.env.PATH, HOME: folder } },
+    );
+    assert.equal(status, 0, `${stderr}`);
+    const actual = await lsjson("/tree/", { recursive: "true" })
+      .then((response) => response.json());
+    assert.deepEqual(normalize(actual), normalize(JSON.parse(stdout)));
+  });
+});

From 2ed169785bc7777c464568a802a5bc85d829390d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sat, 17 Oct 2026 04:29:58 +0000
Subject: [PATCH 43/87] feat(lib): read and write the XML of S3

parseXML reads an answer of S3 to a tree of elements. escapeXML writes a text in XML, with the carriage return as &#13;, because XML changes a raw carriage return to a line feed. isXMLText tells if XML 1.0 can have a text. The tests include property tests.
---
 lib/xml.js      | 121 ++++++++++++++++++++++++++++++++++++++++++++++++
 lib/xml_test.js |  58 +++++++++++++++++++++++
 2 files changed, 179 insertions(+)
 create mode 100644 lib/xml.js
 create mode 100644 lib/xml_test.js

diff --git a/lib/xml.js b/lib/xml.js
new file mode 100644
index 0000000..3886da7
--- /dev/null
+++ b/lib/xml.js
@@ -0,0 +1,121 @@
+/**
+ * A small reader of XML, for the answers of APIs such as S3: elements, text,
+ * CDATA and the entities. It does not read a DTD, and it does not keep the
+ * attributes. A name has no namespace prefix: `s3:Key` is `Key`.
+ */
+
+/**
+ * An element of an XML document.
+ * @typedef {Object} XMLElement
+ * @property {string} name The name with no namespace prefix.
+ * @property {XMLElement[]} children The elements in the element.
+ * @property {string} text The text in the element, with no text of the
+ *   elements in it.
+ */
+
+const TOKENS =
+  /<!--[\s\S]*?-->|<\?[\s\S]*?\?>|<!\[CDATA\[([\s\S]*?)\]\]>|<!DOCTYPE[^>]*>|<(\/?)([^\s/>]+)[^>]*?(\/?)>|([^<]+)/g;
+
+const ENTITIES = { amp: "&", lt: "<", gt: ">", quot: '"', apos: "'" };
+
+/**
+ * Reads an XML document.
+ * @param {string} text
+ * @returns {XMLElement} The root element.
+ * @throws {SyntaxError} When the elements do not close in order.
+ */
+export function parseXML(text) {
+  /** @type {XMLElement} */
+  const document = { name: "", children: [], text: "" };
+  const stack = [document];
+  for (const match of text.matchAll(TOKENS)) {
+    const [, cdata, close, name, empty, chars] = match;
+    const top = stack.at(-1);
+    if (cdata !== undefined) {
+      top.text += cdata;
+    } else if (chars !== undefined) {
+      top.text += decodeEntities(chars);
+    } else if (name !== undefined) {
+      const local = name.slice(name.indexOf(":") + 1);
+      if (close) {
+        if (stack.length === 1 || top.name !== local) {
+          throw new SyntaxError(`unexpected </${name}>`);
+        }
+        stack.pop();
+      } else {
+        const element = { name: local, children: [], text: "" };
+        top.children.push(element);
+        if (!empty) stack.push(element);
+      }
+    }
+  }
+  if (stack.length !== 1 || document.children.length !== 1) {
+    throw new SyntaxError("not one root element");
+  }
+  return document.children[0];
+}
+
+/**
+ * The elements with a name in an element.
+ * @param {XMLElement | undefined} element
+ * @param {string} name
+ * @returns {XMLElement[]}
+ */
+export function childrenOf(element, name) {
+  return element?.children.filter((child) => child.name === name) ?? [];
+}
+
+/**
+ * The text of the first element with a name in an element, or "".
+ * @param {XMLElement | undefined} element
+ * @param {string} name
+ * @returns {string}
+ */
+export function textOf(element, name) {
+  return childrenOf(element, name)[0]?.text ?? "";
+}
+
+/**
+ * Tells if XML 1.0 can have a text: it cannot have the control characters
+ * other than tab and line breaks, also as a character reference.
+ * @param {string} text
+ * @returns {boolean}
+ */
+export function isXMLText(text) {
+  return !/[\0-\x08\x0b\x0c\x0e-\x1f\ufffe\uffff]|[\ud800-\udbff](?![\udc00-\udfff])|(?<![\ud800-\udbff])[\udc00-\udfff]/
+    .test(text);
+}
+
+/**
+ * Puts the escapes of XML in a text, for an element. A carriage return is
+ * `&#13;`, else XML reads it as a line feed.
+ * @param {string} text
+ * @returns {string}
+ */
+export function escapeXML(text) {
+  return text.replace(
+    /[&<>"'\r]/g,
+    (c) =>
+      ({
+        "&": "&amp;",
+        "<": "&lt;",
+        ">": "&gt;",
+        '"': "&quot;",
+        "'": "&apos;",
+        "\r": "&#13;",
+      })[c],
+  );
+}
+
+/** @param {string} text */
+function decodeEntities(text) {
+  return text.replace(/&(#x[0-9a-f]+|#\d+|[a-z]+);/gi, (entity, body) => {
+    if (body[0] === "#") {
+      const code = body[1] === "x" || body[1] === "X"
+        ? parseInt(body.slice(2), 16)
+        : parseInt(body.slice(1), 10);
+      return code <= 0x10ffff ? String.fromCodePoint(code) : entity;
+    }
+    return ENTITIES[body] ?? entity;
+  });
+}
diff --git a/lib/xml_test.js b/lib/xml_test.js
new file mode 100644
index 0000000..b385018
--- /dev/null
+++ b/lib/xml_test.js
@@ -0,0 +1,58 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import fc from "fast-check";
+
+import { childrenOf, escapeXML, isXMLText, parseXML, textOf } from "./xml.js";
+
+test("parseXML reads an answer of S3", () => {
+  const root = parseXML(`<?xml version="1.0" encoding="UTF-8"?>
+<ListBucketResult xmlns="http://s3.amazonaws.com/doc/2006-03-01/">
+  <Name>bucket</Name>
+  <IsTruncated>false</IsTruncated>
+  <Contents><Key>a &amp; b &lt;c&gt; &#233;&#x4E16;</Key><Size>10</Size></Contents>
+  <Contents><Key><![CDATA[<raw>]]></Key><Size>0</Size></Contents>
+  <CommonPrefixes><Prefix>d/</Prefix></CommonPrefixes>
+  <!-- a comment -->
+  <Empty/>
+</ListBucketResult>`);
+  assert.equal(root.name, "ListBucketResult");
+  assert.equal(textOf(root, "Name"), "bucket");
+  assert.deepEqual(
+    childrenOf(root, "Contents").map((
+      c,
+    ) => [textOf(c, "Key"), textOf(c, "Size")]),
+    [["a & b <c> é世", "10"], ["<raw>", "0"]],
+  );
+  assert.equal(textOf(childrenOf(root, "CommonPrefixes")[0], "Prefix"), "d/");
+  assert.equal(childrenOf(root, "Empty").length, 1);
+  assert.equal(textOf(root, "Missing"), "");
+});
+
+test("parseXML reads the names with a namespace prefix", () => {
+  const root = parseXML("<s3:Error><s3:Code>NoSuchKey</s3:Code></s3:Error>");
+  assert.equal(root.name, "Error");
+  assert.equal(textOf(root, "Code"), "NoSuchKey");
+});
+
+test("parseXML refuses elements that do not close in order", () => {
+  for (const text of ["<a><b></a>", "<a>", "</a>", "<a/><b/>", "text"]) {
+    assert.throws(() => parseXML(text), SyntaxError, text);
+  }
+});
+
+test("parseXML reads the text that escapeXML writes", () => {
+  fc.assert(
+    fc.property(fc.string(), (text) => {
+      // XML 1.0 has no control characters other than tab and line breaks.
+      fc.pre(isXMLText(text));
+      assert.equal(parseXML(`<a>${escapeXML(text)}</a>`).text, text);
+    }),
+  );
+});
+
+test("isXMLText refuses the characters that XML 1.0 cannot have", () => {
+  for (const text of ["a", "\t\n\r", "é世😀"]) assert.ok(isXMLText(text), text);
+  for (const text of ["\0", "\v", "\x1f", "\ud800", "a\udc00", "\uffff"]) {
+    assert.ok(!isXMLText(text), JSON.stringify(text));
+  }
+});

From fcaeb617bcf1d650a4e17e11d6d8ac3970d661ea Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sat, 17 Oct 2026 04:29:58 +0000
Subject: [PATCH 44/87] feat(s3): sign requests with the Signature Version 4 of
 AWS

sign adds the header Authorization from the method, the path, the query, the headers and the hash of the body. The body can be UNSIGNED-PAYLOAD. uriEncode puts the percent-encoding of AWS. The tests use the examples of the documentation of Amazon S3.
---
 backend/s3/sigv4.js      | 107 +++++++++++++++++++++++++++++++++++++++
 backend/s3/sigv4_test.js | 105 ++++++++++++++++++++++++++++++++++++++
 2 files changed, 212 insertions(+)
 create mode 100644 backend/s3/sigv4.js
 create mode 100644 backend/s3/sigv4_test.js

diff --git a/backend/s3/sigv4.js b/backend/s3/sigv4.js
new file mode 100644
index 0000000..d1ed5d4
--- /dev/null
+++ b/backend/s3/sigv4.js
@@ -0,0 +1,107 @@
+/**
+ * The Signature Version 4 of AWS for S3: the header `Authorization` of a
+ * request, from the method, the path, the query, the headers and the hash of
+ * the body.
+ */
+import { createHash, createHmac } from "node:crypto";
+
+/** The hash of a body that the signature does not cover. */
+export const UNSIGNED_PAYLOAD = "UNSIGNED-PAYLOAD";
+
+/** The hash of an empty body. */
+export const EMPTY_PAYLOAD =
+  "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855";
+
+/**
+ * Puts the percent-encoding of AWS in a text: all the bytes except
+ * `A-Z a-z 0-9 - . _ ~`, and also `/` when `slash` is false.
+ * @param {string} text
+ * @param {boolean} [slash] True to keep `/`, for a path.
+ * @returns {string}
+ */
+export function uriEncode(text, slash = false) {
+  const encoded = encodeURIComponent(text).replace(
+    /[!'()*]/g,
+    (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`,
+  );
+  return slash ? encoded.replaceAll("%2F", "/") : encoded;
+}
+
+/**
+ * Signs a request.
+ * @param {Object} request
+ * @param {string} request.method
+ * @param {URL} request.url The path of the URL has the percent-encoding of
+ *   `uriEncode`. The query is any.
+ * @param {Headers} request.headers The headers to sign. They get
+ *   `x-amz-date`, `x-amz-content-sha256`, `x-amz-security-token` for a
+ *   session token, and `Authorization`.
+ * @param {string} [request.payload] The SHA-256 of the body in hexadecimal,
+ *   or `UNSIGNED-PAYLOAD`.
+ * @param {Object} credentials
+ * @param {string} credentials.accessKeyId
+ * @param {string} credentials.secretAccessKey
+ * @param {string} [credentials.sessionToken]
+ * @param {string} credentials.region
+ * @param {string} [credentials.service]
+ * @param {Date} [now]
+ * @returns {Headers} The headers of the request.
+ */
+export function sign(
+  { method, url, headers, payload = EMPTY_PAYLOAD },
+  { accessKeyId, secretAccessKey, sessionToken, region, service = "s3" },
+  now = new Date(),
+) {
+  const amzDate = now.toISOString().replace(/[-:]|\.\d{3}/g, "");
+  const date = amzDate.slice(0, 8);
+  headers = new Headers(headers);
+  headers.set("host", url.host);
+  headers.set("x-amz-date", amzDate);
+  headers.set("x-amz-content-sha256", payload);
+  if (sessionToken) headers.set("x-amz-security-token", sessionToken);
+
+  // The query, sorted by the names and the values, with the encoding of AWS.
+  const query = [...url.searchParams]
+    .map(([name, value]) => [uriEncode(name), uriEncode(value)])
+    .sort(([a, x], [b, y]) => a < b ? -1 : a > b ? 1 : x < y ? -1 : +(x > y))
+    .map(([name, value]) => `${name}=${value}`)
+    .join("&");
+  const names = [...headers.keys()].sort();
+  const canonical = [
+    method,
+    url.pathname,
+    query,
+    ...names.map((name) =>
+      `${name}:${headers.get(name).trim().replace(/\s+/g, " ")}`
+    ),
+    "",
+    names.join(";"),
+    payload,
+  ].join("\n");
+
+  const scope = `${date}/${region}/${service}/aws4_request`;
+  const toSign = [
+    "AWS4-HMAC-SHA256",
+    amzDate,
+    scope,
+    createHash("sha256").update(canonical).digest("hex"),
+  ].join("\n");
+
+  let key = hmac(`AWS4${secretAccessKey}`, date);
+  for (const part of [region, service, "aws4_request"]) key = hmac(key, part);
+  const signature = createHmac("sha256", key).update(toSign).digest("hex");
+
+  headers.set(
+    "Authorization",
+    `AWS4-HMAC-SHA256 Credential=${accessKeyId}/${scope}, ` +
+      `SignedHeaders=${names.join(";")}, Signature=${signature}`,
+  );
+  // The host of the URL goes in the request.
+  headers.delete("host");
+  return headers;
+}
+
+/** @param {string | Buffer} key @param {string} data */
+function hmac(key, data) {
+  return createHmac("sha256", key).update(data).digest();
+}
diff --git a/backend/s3/sigv4_test.js b/backend/s3/sigv4_test.js
new file mode 100644
index 0000000..f20c2ba
--- /dev/null
+++ b/backend/s3/sigv4_test.js
@@ -0,0 +1,105 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+
+import { sign, uriEncode } from "./sigv4.js";
+
+/**
+ * The examples of "Signature Calculations for the Authorization Header" in
+ * the documentation of Amazon S3: the key, the date, and the signatures.
+ */
+const CREDENTIALS = {
+  accessKeyId: "AKIAIOSFODNN7EXAMPLE",
+  secretAccessKey: "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
+  region: "us-east-1",
+};
+const NOW = new Date("2013-05-24T00:00:00Z");
+
+/** @param {Headers} headers */
+function signatureOf(headers) {
+  return headers.get("Authorization").match(/Signature=([0-9a-f]+)$/)[1];
+}
+
+test("signs the GET of an object with a range", () => {
+  const headers = sign(
+    {
+      method: "GET",
+      url: new URL("https://examplebucket.s3.amazonaws.com/test.txt"),
+      headers: new Headers({ Range: "bytes=0-9" }),
+    },
+    CREDENTIALS,
+    NOW,
+  );
+  assert.equal(
+    headers.get("Authorization"),
+    "AWS4-HMAC-SHA256 Credential=AKIAIOSFODNN7EXAMPLE/20130524/us-east-1/s3/aws4_request, " +
+      "SignedHeaders=host;range;x-amz-content-sha256;x-amz-date, " +
+      "Signature=f0e8bdb87c964420e857bd35b5d6ed310bd44f0170aba48dd91039c6036bdb41",
+  );
+});
+
+test("signs the PUT of an object", () => {
+  const headers = sign(
+    {
+      method: "PUT",
+      url: new URL(
+        `https://examplebucket.s3.amazonaws.com/${
+          uriEncode("test$file.text", true)
+        }`,
+      ),
+      headers: new Headers({
+        Date: "Fri, 24 May 2013 00:00:00 GMT",
+        "x-amz-storage-class": "REDUCED_REDUNDANCY",
+      }),
+      payload:
+        "44ce7dd67c959e0d3524ffac1771dfbba87d2b6b4b4e99e42034a8b803f8b072",
+    },
+    CREDENTIALS,
+    NOW,
+  );
+  assert.equal(
+    signatureOf(headers),
+    "98ad721746da40c64f1a55b78f14c238d841ea1380cd77a1b5971af0ece108bd",
+  );
+});
+
+test("signs a list with a query", () => {
+  const headers = sign(
+    {
+      method: "GET",
+      url: new URL(
+        "https://examplebucket.s3.amazonaws.com/?max-keys=2&prefix=J",
+      ),
+      headers: new Headers(),
+    },
+    CREDENTIALS,
+    NOW,
+  );
+  assert.equal(
+    signatureOf(headers),
+    "34b48302e7b5fa45bde8084f4b7868a86f0a534bc59db6670ed5711ef69dc6f7",
+  );
+});
+
+test("signs a query with a name and no value", () => {
+  const headers = sign(
+    {
+      method: "GET",
+      url: new URL("https://examplebucket.s3.amazonaws.com/?lifecycle"),
+      headers: new Headers(),
+    },
+    CREDENTIALS,
+    NOW,
+  );
+  assert.equal(
+    signatureOf(headers),
+    "fea454ca298b7da1c68078a5d1bdbfbbe0d65c699e0f91ac7a200a0136783543",
+  );
+});
+
+test("uriEncode keeps only the bytes that AWS keeps", () => {
+  assert.equal(uriEncode("a-z_A.Z~0 9"), "a-z_A.Z~0%209");
+  assert.equal(uriEncode("!'()*"), "%21%27%28%29%2A");
+  assert.equal(uriEncode("a/b c", true), "a/b%20c");
+  assert.equal(uriEncode("a/b"), "a%2Fb");
+  assert.equal(uriEncode("é+&="), "%C3%A9%2B%26%3D");
+});

From 8a3613cc12c254f70c1af6569c9927d790431955 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sat, 17 Oct 2026 04:29:58 +0000
Subject: [PATCH 45/87] test(lib): suite options for buckets and for no empty
 folders

parent is the folder of the folder of the tests, for example a bucket. With emptyFolders false, a folder with no file can give 404, as CanHaveEmptyDirectories of rclone. It is for s3 with no folder markers.
---
 CONTRIBUTING.md      |  7 ++++++-
 lib/testing/suite.js | 28 ++++++++++++++++++++++++++--
 2 files changed, 32 insertions(+), 3 deletions(-)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 4a82f8d..56b86b0 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -158,13 +158,18 @@ and deletes it at the end. It tests:
 - `PUT` over a file, `DELETE` of a file, and `DELETE` of a folder with all that
   is in it.
 
-Two other options are for some backends only:
+Other options are for some backends only:
 
 - `skipName`: the suite skips the names that match this regular expression. Use
   it only for a limit that the backend has in rclone too. For example, rclone
   cannot read the name of a chunk with a line break.
 - `writer`: for a read only backend, for example `http`, the `PUT` and `DELETE`
   requests go to this backend, and the backend under test reads the files.
+- `parent`: the folder of the folder of the tests, `/` by default. For example,
+  the tests of `s3` are in the bucket `/rfetch/`.
+- `emptyFolders`: `false` for a backend that cannot have an empty folder, as
+  `CanHaveEmptyDirectories` of rclone. For example, `s3` with no folder markers.
+  Then the suite accepts 404 for a folder with no file.
 
 Put the tests for what only one backend does in the same file, after the suite.
 For example, the tests of the local backend make sure that a path cannot go out
diff --git a/lib/testing/suite.js b/lib/testing/suite.js
index e5637cc..21d06c1 100644
--- a/lib/testing/suite.js
+++ b/lib/testing/suite.js
@@ -53,24 +53,47 @@ const FILE2 = `hello? sausage/êé/Hello, 世界/ " ' @ < > & ? + ≠/z.txt`;
  *   env?: object,
  *   skipName?: RegExp,
  *   writer?: { fetch: (request: Request) => Response | Promise<Response> },
+ *   parent?: string,
+ *   emptyFolders?: boolean,
  * }} [options] `params` go in the query of each request, for example the
  *   options of the backend. `env` is the env of the backend, for example
  *   `REMOTE`. The tests skip the names that match `skipName`,
  *   for a limit that the backend has in rclone too. For a backend that is
  *   read only, the PUT and DELETE requests go to `writer`, with no `params`:
  *   a backend that writes the files that the backend under test reads.
+ *   `parent` is the folder of the folder of the tests, for example the
+ *   bucket `/bucket/` of s3. `emptyFolders` is false for a backend that
+ *   cannot have an empty folder, as `CanHaveEmptyDirectories` of rclone:
+ *   for example s3 with no folder markers. Then a folder with no file
+ *   gives 404, as a folder that does not exist.
  */
 export function backendSuite(
   name,
   backend,
-  { params = {}, env = {}, skipName, writer } = {},
+  {
+    params = {},
+    env = {},
+    skipName,
+    writer,
+    parent = "/",
+    emptyFolders = true,
+  } = {},
 ) {
-  const root = `/rfetch-test-${randomBytes(6).toString("hex")}/`;
+  const root = `${parent}rfetch-test-${randomBytes(6).toString("hex")}/`;
   const fs = remote(backend, { params, root, env });
   if (writer) {
     const { put, delete: remove } = remote(writer, { root });
     Object.assign(fs, { put, delete: remove });
   }
+  if (!emptyFolders) {
+    // A folder with no file is a folder that does not exist.
+    const { list } = fs;
+    fs.list = (path) =>
+      list(path).catch((error) => {
+        if (/ gave 404$/.test(error.message)) return [];
+        throw error;
+      });
+  }
 
   describe(`backend ${name}`, () => {
     after(async () => {
@@ -85,6 +108,7 @@ export function backendSuite(
 
     it("makes a folder with PUT", async () => {
       await put("", new Uint8Array(0));
+      if (!emptyFolders) return;
 
       const response = await fs.get("");
       assert.equal(response.status, 200);

From 8b2f7e40296b18c12f009c57236a2f6215ce2b01 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sat, 17 Oct 2026 04:30:07 +0000
Subject: [PATCH 46/87] feat(s3): the s3 backend

The backend s3 is for Amazon S3 and the services with the same API, for example Cloudflare R2. It lists the buckets and the folders, reads files and ranges, puts files in one PUT or in parts, and deletes files and folders. The options are as the options of rclone, from the query or from the variables RCLONE_S3_*. The links of a list have no credentials.

As rclone, a folder exists only when it has a file. With directory_markers, the PUT of a folder or of a file puts the markers of the folder and of its parent folders.

The tests run the shared suite on rclone serve s3, and compare the files with rclone in the two directions. When S3_TEST_ENDPOINT and S3_TEST_BUCKET are set, the suite also runs on a real service.
---
 CONTRIBUTING.md           |   7 +
 README.md                 |   2 +
 backend/main.js           |   1 +
 backend/s3/main.js        | 901 ++++++++++++++++++++++++++++++++++++++
 backend/s3/main_test.js   | 191 ++++++++
 backend/s3/rclone_test.js | 131 ++++++
 backend/s3/testing.js     |  60 +++
 7 files changed, 1293 insertions(+)
 create mode 100644 backend/s3/main.js
 create mode 100644 backend/s3/main_test.js
 create mode 100644 backend/s3/rclone_test.js
 create mode 100644 backend/s3/testing.js

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 56b86b0..3b7427b 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -184,6 +184,13 @@ the files `rclone_test.js` of the backends. They run when `rclone` is in the
 skipped. The tests of `lib/list.js` compare it with the `encoding/csv` package
 of Go, when `go` is in the `PATH` or when the variable `GO` is its path.
 
+The tests of `s3` use `rclone serve s3`, a server of the S3 API on a local
+folder. They also run on a real service when the variables `S3_TEST_ENDPOINT`
+and `S3_TEST_BUCKET` are set, with the region in `S3_TEST_REGION` (`auto` by
+default). Put the credentials in `RCLONE_S3_ACCESS_KEY_ID` and
+`RCLONE_S3_SECRET_ACCESS_KEY`. Use a bucket only for the tests: the tests make
+folders in it and delete them.
+
 ## Continuous integration
 
 The workflow `.github/workflows/ci.yml` runs for each push and each pull
diff --git a/README.md b/README.md
index 6cebbca..928ba6a 100644
--- a/README.md
+++ b/README.md
@@ -12,6 +12,8 @@ A [Rclone wrapper for WebAssembly build](./rclone.js) is also available.
 - HTTP [:page_facing_up:](https://rclone.org/http/)
 - The local filesystem [:page_facing_up:](https://rclone.org/local/)
 - Memory [:page_facing_up:](https://rclone.org/memory/)
+- S3: Amazon S3 and the services with the same API, for example Cloudflare R2
+  [:page_facing_up:](https://rclone.org/s3/)
 
 ### Virtual storage providers
 
diff --git a/backend/main.js b/backend/main.js
index eb1271d..90c1c45 100644
--- a/backend/main.js
+++ b/backend/main.js
@@ -26,3 +26,4 @@ export { default as drive } from "./drive/main.js";
 export { default as http } from "./http/main.js";
 export { default as local } from "./local/main.js";
 export { default as memory } from "./memory/main.js";
+export { default as s3 } from "./s3/main.js";
diff --git a/backend/s3/main.js b/backend/s3/main.js
new file mode 100644
index 0000000..73aaa89
--- /dev/null
+++ b/backend/s3/main.js
@@ -0,0 +1,901 @@
+/**
+ * Amazon S3 Backend
+ *
+ * The s3 backend reads and writes the objects of Amazon S3, and of the
+ * services that are compatible with S3, for example Cloudflare R2, MinIO and
+ * `rclone serve s3`, as the s3 backend of rclone.
+ *
+ * A path is `/bucket/path/to/file`. The path `/` is the list of the
+ * buckets, and `/bucket/` is the root of a bucket.
+ *
+ * The options, with the names of rclone:
+ *
+ * - `access_key_id`, `secret_access_key` and `session_token`: the
+ *   credentials. With no credentials, the requests have no signature. These
+ *   options are not in the links of a list, because they are secret.
+ * - `region`: `us-east-1` by default. For Cloudflare R2, `auto`.
+ * - `endpoint`: the URL of the service, by default the URL of Amazon S3 for
+ *   the region.
+ * - `force_path_style`: `true` by default, for the URL
+ *   `ENDPOINT/bucket/key`. With `false`, the URL is `bucket.ENDPOINT/key`.
+ * - `upload_cutoff`: 200 MiB by default. A file of a known size up to this
+ *   size goes in one PUT. A larger file, or a file of unknown size that is
+ *   larger than `chunk_size`, goes in parts.
+ * - `chunk_size`: 5 MiB by default, the size of a part.
+ * - `list_chunk`: 1000 by default, the number of objects of each list.
+ * - `list_url_encode`: `true` by default. The service puts the
+ *   percent-encoding in the names of a list, thus a name can have control
+ *   characters.
+ * - `directory_markers`: `false` by default, thus a folder exists only when
+ *   it has a file, as in rclone. With `true`, the PUT of a folder or of a
+ *   file puts a marker for the folder and for each parent folder that has
+ *   no marker. A marker is an empty object with the name of the folder and
+ *   a `/`, thus a folder can be empty.
+ *
+ * Each option can also come from `env`, with the name of the variable of
+ * rclone, for example `RCLONE_S3_SECRET_ACCESS_KEY`. In a Worker, put the
+ * credentials in `env`, not in a URL.
+ */
+import { createHash } from "node:crypto";
+import { renderListing } from "../../lib/listing.js";
+import { mimeType } from "../../lib/mime.js";
+import { decodePath } from "../../lib/path.js";
+import {
+  notSatisfiable,
+  parseRange,
+  partialHeaders,
+  sliceStream,
+} from "../../lib/range.js";
+import { parseSize } from "../../lib/size.js";
+import { sized } from "../../lib/streams/sized.js";
+import {
+  childrenOf,
+  escapeXML,
+  isXMLText,
+  parseXML,
+  textOf,
+} from "../../lib/xml.js";
+import { EMPTY_PAYLOAD, sign, UNSIGNED_PAYLOAD, uriEncode } from "./sigv4.js";
+
+export const options = {
+  string: [
+    "access_key_id",
+    "secret_access_key",
+    "session_token",
+    "region",
+    "endpoint",
+    "upload_cutoff",
+    "chunk_size",
+    "list_chunk",
+  ],
+  boolean: ["force_path_style", "list_url_encode", "directory_markers"],
+  default: {
+    region: "us-east-1",
+    upload_cutoff: "200Mi",
+    chunk_size: "5Mi",
+    list_chunk: "1000",
+    force_path_style: "true",
+    list_url_encode: "true",
+    directory_markers: "false",
+  },
+};
+
+/** The options that are secret. They are not in the links of a list. */
+const SECRETS = ["access_key_id", "secret_access_key", "session_token"];
+
+/** The largest number of parts of an upload in parts. */
+const MAX_PARTS = 10000;
+
+/** The smallest size of a part, but not of the last part. */
+const MIN_CHUNK_SIZE = 5 * 1024 * 1024;
+
+/**
+ * The options of a request.
+ * @typedef {Object} Config
+ * @property {URL} endpoint
+ * @property {boolean} pathStyle
+ * @property {{ accessKeyId: string, secretAccessKey: string,
+ *   sessionToken?: string, region: string } | null} credentials
+ * @property {number} uploadCutoff
+ * @property {number} chunkSize
+ * @property {number} listChunk
+ * @property {boolean} urlEncode
+ * @property {boolean} markers
+ */
+
+/** An error with the status of the answer. */
+class S3Error extends Error {
+  /** @param {string} message @param {number} status */
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+  }
+}
+
+/**
+ * Serves an S3 remote.
+ * @param {Request} request
+ * @param {Record<string, unknown>} [env] The options from the variables
+ *   `RCLONE_S3_*`.
+ * @returns {Promise<Response>}
+ */
+async function s3(request, env = {}) {
+  const { method } = request;
+  const { pathname, searchParams } = new URL(request.url);
+
+  let config;
+  try {
+    config = configOf(searchParams, env);
+  } catch (error) {
+    return new Response(error.message, { status: 400 });
+  }
+  const path = decodePath(pathname);
+  if (path === null) {
+    return new Response(null, { status: 400 });
+  }
+
+  const slash = path.indexOf("/", 1);
+  const bucket = slash === -1 ? path.slice(1) : path.slice(1, slash);
+  const key = slash === -1 ? "" : path.slice(slash + 1);
+  const isFolder = path.endsWith("/");
+  if (!isFolder && key === "") {
+    // A file is in a bucket.
+    return new Response(null, { status: method === "PUT" ? 400 : 404 });
+  }
+
+  try {
+    if (method === "GET" || method === "HEAD") {
+      if (!isFolder) return await getFile(config, bucket, key, request);
+      const query = new URLSearchParams(searchParams);
+      for (const name of SECRETS) query.delete(name);
+      return await getFolder(config, bucket, key, method, `${query}`);
+    }
+    if (method === "PUT") {
+      if (bucket === "") {
+        return new Response(null, { status: 405, headers: { Allow: "GET" } });
+      }
+      await (isFolder
+        ? putFolder(config, bucket, key)
+        : putFile(config, bucket, key, request));
+      return new Response(null, {
+        status: 201,
+        headers: { "Content-Location": pathname },
+      });
+    }
+    if (method === "DELETE") {
+      if (bucket === "") {
+        return new Response(null, { status: 405, headers: { Allow: "GET" } });
+      }
+      await (isFolder
+        ? deleteFolder(config, bucket, key)
+        : deleteFile(config, bucket, key));
+      return new Response(null, { status: 204 });
+    }
+  } catch (error) {
+    if (error instanceof S3Error) {
+      return new Response(error.message, { status: error.status });
+    }
+    throw error;
+  }
+  return new Response(null, {
+    status: 405,
+    headers: { Allow: "GET, HEAD, PUT, DELETE" },
+  });
+}
+
+/**
+ * Reads the options of a request, as `NewFs` of the s3 backend of rclone.
+ * @param {URLSearchParams} searchParams
+ * @param {Record<string, unknown>} env
+ * @returns {Config}
+ * @throws {Error} When an option is not correct.
+ */
+function configOf(searchParams, env) {
+  /** @param {string} name */
+  const get = (name) => {
+    const value = searchParams.get(name) ??
+      env[`RCLONE_S3_${name.toUpperCase()}`];
+    return typeof value === "string" ? value : options.default[name] ?? "";
+  };
+  const region = get("region") || "us-east-1";
+  let endpoint = get("endpoint") ||
+    `https://s3.${region}.amazonaws.com`;
+  if (!/^https?:\/\//i.test(endpoint)) endpoint = `https://${endpoint}`;
+  let url;
+  try {
+    url = new URL(endpoint);
+  } catch {
+    throw new Error("The endpoint is not a URL");
+  }
+
+  const accessKeyId = get("access_key_id");
+  const secretAccessKey = get("secret_access_key");
+  if (Boolean(accessKeyId) !== Boolean(secretAccessKey)) {
+    throw new Error("access_key_id and secret_access_key go together");
+  }
+  const sessionToken = get("session_token");
+
+  const chunkSize = parseSize(get("chunk_size"));
+  if (chunkSize < MIN_CHUNK_SIZE) {
+    throw new Error("chunk_size must be at least 5 MiB");
+  }
+  const listChunk = Number(get("list_chunk"));
+  if (!Number.isInteger(listChunk) || listChunk < 1) {
+    throw new Error("list_chunk must be a number of 1 or more");
+  }
+
+  return {
+    endpoint: url,
+    pathStyle: get("force_path_style") !== "false",
+    credentials: accessKeyId
+      ? { accessKeyId, secretAccessKey, sessionToken, region }
+      : null,
+    uploadCutoff: parseSize(get("upload_cutoff")),
+    chunkSize,
+    listChunk,
+    urlEncode: get("list_url_encode") !== "false",
+    markers: get("directory_markers") === "true",
+  };
+}
+
+/**
+ * Sends a request to S3, with the signature of the credentials.
+ * @param {Config} config
+ * @param {string} method
+ * @param {string} bucket "" for the service.
+ * @param {string} key "" for the bucket.
+ * @param {Object} [init]
+ * @param {Record<string, string>} [init.query]
+ * @param {Record<string, string>} [init.headers]
+ * @param {BodyInit | null} [init.body]
+ * @param {number} [init.length] The size of the body.
+ * @param {string} [init.payload] The SHA-256 of the body, else the body has
+ *   no signature.
+ * @returns {Promise<Response>}
+ * @throws {S3Error} When the service does not answer.
+ */
+async function send(
+  config,
+  method,
+  bucket,
+  key,
+  { query = {}, headers = {}, body = null, length, payload } = {},
+) {
+  const url = new URL(config.endpoint);
+  let path = url.pathname.replace(/\/$/, "");
+  if (bucket && !config.pathStyle) {
+    url.hostname = `${bucket}.${url.hostname}`;
+  } else if (bucket) {
+    path += `/${uriEncode(bucket)}`;
+  }
+  if (key) path += `/${uriEncode(key, true)}`;
+  url.pathname = path || "/";
+  // The query has the encoding of AWS, as the signature.
+  url.search = Object.entries(query)
+    .map(([name, value]) => `${uriEncode(name)}=${uriEncode(value)}`)
+    .join("&");
+
+  let signed = new Headers(headers);
+  if (config.credentials) {
+    signed = sign({
+      method,
+      url,
+      headers: signed,
+      payload: payload ?? (body === null ? EMPTY_PAYLOAD : UNSIGNED_PAYLOAD),
+    }, config.credentials);
+  }
+  if (length !== undefined) signed.set("Content-Length", `${length}`);
+  // The size of a file is the size of its body: a service such as R2 can
+  // compress a text file for a client that accepts gzip.
+  signed.set("Accept-Encoding", "identity");
+
+  /** @type {RequestInit} */
+  const init = { method, headers: signed };
+  if (body !== null) {
+    init.body = body;
+    if (body instanceof ReadableStream) init.duplex = "half";
+  }
+  try {
+    return await fetch(url, init);
+  } catch {
+    throw new S3Error("The S3 service did not answer", 502);
+  }
+}
+
+/**
+ * Makes sure that an answer of S3 is a success, else throws its error.
+ * @param {Response} response
+ * @returns {Promise<Response>}
+ * @throws {S3Error}
+ */
+async function check(response) {
+  if (response.ok) return response;
+  const text = await response.text();
+  let code = "";
+  try {
+    code = textOf(parseXML(text), "Code");
+  } catch {
+    // An answer with no XML, for example of HEAD.
+  }
+  throw new S3Error(code || response.statusText, response.status);
+}
+
+/**
+ * Reads a name of a list, as rclone: with no percent-encoding when the
+ * list has the encoding `url`. As `url.QueryUnescape` of Go, a `+` is a
+ * space.
+ * @param {string} name
+ * @param {boolean} encoded
+ * @returns {string | null} null for an encoding that is not correct.
+ */
+function nameOf(name, encoded) {
+  if (!encoded) return name;
+  try {
+    return decodeURIComponent(name.replaceAll("+", " "));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Gets a file, or only its headers for HEAD, with the range of the request.
+ *
+ * S3 gets a range that is correct, and its answer 206 goes to the client.
+ * When the service does not give a 206 with `Content-Range`, the backend
+ * makes the answer of RFC 9110 with the size of a HEAD request: some
+ * services, for example `rclone serve s3`, give the bytes of a range with
+ * 200.
+ * @param {Config} config
+ * @param {string} bucket
+ * @param {string} key
+ * @param {Request} request
+ * @returns {Promise<Response>}
+ */
+async function getFile(config, bucket, key, request) {
+  const { method } = request;
+  const header = method === "GET" ? request.headers.get("Range") : null;
+  let range = null;
+  try {
+    // Only the form of the range: the size is not known yet.
+    range = parseRange(header, Number.MAX_SAFE_INTEGER);
+  } catch {
+    // For example bytes=-0: no byte of a file is in the range.
+    return await getRange(config, bucket, key, header);
+  }
+  if (range) {
+    const response = await send(config, "GET", bucket, key, {
+      headers: { Range: header },
+    });
+    if (response.status === 206 && response.headers.has("Content-Range")) {
+      return fileResponse(response, key);
+    }
+    await response.body?.cancel();
+    if (response.ok || response.status === 416) {
+      return await getRange(config, bucket, key, header);
+    }
+    return new Response(null, { status: response.status });
+  }
+  const response = await send(config, method, bucket, key);
+  if (!response.ok) {
+    await response.body?.cancel();
+    return new Response(null, { status: response.status });
+  }
+  return fileResponse(response, key, method === "HEAD");
+}
+
+/**
+ * Gets a range of a file with the size of a HEAD request, as RFC 9110.
+ * @param {Config} config
+ * @param {string} bucket
+ * @param {string} key
+ * @param {string} header The `Range` of the request.
+ * @returns {Promise<Response>}
+ */
+async function getRange(config, bucket, key, header) {
+  const head = await send(config, "HEAD", bucket, key);
+  await head.body?.cancel();
+  if (!head.ok) return new Response(null, { status: head.status });
+  const size = Number(head.headers.get("Content-Length"));
+  let range;
+  try {
+    range = parseRange(header, size);
+  } catch {
+    return notSatisfiable(size);
+  }
+  if (!range) {
+    const response = await send(config, "GET", bucket, key);
+    if (!response.ok) {
+      await response.body?.cancel();
+      return new Response(null, { status: response.status });
+    }
+    return fileResponse(response, key);
+  }
+
+  const response = await send(config, "GET", bucket, key, {
+    headers: { Range: `bytes=${range.start}-${range.end}` },
+  });
+  if (!response.ok) {
+    await response.body?.cancel();
+    return new Response(null, { status: response.status });
+  }
+  const length = range.end - range.start + 1;
+  let body = response.body;
+  // A service that sends all the file sends the bytes before the range too.
+  if (
+    Number(response.headers.get("Content-Length")) === size && size !== length
+  ) {
+    body = sliceStream(body, range.start, length);
+  }
+  const result = fileHeaders(response, key);
+  for (const [name, value] of Object.entries(partialHeaders(range, size))) {
+    result.set(name, value);
+  }
+  return new Response(sized(body, length), { status: 206, headers: result });
+}
+
+/**
+ * The answer for a file, with the headers of the answer of S3.
+ * @param {Response} response
+ * @param {string} key
+ * @param {boolean} [head] True for no body.
+ * @returns {Response}
+ */
+function fileResponse(response, key, head = false) {
+  const headers = fileHeaders(response, key);
+  if (head) {
+    response.body?.cancel();
+    return new Response(null, { headers });
+  }
+  return new Response(response.body, { status: response.status, headers });
+}
+
+/**
+ * The headers of a file, from the answer of S3.
+ * @param {Response} response
+ * @param {string} key
+ * @returns {Headers}
+ */
+function fileHeaders(response, key) {
+  const headers = new Headers({
+    "Content-Type": response.headers.get("Content-Type") || mimeType(key),
+    "Accept-Ranges": "bytes",
+  });
+  for (const name of ["Content-Length", "Content-Range", "Last-Modified"]) {
+    const value = response.headers.get(name);
+    if (value) headers.set(name, value);
+  }
+  return headers;
+}
+
+/**
+ * Gets the list of a folder, or only its headers for HEAD.
+ * @param {Config} config
+ * @param {string} bucket "" for the list of the buckets.
+ * @param {string} prefix The path of the folder in the bucket, with a `/`
+ *   at the end, or "" for the root of the bucket.
+ * @param {string} method
+ * @param {string} query The query of each link.
+ * @returns {Promise<Response>}
+ */
+async function getFolder(config, bucket, prefix, method, query) {
+  const entries = bucket === ""
+    ? await listBuckets(config)
+    : await listFolder(config, bucket, prefix);
+  if (entries === null) return new Response(null, { status: 404 });
+  const headers = { "Content-Type": "text/html;charset=utf-8" };
+  if (method === "HEAD") return new Response(null, { headers });
+  return new Response(renderListing(entries, { query }), { headers });
+}
+
+/**
+ * The buckets, as folders.
+ * @param {Config} config
+ * @returns {Promise<import("../../lib/listing.js").Entry[]>}
+ */
+async function listBuckets(config) {
+  const response = await check(await send(config, "GET", "", ""));
+  const root = parseXML(await response.text());
+  return childrenOf(childrenOf(root, "Buckets")[0], "Bucket").map((bucket) => ({
+    Name: textOf(bucket, "Name"),
+    IsDir: true,
+    Size: -1,
+    MimeType: "",
+    ModTime: textOf(bucket, "CreationDate"),
+  }));
+}
+
+/**
+ * The files and the folders in a folder, as `list` of the s3 backend of
+ * rclone with a delimiter.
+ * @param {Config} config
+ * @param {string} bucket
+ * @param {string} prefix "" for the root of the bucket.
+ * @returns {Promise<import("../../lib/listing.js").Entry[] | null>} null when
+ *   the folder does not exist.
+ */
+async function listFolder(config, bucket, prefix) {
+  /** @type {import("../../lib/listing.js").Entry[]} */
+  const entries = [];
+  let found = false;
+  let token = "";
+  do {
+    const query = {
+      "list-type": "2",
+      delimiter: "/",
+      prefix,
+      "max-keys": `${config.listChunk}`,
+    };
+    if (config.urlEncode) query["encoding-type"] = "url";
+    if (token) query["continuation-token"] = token;
+    const response = await send(config, "GET", bucket, "", { query });
+    if (response.status === 404) {
+      await response.body?.cancel();
+      return null;
+    }
+    const root = parseXML(await (await check(response)).text());
+    const encoded = textOf(root, "EncodingType") === "url";
+
+    for (const common of childrenOf(root, "CommonPrefixes")) {
+      const name = nameOf(textOf(common, "Prefix"), encoded);
+      if (name === null || !name.startsWith(prefix)) continue;
+      found = true;
+      const folder = name.slice(prefix.length).replace(/\/$/, "");
+      if (folder === "") continue;
+      entries.push({
+        Name: folder,
+        IsDir: true,
+        Size: -1,
+        MimeType: "",
+        ModTime: "",
+      });
+    }
+    for (const object of childrenOf(root, "Contents")) {
+      const name = nameOf(textOf(object, "Key"), encoded);
+      if (name === null || !name.startsWith(prefix)) continue;
+      found = true;
+      const file = name.slice(prefix.length);
+      // The marker of the folder is not a file in it.
+      if (file === "" || file.endsWith("/")) continue;
+      entries.push({
+        Name: file,
+        IsDir: false,
+        Size: Number(textOf(object, "Size")),
+        MimeType: mimeType(file),
+        ModTime: textOf(object, "LastModified"),
+      });
+    }
+    token = textOf(root, "IsTruncated") === "true"
+      ? textOf(root, "NextContinuationToken")
+      : "";
+  } while (token);
+
+  // The root of a bucket exists with no file. An empty folder exists when it
+  // has a marker, as rclone checks it.
+  if (!found && prefix !== "") {
+    const response = await send(config, "HEAD", bucket, prefix);
+    await response.body?.cancel();
+    if (!response.ok) return null;
+  }
+  return entries;
+}
+
+/**
+ * Makes a bucket, or a marker of a folder with the option
+ * `directory_markers`. With no marker, a folder exists when it has a file.
+ * @param {Config} config
+ * @param {string} bucket
+ * @param {string} prefix
+ */
+async function putFolder(config, bucket, prefix) {
+  if (prefix === "") {
+    const head = await send(config, "HEAD", bucket, "");
+    await head.body?.cancel();
+    if (head.ok) return;
+    const response = await send(config, "PUT", bucket, "", {
+      body: new Uint8Array(0),
+      length: 0,
+      payload: EMPTY_PAYLOAD,
+    });
+    await check(response);
+    await response.body?.cancel();
+    return;
+  }
+  if (config.markers) await putMarkers(config, bucket, prefix);
+}
+
+/**
+ * Puts the markers of a folder and of its parent folders, as rclone: from
+ * the folder to the root of the bucket, until a marker exists.
+ * @param {Config} config
+ * @param {string} bucket
+ * @param {string} prefix The folder, with a `/` at the end.
+ */
+async function putMarkers(config, bucket, prefix) {
+  while (prefix !== "") {
+    const head = await send(config, "HEAD", bucket, prefix);
+    await head.body?.cancel();
+    if (head.ok) return;
+    const response = await send(config, "PUT", bucket, prefix, {
+      body: new Uint8Array(0),
+      length: 0,
+      payload: EMPTY_PAYLOAD,
+    });
+    await check(response);
+    await response.body?.cancel();
+    prefix = prefix.slice(0, prefix.lastIndexOf("/", prefix.length - 2) + 1);
+  }
+}
+
+/**
+ * Puts a file: in one PUT up to `upload_cutoff`, else in parts, as rclone.
+ * With `directory_markers`, the parent folders get markers first.
+ * @param {Config} config
+ * @param {string} bucket
+ * @param {string} key
+ * @param {Request} request
+ */
+async function putFile(config, bucket, key, request) {
+  if (config.markers) {
+    await putMarkers(config, bucket, key.slice(0, key.lastIndexOf("/") + 1));
+  }
+  const header = request.headers.get("Content-Length");
+  const length = header !== null && /^\d+$/.test(header)
+    ? Number(header)
+    : null;
+  const headers = {
+    "Content-Type": request.headers.get("Content-Type") || mimeType(key),
+  };
+
+  if (length !== null && length <= config.uploadCutoff) {
+    const body = sized(request.body ?? new Blob([]).stream(), length);
+    const response = await send(config, "PUT", bucket, key, {
+      headers,
+      body,
+      length,
+    });
+    await check(response);
+    await response.body?.cancel();
+    return;
+  }
+
+  // A part has the size of chunk_size, or more for a large file.
+  const partSize = length === null
+    ? config.chunkSize
+    : Math.max(config.chunkSize, Math.ceil(length / MAX_PARTS));
+  const parts = new Parts(request.body ?? new Blob([]).stream(), partSize);
+  const first = await parts.next();
+  if (length === null && parts.done) {
+    // A small file of unknown size.
+    const response = await send(config, "PUT", bucket, key, {
+      headers,
+      body: first,
+      length: first.length,
+      payload: sha256(first),
+    });
+    await check(response);
+    await response.body?.cancel();
+    return;
+  }
+
+  const create = await check(
+    await send(config, "POST", bucket, key, {
+      query: { uploads: "" },
+      headers,
+    }),
+  );
+  const uploadId = textOf(parseXML(await create.text()), "UploadId");
+  const upload = { uploadId };
+  try {
+    /** @type {string[]} */
+    const etags = [];
+    for (let part = first; part; part = await parts.next()) {
+      if (etags.length === MAX_PARTS) {
+        throw new S3Error("too many parts", 413);
+      }
+      const response = await check(
+        await send(config, "PUT", bucket, key, {
+          query: { partNumber: `${etags.length + 1}`, ...upload },
+          body: part,
+          length: part.length,
+          payload: sha256(part),
+        }),
+      );
+      await response.body?.cancel();
+      etags.push(response.headers.get("ETag") ?? "");
+      if (parts.done) break;
+    }
+    const xml = new TextEncoder().encode(
+      `<CompleteMultipartUpload>${
+        etags.map((etag, index) =>
+          `<Part><PartNumber>${index + 1}</PartNumber><ETag>${
+            escapeXML(etag)
+          }</ETag></Part>`
+        ).join("")
+      }</CompleteMultipartUpload>`,
+    );
+    const complete = await check(
+      await send(config, "POST", bucket, key, {
+        query: upload,
+        body: xml,
+        length: xml.length,
+        payload: sha256(xml),
+      }),
+    );
+    // S3 can give an error in an answer 200.
+    const result = parseXML(await complete.text());
+    if (result.name === "Error") {
+      throw new S3Error(textOf(result, "Code"), 502);
+    }
+  } catch (error) {
+    const abort = await send(config, "DELETE", bucket, key, { query: upload });
+    await abort.body?.cancel();
+    throw error;
+  }
+}
+
+/**
+ * Deletes a file. As the other backends, a file that does not exist gives
+ * 404: S3 gives no error for it.
+ * @param {Config} config
+ * @param {string} bucket
+ * @param {string} key
+ */
+async function deleteFile(config, bucket, key) {
+  const head = await send(config, "HEAD", bucket, key);
+  await head.body?.cancel();
+  if (head.status === 404) throw new S3Error("Not Found", 404);
+  await check(head);
+  const response = await check(await send(config, "DELETE", bucket, key));
+  await response.body?.cancel();
+}
+
+/**
+ * Deletes a folder and all that is in it, with lists with no delimiter and
+ * DeleteObjects of 1000 objects. The root of a bucket deletes the bucket
+ * too, as `rclone purge`.
+ * @param {Config} config
+ * @param {string} bucket
+ * @param {string} prefix
+ */
+async function deleteFolder(config, bucket, prefix) {
+  let found = false;
+  let token = "";
+  do {
+    const query = {
+      "list-type": "2",
+      prefix,
+      "max-keys": `${Math.min(config.listChunk, 1000)}`,
+    };
+    if (config.urlEncode) query["encoding-type"] = "url";
+    if (token) query["continuation-token"] = token;
+    const response = await send(config, "GET", bucket, "", { query });
+    if (response.status === 404) throw new S3Error("Not Found", 404);
+    const root = parseXML(await (await check(response)).text());
+    const encoded = textOf(root, "EncodingType") === "url";
+    const keys = childrenOf(root, "Contents")
+      .map((object) => nameOf(textOf(object, "Key"), encoded))
+      .filter((key) => key !== null);
+    if (keys.length) {
+      found = true;
+      await deleteObjects(config, bucket, keys);
+    }
+    token = textOf(root, "IsTruncated") === "true"
+      ? textOf(root, "NextContinuationToken")
+      : "";
+  } while (token);
+
+  if (prefix === "") {
+    const response = await check(await send(config, "DELETE", bucket, ""));
+    await response.body?.cancel();
+    return;
+  }
+  if (!found) {
+    // An empty folder with a marker.
+    const head = await send(config, "HEAD", bucket, prefix);
+    await head.body?.cancel();
+    if (!head.ok) throw new S3Error("Not Found", 404);
+    const response = await check(await send(config, "DELETE", bucket, prefix));
+    await response.body?.cancel();
+  }
+}
+
+/**
+ * Deletes objects with one request.
+ * @param {Config} config
+ * @param {string} bucket
+ * @param {string[]} keys At most 1000 keys.
+ */
+async function deleteObjects(config, bucket, keys) {
+  // A key that XML cannot have, for example with a vertical tab, gets a
+  // DeleteObject.
+  for (const key of keys.filter((key) => !isXMLText(key))) {
+    const response = await check(await send(config, "DELETE", bucket, key));
+    await response.body?.cancel();
+  }
+  keys = keys.filter(isXMLText);
+  if (keys.length === 0) return;
+  const xml = new TextEncoder().encode(
+    `<Delete><Quiet>true</Quiet>${
+      keys.map((key) => `<Object><Key>${escapeXML(key)}</Key></Object>`)
+        .join("")
+    }</Delete>`,
+  );
+  const response = await check(
+    await send(config, "POST", bucket, "", {
+      query: { delete: "" },
+      headers: {
+        "Content-MD5": createHash("md5").update(xml).digest("base64"),
+      },
+      body: xml,
+      length: xml.length,
+      payload: sha256(xml),
+    }),
+  );
+  const result = parseXML(await response.text());
+  const error = childrenOf(result, "Error")[0];
+  if (error) {
+    throw new S3Error(`DeleteObjects: ${textOf(error, "Code")}`, 502);
+  }
+}
+
+/** @param {Uint8Array} bytes */
+function sha256(bytes) {
+  return createHash("sha256").update(bytes).digest("hex");
+}
+
+/**
+ * Cuts a stream into parts of a size: each part has the size, but the last
+ * part can be smaller.
+ */
+class Parts {
+  /** @param {ReadableStream<Uint8Array>} stream @param {number} size */
+  constructor(stream, size) {
+    this.reader = stream.getReader();
+    this.size = size;
+    /** @type {Uint8Array} */
+    this.pending = new Uint8Array(0);
+    /** True when the stream has no more data. */
+    this.done = false;
+  }
+
+  /**
+   * The next part, or null at the end.
+   * @returns {Promise<Uint8Array | null>}
+   */
+  async next() {
+    const chunks = this.pending.length ? [this.pending] : [];
+    let length = this.pending.length;
+    this.pending = new Uint8Array(0);
+    while (length < this.size && !this.done) {
+      const { done, value } = await this.reader.read();
+      if (done) {
+        this.done = true;
+        break;
+      }
+      chunks.push(value);
+      length += value.length;
+    }
+    if (length === 0 && this.done) return null;
+    const bytes = new Uint8Array(length);
+    let offset = 0;
+    for (const chunk of chunks) {
+      bytes.set(chunk, offset);
+      offset += chunk.length;
+    }
+    if (length > this.size) {
+      this.pending = bytes.slice(this.size);
+      return bytes.subarray(0, this.size);
+    }
+    // A part of the size can be the last part: the next read tells it.
+    if (!this.done && this.pending.length === 0) {
+      const { done, value } = await this.reader.read();
+      if (done) this.done = true;
+      else this.pending = value;
+    }
+    return bytes;
+  }
+}
+
+export default {
+  fetch: s3,
+};
diff --git a/backend/s3/main_test.js b/backend/s3/main_test.js
new file mode 100644
index 0000000..e88b270
--- /dev/null
+++ b/backend/s3/main_test.js
@@ -0,0 +1,191 @@
+/**
+ * The tests of the s3 backend, on `rclone serve s3`: a server of the S3 API
+ * on a local folder. They run when rclone is in the PATH, or when RCLONE is
+ * the path of rclone.
+ */
+import { after, describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import process from "node:process";
+
+import { backendSuite } from "../../lib/testing/suite.js";
+import { remote } from "../../lib/testing/remote.js";
+import { listen } from "../../lib/testing/server.js";
+import s3 from "./main.js";
+import { KEYS, serveS3 } from "./testing.js";
+
+const RCLONE = process.env.RCLONE || "rclone";
+const hasRclone = spawnSync(RCLONE, ["version"]).status === 0;
+
+if (hasRclone) {
+  const server = await serveS3();
+  after(() => server.stop());
+  const params = { ...KEYS, endpoint: server.endpoint, region: "us-east-1" };
+
+  // S3 has no empty folders with no markers, as rclone.
+  backendSuite("s3", s3, { params, parent: "/rfetch/", emptyFolders: false });
+  // Files in parts: upload_cutoff of 100 KiB, and parts of 5 MiB.
+  backendSuite("s3 in parts", s3, {
+    params: { ...params, upload_cutoff: "100k" },
+    parent: "/rfetch/",
+    emptyFolders: false,
+  });
+
+  describe("s3", () => {
+    const fs = remote(s3, { params, root: "/rfetch/s3-test/" });
+
+    test("puts no credentials in the links of a list", async () => {
+      await fs.put("a b.txt", new TextEncoder().encode("a"));
+      const html = await fs.get("").then((response) => response.text());
+      assert.ok(html.includes(' href="a%20b.txt?endpoint='));
+      assert.ok(!html.includes("rfetch-key"));
+      assert.ok(!html.includes("rfetch-secret"));
+    });
+
+    test("lists the buckets", async () => {
+      const root = remote(s3, { params });
+      assert.deepEqual(
+        (await root.list("")).map(({ Name, IsDir }) => ({ Name, IsDir })),
+        [{ Name: "rfetch", IsDir: true }],
+      );
+    });
+
+    test("puts a file of unknown size in parts", async () => {
+      const size = 5 * 1024 * 1024 + 1000;
+      const data = new Uint8Array(size).map((_, i) => (i * 31) & 0xff);
+      const response = await fs.send("parts.bin", {
+        method: "PUT",
+        body: new Blob([data]).stream(),
+      });
+      assert.equal(response.status, 201);
+      const got = await fs.get("parts.bin");
+      assert.equal(got.headers.get("Content-Length"), `${size}`);
+      assert.deepEqual(new Uint8Array(await got.arrayBuffer()), data);
+    });
+
+    test("takes the options from env", async () => {
+      const fromEnv = remote(s3, {
+        params: { endpoint: server.endpoint },
+        env: {
+          RCLONE_S3_ACCESS_KEY_ID: KEYS.access_key_id,
+          RCLONE_S3_SECRET_ACCESS_KEY: KEYS.secret_access_key,
+        },
+        root: "/rfetch/s3-test/",
+      });
+      const response = await fromEnv.get("a b.txt");
+      assert.equal(await response.text(), "a");
+    });
+
+    test("gives 403 with wrong credentials", async () => {
+      const wrong = remote(s3, {
+        params: { ...params, secret_access_key: "wrong" },
+        root: "/rfetch/s3-test/",
+      });
+      const response = await wrong.get("a b.txt");
+      await response.body?.cancel();
+      assert.equal(response.status, 403);
+    });
+
+    test("gives 400 for options that are not correct", async () => {
+      for (
+        const options of [
+          { secret_access_key: "" },
+          { chunk_size: "1M" },
+          { list_chunk: "0" },
+          { endpoint: "http://[" },
+        ]
+      ) {
+        const response = await remote(s3, { params: { ...params, ...options } })
+          .get("");
+        await response.body?.cancel();
+        assert.equal(response.status, 400, JSON.stringify(options));
+      }
+    });
+
+    test("deletes the files of the tests", async () => {
+      const response = await fs.delete("");
+      assert.equal(response.status, 204);
+    });
+  });
+} else {
+  test("s3", { skip: "rclone is not installed. Set RCLONE to its path." });
+}
+
+test("puts the markers of the parent folders, as rclone", async () => {
+  // A service that keeps the names of the objects, and records the requests.
+  const keys = new Set();
+  const log = [];
+  const server = await listen(async (request) => {
+    const { pathname } = new URL(request.url);
+    log.push(`${request.method} ${pathname}`);
+    await request.body?.cancel();
+    if (request.method === "HEAD") {
+      return new Response(null, { status: keys.has(pathname) ? 200 : 404 });
+    }
+    keys.add(pathname);
+    return new Response(null, { headers: { ETag: '"0"' } });
+  });
+  after(() => server.close());
+
+  const params = { endpoint: `${server.url}`, directory_markers: "true" };
+  const fs = remote(s3, { params, root: "/bucket/" });
+  /** @param {string} path @param {string[]} requests */
+  const putGives = async (path, requests) => {
+    log.length = 0;
+    const response = await fs.put(path, new Uint8Array(0));
+    assert.equal(response.status, 201, path);
+    assert.deepEqual(log, requests, path);
+  };
+
+  await putGives("a/b/c.txt", [
+    "HEAD /bucket/a/b/",
+    "PUT /bucket/a/b/",
+    "HEAD /bucket/a/",
+    "PUT /bucket/a/",
+    "PUT /bucket/a/b/c.txt",
+  ]);
+  // The parent folder a/ has a marker.
+  await putGives("a/d/e.txt", [
+    "HEAD /bucket/a/d/",
+    "PUT /bucket/a/d/",
+    "HEAD /bucket/a/",
+    "PUT /bucket/a/d/e.txt",
+  ]);
+  await putGives("a/f/", [
+    "HEAD /bucket/a/f/",
+    "PUT /bucket/a/f/",
+    "HEAD /bucket/a/",
+  ]);
+  await putGives("g.txt", ["PUT /bucket/g.txt"]);
+
+  // With no markers, a file is one PUT.
+  log.length = 0;
+  const plain = remote(s3, {
+    params: { endpoint: `${server.url}` },
+    root: "/bucket/",
+  });
+  assert.equal((await plain.put("h/i.txt", new Uint8Array(0))).status, 201);
+  assert.deepEqual(log, ["PUT /bucket/h/i.txt"]);
+});
+
+// A run on a real service, for example Cloudflare R2, when S3_TEST_ENDPOINT
+// and S3_TEST_BUCKET are set. The credentials are in RCLONE_S3_ACCESS_KEY_ID
+// and RCLONE_S3_SECRET_ACCESS_KEY, thus they are not in a URL.
+const { S3_TEST_ENDPOINT, S3_TEST_BUCKET, S3_TEST_REGION } = process.env;
+if (S3_TEST_ENDPOINT && S3_TEST_BUCKET) {
+  const env = {
+    RCLONE_S3_ACCESS_KEY_ID: process.env.RCLONE_S3_ACCESS_KEY_ID,
+    RCLONE_S3_SECRET_ACCESS_KEY: process.env.RCLONE_S3_SECRET_ACCESS_KEY,
+  };
+  const params = {
+    endpoint: S3_TEST_ENDPOINT,
+    region: S3_TEST_REGION ?? "auto",
+  };
+  const parent = `/${S3_TEST_BUCKET}/`;
+  backendSuite("s3 service", s3, { params, env, parent, emptyFolders: false });
+  backendSuite("s3 service with folder markers", s3, {
+    params: { ...params, directory_markers: "true" },
+    env,
+    parent,
+  });
+}
diff --git a/backend/s3/rclone_test.js b/backend/s3/rclone_test.js
new file mode 100644
index 0000000..ae7b244
--- /dev/null
+++ b/backend/s3/rclone_test.js
@@ -0,0 +1,131 @@
+/**
+ * The tests of the s3 backend against the s3 backend of rclone, on the same
+ * `rclone serve s3`: each one reads what the other writes. The tests run
+ * when rclone is in the PATH, or when RCLONE is the path of rclone.
+ */
+import { after, before, describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import process from "node:process";
+
+import { remote } from "../../lib/testing/remote.js";
+import { KEYS, serveS3 } from "./testing.js";
+import s3 from "./main.js";
+
+const RCLONE = process.env.RCLONE || "rclone";
+const hasRclone = spawnSync(RCLONE, ["version"]).status === 0;
+
+/** The files: hard names, and sizes in one PUT and in parts. */
+const FILES = {
+  "empty.txt": 0,
+  "a/one.bin": 1,
+  "a/b/c.json": 100,
+  "file name #1.txt": 2048,
+  [`hello? sausage/êé/Hello, 世界/ " ' @ < > & ? + ≠/z.txt`]: 3000,
+  "parts/large.bin": 6 * 1024 * 1024 + 7,
+};
+
+/** @param {number} size */
+function content(size) {
+  return new Uint8Array(size).map((_, index) => (index * 13 + size) & 0xff);
+}
+
+describe("s3 and rclone", {
+  skip: !hasRclone && "rclone is not installed. Set RCLONE to its path.",
+}, () => {
+  let server;
+  /** The connection string of the s3 backend of rclone for the server. */
+  let target;
+  /** @param {string[]} args */
+  const rclone = (...args) => {
+    const { status, stdout, stderr } = spawnSync(RCLONE, args, {
+      env: { PATH: process.env.PATH, HOME: server.folder },
+      maxBuffer: 64 * 1024 * 1024,
+    });
+    assert.equal(status, 0, `rclone ${args[0]}: ${stderr}`);
+    return stdout;
+  };
+
+  before(async () => {
+    server = await serveS3();
+    target = `:s3,provider=Other,access_key_id=${KEYS.access_key_id},` +
+      `secret_access_key=${KEYS.secret_access_key},` +
+      `endpoint='${server.endpoint}':rfetch`;
+    for (const [path, size] of Object.entries(FILES)) {
+      mkdirSync(dirname(join(server.folder, "plain", path)), {
+        recursive: true,
+      });
+      writeFileSync(join(server.folder, "plain", path), content(size));
+    }
+  });
+  after(() => server?.stop());
+
+  const rfetch = (root) =>
+    remote(s3, {
+      params: { endpoint: server.endpoint, upload_cutoff: "1M" },
+      env: {
+        RCLONE_S3_ACCESS_KEY_ID: KEYS.access_key_id,
+        RCLONE_S3_SECRET_ACCESS_KEY: KEYS.secret_access_key,
+      },
+      root,
+    });
+
+  /** The paths and the sizes of the files in a folder, from the lists. */
+  async function walk(fs) {
+    const files = [];
+    const next = async (path) => {
+      for (const entry of await fs.list(path)) {
+        if (entry.IsDir) await next(`${path}${entry.Name}/`);
+        else files.push({ Path: `${path}${entry.Name}`, Size: entry.Size });
+      }
+    };
+    await next("");
+    return files.sort((a, b) => a.Path < b.Path ? -1 : +(a.Path > b.Path));
+  }
+
+  test("rfetch reads what rclone writes", async () => {
+    rclone("copy", join(server.folder, "plain"), `${target}/by-rclone`);
+    const fs = rfetch("/rfetch/by-rclone/");
+    for (const [path, size] of Object.entries(FILES)) {
+      const response = await fs.get(path);
+      assert.equal(response.status, 200, path);
+      assert.equal(response.headers.get("Content-Length"), `${size}`, path);
+      assert.deepEqual(
+        new Uint8Array(await response.arrayBuffer()),
+        content(size),
+        path,
+      );
+    }
+    const expected = JSON.parse(
+      rclone("lsjson", "-R", "--files-only", `${target}/by-rclone`),
+    ).map(({ Path, Size }) => ({ Path, Size }))
+      .sort((a, b) => a.Path < b.Path ? -1 : +(a.Path > b.Path));
+    assert.deepEqual(await walk(fs), expected);
+  });
+
+  test("rclone reads what rfetch writes", async () => {
+    const fs = rfetch("/rfetch/by-rfetch/");
+    for (const [path, size] of Object.entries(FILES)) {
+      const response = await fs.put(path, content(size));
+      assert.equal(response.status, 201, path);
+    }
+    rclone("check", join(server.folder, "plain"), `${target}/by-rfetch`);
+    rclone("copy", `${target}/by-rfetch`, join(server.folder, "out"));
+    for (const [path, size] of Object.entries(FILES)) {
+      assert.deepEqual(
+        new Uint8Array(readFileSync(join(server.folder, "out", path))),
+        content(size),
+        path,
+      );
+    }
+  });
+
+  test("rclone purge leaves nothing that rfetch lists", async () => {
+    const fs = rfetch("/rfetch/by-rfetch/");
+    assert.equal((await fs.delete("")).status, 204);
+    rclone("purge", `${target}/by-rclone`);
+    assert.deepEqual(await rfetch("/rfetch/").list(""), []);
+  });
+});
diff --git a/backend/s3/testing.js b/backend/s3/testing.js
new file mode 100644
index 0000000..477198f
--- /dev/null
+++ b/backend/s3/testing.js
@@ -0,0 +1,60 @@
+/**
+ * A test server of the S3 API: `rclone serve s3` on a local folder, with the
+ * bucket `rfetch`.
+ */
+import { spawn } from "node:child_process";
+import { mkdirSync, mkdtempSync, rmSync } from "node:fs";
+import { createServer } from "node:net";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import process from "node:process";
+
+const RCLONE = process.env.RCLONE || "rclone";
+
+/** The credentials of the test server. */
+export const KEYS = {
+  access_key_id: "rfetch-key",
+  secret_access_key: "rfetch-secret",
+};
+
+/**
+ * Starts `rclone serve s3` on a free port, with the bucket `rfetch`.
+ * @returns {Promise<{ endpoint: string, folder: string, stop: () => void }>}
+ */
+export async function serveS3() {
+  const folder = mkdtempSync(join(tmpdir(), "rfetch-s3-"));
+  mkdirSync(join(folder, "data", "rfetch"), { recursive: true });
+  const port = await new Promise((resolve) => {
+    const server = createServer().listen(0, "127.0.0.1", () => {
+      const { port } = server.address();
+      server.close(() => resolve(port));
+    });
+  });
+  const child = spawn(RCLONE, [
+    "serve",
+    "s3",
+    "--auth-key",
+    `${KEYS.access_key_id},${KEYS.secret_access_key}`,
+    "--addr",
+    `127.0.0.1:${port}`,
+    join(folder, "data"),
+  ], { env: { PATH: process.env.PATH, HOME: folder }, stdio: "ignore" });
+  const endpoint = `http://127.0.0.1:${port}`;
+  // Waits until the server answers.
+  for (let i = 0; i < 100; i++) {
+    try {
+      await fetch(endpoint);
+      break;
+    } catch {
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+  }
+  return {
+    endpoint,
+    folder,
+    stop() {
+      child.kill();
+      rmSync(folder, { recursive: true, force: true });
+    },
+  };
+}

From 3dd7b11cd5649f92070c72da371a6d09ff77cbf9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sat, 17 Oct 2026 15:27:37 +0000
Subject: [PATCH 47/87] refactor: backends call the global fetch for their
 remotes

The import of mod.js sets the global fetch again. Thus alias, chunker and crypt call fetch(":memory:/path") for the remote under them, and know nothing of rfetch. env.REMOTE is removed. _worker.js and the tests of these backends import mod.js. The tests that count or change the requests to the remote use t.mock.method on the global fetch.
---
 CONTRIBUTING.md                | 16 ++++++++-----
 _worker.js                     |  7 +++---
 backend/alias/main.js          |  9 +++----
 backend/alias/main_test.js     | 12 ++++------
 backend/chunker/main.js        | 17 +++++--------
 backend/chunker/main_test.js   | 32 +++++++------------------
 backend/chunker/rclone_test.js |  8 ++-----
 backend/crypt/main.js          | 24 ++++++++-----------
 backend/crypt/main_test.js     | 44 +++++++++++-----------------------
 backend/crypt/rclone_test.js   |  7 ++----
 backend/http/rclone_test.js    |  8 +++----
 backend/main.js                | 13 ++++------
 lib/testing/remote.js          |  2 +-
 lib/testing/suite.js           |  2 +-
 mod.js                         | 16 +++++--------
 15 files changed, 80 insertions(+), 137 deletions(-)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 3b7427b..3d04c62 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -64,20 +64,24 @@ export default {
 A backend imports nothing of rfetch, for example `mod.js`. It is a Worker of
 Cloudflare: it gets all from the request and from `env`, the second argument of
 `fetch`. A backend on top of another remote, for example `crypt` or `chunker`,
-sends its requests to that remote with `env.REMOTE.fetch`, as a service binding.
-With no `REMOTE`, it uses the global `fetch`. The `fetch` of `mod.js` and
-`_worker.js` give `REMOTE`: it reads remotes as `:memory:/path`. In the tests,
-give the same `env` to the suite:
+sends its requests to that remote with the global `fetch`, for example
+`fetch(":memory:/crypt/file.bin")`. The host sets the global `fetch` that reads
+such a path: the import of `mod.js` sets it, and `_worker.js` imports `mod.js`.
+The tests of such a backend import `mod.js` too:
 
 ```js
-import { fetch } from "../../mod.js";
+// Sets the global `fetch` that reads the paths of remotes.
+import "../../mod.js";
 
 backendSuite("crypt", crypt, {
-  env: { REMOTE: { fetch } },
   params: { remote: ":memory:/crypt", password },
 });
 ```
 
+To count or change the requests to the remote in a test, replace the global
+`fetch` with `t.mock.method(globalThis, "fetch", …)`. The test runner puts the
+original `fetch` back at the end of the test.
+
 ## Architecture
 
 - `GET /folder/`: displays HTML page with folder content.
diff --git a/_worker.js b/_worker.js
index 39cdbf8..f154e26 100644
--- a/_worker.js
+++ b/_worker.js
@@ -1,5 +1,6 @@
 import * as backends from "./backend/main.js";
-import { fetch } from "./mod.js";
+// Sets the global `fetch` that reads the paths of remotes.
+import "./mod.js";
 
 /**
  * A handler
@@ -39,9 +40,7 @@ function remote(request, env, params) {
 
   request = new Request(url, request);
 
-  // A backend on top of other remotes, for example crypt, sends its
-  // requests to them with the fetch of rfetch, as REMOTE.
-  return backend.fetch(request, { ...env, REMOTE: env.REMOTE ?? { fetch } });
+  return backend.fetch(request, env);
 }
 
 const routes = {
diff --git a/backend/alias/main.js b/backend/alias/main.js
index 8169fea..ab5ab7f 100644
--- a/backend/alias/main.js
+++ b/backend/alias/main.js
@@ -23,13 +23,11 @@ import { relink } from "../../lib/listing.js";
 import { decodePath, encodePath } from "../../lib/path.js";
 
 /**
+ * Sends the requests to the remote of the alias with the global `fetch`.
  * @param {Request} request
- * @param {{ REMOTE?: { fetch: typeof fetch } }} [env] `REMOTE` gets the
- *   requests to the remote of the alias, as a service binding of Cloudflare.
- *   With no `REMOTE`, the global `fetch` gets them.
  * @returns {Promise<Response>}
  */
-async function alias(request, env = {}) {
+async function alias(request) {
   const { method } = request;
   const { pathname, searchParams } = new URL(request.url);
 
@@ -49,8 +47,7 @@ async function alias(request, env = {}) {
     init.body = request.body;
     init.duplex = "half";
   }
-  const fetcher = env.REMOTE ?? globalThis;
-  const response = await fetcher.fetch(remote + encodePath(path), init);
+  const response = await fetch(remote + encodePath(path), init);
   if (!response.ok) {
     return response;
   }
diff --git a/backend/alias/main_test.js b/backend/alias/main_test.js
index 44abfc0..3fdc81a 100644
--- a/backend/alias/main_test.js
+++ b/backend/alias/main_test.js
@@ -6,12 +6,10 @@ import assert from "node:assert/strict";
 
 import { backendSuite } from "../../lib/testing/suite.js";
 import { remote } from "../../lib/testing/remote.js";
-import { fetch } from "../../mod.js";
+// Sets the global `fetch` that reads the paths of remotes.
+import "../../mod.js";
 import backend from "./main.js";
 
-/** The remotes under the backend, through the fetch of rfetch. */
-const env = { REMOTE: { fetch } };
-
 test("local path", async () => {
   const requestInit = {
     method: "GET",
@@ -21,7 +19,7 @@ test("local path", async () => {
   const url = new URL(`/backend/?remote=.`, import.meta.url);
 
   const request = new Request(url, requestInit);
-  const response = await backend.fetch(request, env);
+  const response = await backend.fetch(request);
   const html = await response.text();
 
   const entries = await readdir(join(cwd, "backend"), { withFileTypes: true });
@@ -37,10 +35,10 @@ test("local path", async () => {
   }
 });
 
-backendSuite("alias", backend, { env, params: { remote: ":memory:/alias" } });
+backendSuite("alias", backend, { params: { remote: ":memory:/alias" } });
 
 test("the links of a list are in the alias", async () => {
-  const fs = remote(backend, { env, params: { remote: ":memory:/links" } });
+  const fs = remote(backend, { params: { remote: ":memory:/links" } });
   await fs.put("a b.txt", new TextEncoder().encode("a"));
   const html = await fs.get("").then((response) => response.text());
   assert.ok(html.includes(` href="a%20b.txt?remote=%3Amemory%3A%2Flinks"`));
diff --git a/backend/chunker/main.js b/backend/chunker/main.js
index c550ffc..0d4fcfa 100644
--- a/backend/chunker/main.js
+++ b/backend/chunker/main.js
@@ -169,25 +169,22 @@ export const options = {
  * @property {boolean} noRename True for the transactions "norename".
  * @property {boolean} failHard
  * @property {ReturnType<typeof nameFormat>} names
- * @property {{ fetch: typeof fetch }} fetcher The remote under the chunker:
- *   `env.REMOTE`, or the global `fetch`.
  */
 
 /**
+ * Sends the requests to the remote under the chunker with the global
+ * `fetch`.
  * @param {Request} request
- * @param {{ REMOTE?: { fetch: typeof fetch } }} [env] `REMOTE` gets the
- *   requests to the remote under the chunker, as a service binding of
- *   Cloudflare. With no `REMOTE`, the global `fetch` gets them.
  * @returns {Promise<Response>}
  */
-async function chunker(request, env = {}) {
+async function chunker(request) {
   const { method } = request;
   const { pathname, searchParams } = new URL(request.url);
 
   /** @type {Config} */
   let config;
   try {
-    config = configOf(searchParams, env);
+    config = configOf(searchParams);
   } catch (error) {
     return new Response(error.message, { status: 400 });
   }
@@ -249,10 +246,9 @@ class ChunkerError extends Error {
 /**
  * Reads the options, as `NewFs` of the chunker of rclone.
  * @param {URLSearchParams} searchParams
- * @param {{ REMOTE?: { fetch: typeof fetch } }} env
  * @returns {Config}
  */
-function configOf(searchParams, env) {
+function configOf(searchParams) {
   const get = (name) => searchParams.get(name) ?? options.default[name];
 
   const remote = searchParams.get("remote")?.replace(/\/$/, "");
@@ -310,7 +306,6 @@ function configOf(searchParams, env) {
     noRename,
     failHard: get("fail_hard") === "true",
     names: nameFormat(get("name_format"), startFrom),
-    fetcher: env.REMOTE ?? globalThis,
   };
 }
 
@@ -914,7 +909,7 @@ async function deleteFile(config, dir, name) {
  * @returns {Promise<Response>}
  */
 function send(config, path, init) {
-  return config.fetcher.fetch(config.remote + encodePath(path), init);
+  return fetch(config.remote + encodePath(path), init);
 }
 
 /**
diff --git a/backend/chunker/main_test.js b/backend/chunker/main_test.js
index e8eae64..d5658b9 100644
--- a/backend/chunker/main_test.js
+++ b/backend/chunker/main_test.js
@@ -7,20 +7,15 @@ import { remote } from "../../lib/testing/remote.js";
 import { fetch } from "../../mod.js";
 import backend from "./main.js";
 
-/** The remotes under the backend, through the fetch of rfetch. */
-const env = { REMOTE: { fetch } };
-
 // Small chunks, thus the files of the suite have more than one chunk.
 const CHUNK = "64k";
 
 backendSuite("chunker", backend, {
-  env,
   params: { remote: ":memory:/chunker", chunk_size: CHUNK },
 });
 // Without metadata, a name is always in chunks. rclone does not read the
 // name of a chunk with "\n": "." of Go does not match it.
 backendSuite("chunker meta_format=none", backend, {
-  env,
   params: {
     remote: ":memory:/none",
     chunk_size: CHUNK,
@@ -30,7 +25,6 @@ backendSuite("chunker meta_format=none", backend, {
   skipName: /\n/,
 });
 backendSuite("chunker transactions=norename", backend, {
-  env,
   params: {
     remote: ":memory:/norename",
     chunk_size: CHUNK,
@@ -46,7 +40,6 @@ function content(size) {
 describe("chunker", () => {
   const root = ":memory:/layout";
   const fs = remote(backend, {
-    env,
     params: { remote: root, chunk_size: "1k" },
   });
 
@@ -160,14 +153,13 @@ describe("chunker", () => {
         },
       ]
     ) {
-      const response = await remote(backend, { env, params }).get("");
+      const response = await remote(backend, { params }).get("");
       assert.equal(response.status, 400, JSON.stringify(params));
     }
   });
 
   test("names the chunks with name_format and start_from", async () => {
     const custom = remote(backend, {
-      env,
       params: {
         remote: root,
         chunk_size: "1k",
@@ -186,24 +178,18 @@ describe("chunker", () => {
     await custom.delete("a.bin");
   });
 
-  test("reads only the chunks of a range", async () => {
+  test("reads only the chunks of a range", async (t) => {
     /** The chunk and the `Range` of each GET of a chunk. */
     const reads = [];
+    t.mock.method(globalThis, "fetch", (input, init = {}) => {
+      const name = decodeURIComponent(input.slice(input.lastIndexOf("/") + 1));
+      if (/_chunk\.\d+$/.test(name) && (init.method ?? "GET") === "GET") {
+        reads.push([name, new Headers(init.headers).get("Range")]);
+      }
+      return fetch(input, init);
+    });
     const counted = remote(backend, {
       params: { remote: root, chunk_size: "1k" },
-      env: {
-        REMOTE: {
-          fetch(input, init = {}) {
-            const name = decodeURIComponent(
-              input.slice(input.lastIndexOf("/") + 1),
-            );
-            if (/_chunk\.\d+$/.test(name) && (init.method ?? "GET") === "GET") {
-              reads.push([name, new Headers(init.headers).get("Range")]);
-            }
-            return fetch(input, init);
-          },
-        },
-      },
     });
     const data = content(3000);
     await counted.put("range.bin", data);
diff --git a/backend/chunker/rclone_test.js b/backend/chunker/rclone_test.js
index 919ee94..5719aaf 100644
--- a/backend/chunker/rclone_test.js
+++ b/backend/chunker/rclone_test.js
@@ -20,12 +20,10 @@ import { dirname, join } from "node:path";
 import process from "node:process";
 
 import { remote } from "../../lib/testing/remote.js";
-import { fetch } from "../../mod.js";
+// Sets the global `fetch` that reads the paths of remotes.
+import "../../mod.js";
 import chunker from "./main.js";
 
-/** The remotes under the backend, through the fetch of rfetch. */
-const env = { REMOTE: { fetch } };
-
 const RCLONE = process.env.RCLONE || "rclone";
 const hasRclone = spawnSync(RCLONE, ["version"]).status === 0;
 
@@ -109,7 +107,6 @@ describe("chunker and rclone", {
   for (const [mode, options] of Object.entries(MODES)) {
     const rfetch = (side) =>
       remote(chunker, {
-        env,
         params: { remote: `${mode}/${side}`, ...options },
       });
 
@@ -185,7 +182,6 @@ describe("chunker and rclone", {
 
   test("rclone reads a file that rfetch writes with no Content-Length", async () => {
     const fs = remote(chunker, {
-      env,
       params: { remote: "rename/by-rfetch", ...MODES.rename },
     });
     for (const size of [10, 3000]) {
diff --git a/backend/crypt/main.js b/backend/crypt/main.js
index 621b5b6..f686f8b 100644
--- a/backend/crypt/main.js
+++ b/backend/crypt/main.js
@@ -154,14 +154,12 @@ const SECRETBOX_OPTIONS = {
 const SECRETS = ["password", "password2"];
 
 /**
- * Serves a crypted remote.
+ * Serves a crypted remote. The requests to the remote under crypt go to the
+ * global `fetch`.
  * @param {Request} request
- * @param {{ REMOTE?: { fetch: typeof fetch } }} [env] `REMOTE` gets the
- *   requests to the remote under crypt, as a service binding of Cloudflare.
- *   With no `REMOTE`, the global `fetch` gets them.
  * @returns {Promise<Response>}
  */
-async function crypt(request, env = {}) {
+async function crypt(request) {
   const { method } = request;
   const { pathname, searchParams } = new URL(request.url);
 
@@ -188,7 +186,6 @@ async function crypt(request, env = {}) {
     return new Response("The password is not obscured", { status: 400 });
   }
 
-  const fetcher = env.REMOTE ?? globalThis;
   const isDirectory = path.endsWith("/");
   const target = remote + cipher.names.encrypt(path);
 
@@ -199,11 +196,11 @@ async function crypt(request, env = {}) {
 
   const range = request.headers.get("Range");
   if (method === "GET" && !isDirectory && range !== null) {
-    return await getRange(fetcher, target, headers, cipher, path, range);
+    return await getRange(target, headers, cipher, path, range);
   }
 
   if (method === "GET" || method === "HEAD") {
-    const response = await fetcher.fetch(target, { method, headers });
+    const response = await fetch(target, { method, headers });
     if (!response.ok) {
       return response;
     }
@@ -258,7 +255,7 @@ async function crypt(request, env = {}) {
       init.duplex = "half";
     }
 
-    const response = await fetcher.fetch(target, init);
+    const response = await fetch(target, init);
     await response.body?.cancel();
     const result = new Headers();
     if (response.ok) {
@@ -268,7 +265,7 @@ async function crypt(request, env = {}) {
   }
 
   if (method === "DELETE") {
-    const response = await fetcher.fetch(target, { method, headers });
+    const response = await fetch(target, { method, headers });
     await response.body?.cancel();
     return new Response(null, { status: response.status });
   }
@@ -284,7 +281,6 @@ async function crypt(request, env = {}) {
  * encrypted file gives its nonce and its size, then only the blocks of the
  * range are read and decrypted. When the remote sends all the file for a
  * range, all the file is decrypted, and the answer has the range only.
- * @param {{ fetch: typeof fetch }} fetcher The remote.
  * @param {string} target The encrypted path on the remote.
  * @param {Headers} headers The headers of the request, with no `Range`.
  * @param {{ dataKey: Uint8Array }} cipher
@@ -292,14 +288,14 @@ async function crypt(request, env = {}) {
  * @param {string} header The `Range` of the request.
  * @returns {Promise<Response>}
  */
-async function getRange(fetcher, target, headers, cipher, path, header) {
+async function getRange(target, headers, cipher, path, header) {
   const { magic, blockSize } = SECRETBOX_OPTIONS;
   const headerSize = magic.length + 24;
   const blockLength = blockSize + 16;
 
   const init = { headers: new Headers(headers) };
   init.headers.set("Range", `bytes=0-${headerSize - 1}`);
-  const first = await fetcher.fetch(target, init);
+  const first = await fetch(target, init);
   if (first.status === 416) {
     // The encrypted file is shorter than its header.
     return new Response(Errors.TOO_SHORT, { status: 500 });
@@ -380,7 +376,7 @@ async function getRange(fetcher, target, headers, cipher, path, header) {
     Number(total),
   ) - 1;
   init.headers.set("Range", `bytes=${from}-${to}`);
-  const second = await fetcher.fetch(target, init);
+  const second = await fetch(target, init);
   if (!second.ok) {
     await second.body?.cancel();
     return new Response(null, { status: 502 });
diff --git a/backend/crypt/main_test.js b/backend/crypt/main_test.js
index 3382b01..339e4fb 100644
--- a/backend/crypt/main_test.js
+++ b/backend/crypt/main_test.js
@@ -11,9 +11,6 @@ import { fetch } from "../../mod.js";
 import { mimeType } from "../../lib/mime.js";
 import { decode, default as crypt, deriveKey, encode } from "./main.js";
 
-/** The remotes under the backend, through the fetch of rfetch. */
-const env = { REMOTE: { fetch } };
-
 // The password "123456" and the salt, obscured.
 const PASSWORD = "UmyLSdRHfew6aual28-ggx78qHqSfQ";
 const SALT = "Cj3gLa5PVwc2aot0QpKiOZ3YEzs3Sw";
@@ -124,7 +121,6 @@ test("encode", async () => {
 
 test("GET of the fixtures", async () => {
   const fs = remote(crypt, {
-    env,
     params: { remote: "crypt", password: PASSWORD, password2: SALT },
   });
   for (const name of Object.keys(CRYPT)) {
@@ -149,10 +145,10 @@ const params = {
   password2: SALT,
 };
 
-backendSuite("crypt", crypt, { env, params });
+backendSuite("crypt", crypt, { params });
 
 describe("crypt", () => {
-  const fs = remote(crypt, { env, params });
+  const fs = remote(crypt, { params });
 
   test("puts no password in the links of a list", async () => {
     await fs.put("secret/a b.txt", new TextEncoder().encode("a"));
@@ -182,7 +178,7 @@ describe("crypt", () => {
   });
 
   test("gives 400 for a password that is not obscured", async () => {
-    const bad = remote(crypt, { env, params: { ...params, password: "!!" } });
+    const bad = remote(crypt, { params: { ...params, password: "!!" } });
     const response = await bad.get("");
     assert.equal(response.status, 400);
     assert.ok(!(await response.text()).includes("!!"));
@@ -204,20 +200,14 @@ describe("crypt", () => {
   /** A file of 3 blocks and a part of a block. */
   const content = new Uint8Array(3 * 65536 + 100).map((_, i) => i * 7 + 1);
 
-  test("reads only the header and the blocks of a range", async () => {
+  test("reads only the header and the blocks of a range", async (t) => {
     /** The `Range` of each request to the remote. */
     const ranges = [];
-    const counted = remote(crypt, {
-      params,
-      env: {
-        REMOTE: {
-          fetch(input, init = {}) {
-            ranges.push(new Headers(init.headers).get("Range"));
-            return fetch(input, init);
-          },
-        },
-      },
+    t.mock.method(globalThis, "fetch", (input, init = {}) => {
+      ranges.push(new Headers(init.headers).get("Range"));
+      return fetch(input, init);
     });
+    const counted = remote(crypt, { params });
     await counted.put("blocks.bin", content);
 
     ranges.length = 0;
@@ -242,20 +232,14 @@ describe("crypt", () => {
     assert.deepEqual(ranges, ["bytes=0-31", `bytes=196688-${size - 1}`]);
   });
 
-  test("gives a range when the remote sends all the file", async () => {
+  test("gives a range when the remote sends all the file", async (t) => {
     // A remote that does not read the ranges.
-    const full = remote(crypt, {
-      params,
-      env: {
-        REMOTE: {
-          fetch(input, init = {}) {
-            const headers = new Headers(init.headers);
-            headers.delete("Range");
-            return fetch(input, { ...init, headers });
-          },
-        },
-      },
+    t.mock.method(globalThis, "fetch", (input, init = {}) => {
+      const headers = new Headers(init.headers);
+      headers.delete("Range");
+      return fetch(input, { ...init, headers });
     });
+    const full = remote(crypt, { params });
     await full.put("full.bin", content);
     for (
       const [header, start, end] of [["bytes=70000-140000", 70000, 140000]]
diff --git a/backend/crypt/rclone_test.js b/backend/crypt/rclone_test.js
index 022c483..60f4f97 100644
--- a/backend/crypt/rclone_test.js
+++ b/backend/crypt/rclone_test.js
@@ -19,12 +19,10 @@ import process from "node:process";
 import fc from "fast-check";
 
 import { remote } from "../../lib/testing/remote.js";
-import { fetch } from "../../mod.js";
+// Sets the global `fetch` that reads the paths of remotes.
+import "../../mod.js";
 import crypt from "./main.js";
 
-/** The remotes under the backend, through the fetch of rfetch. */
-const env = { REMOTE: { fetch } };
-
 const RCLONE = process.env.RCLONE || "rclone";
 const hasRclone = spawnSync(RCLONE, ["version"]).status === 0;
 
@@ -73,7 +71,6 @@ describe("crypt and rclone", {
    */
   const rfetch = (name) =>
     remote(crypt, {
-      env,
       params: { remote: name, password: PASSWORD, password2: SALT },
     });
 
diff --git a/backend/http/rclone_test.js b/backend/http/rclone_test.js
index a598e9f..040dcce 100644
--- a/backend/http/rclone_test.js
+++ b/backend/http/rclone_test.js
@@ -13,7 +13,8 @@ import process from "node:process";
 
 import { remote } from "../../lib/testing/remote.js";
 import { listen } from "../../lib/testing/server.js";
-import { fetch } from "../../mod.js";
+// Sets the global `fetch` that reads the paths of remotes.
+import "../../mod.js";
 import chunker from "../chunker/main.js";
 import crypt from "../crypt/main.js";
 import memory from "../memory/main.js";
@@ -181,7 +182,6 @@ describe("rclone reads ranges of rfetch", {
       chunk_size: "64k",
     }],
   };
-  const env = { REMOTE: { fetch } };
   const data = content(3 * 65536 + 1000);
   let server;
 
@@ -194,10 +194,10 @@ describe("rclone reads ranges of rfetch", {
       for (const [key, value] of Object.entries(params)) {
         url.searchParams.set(key, value);
       }
-      return backend.fetch(new Request(url, request), env);
+      return backend.fetch(new Request(url, request));
     });
     for (const [backend, params] of Object.values(BACKENDS)) {
-      const response = await remote(backend, { params, env }).put(
+      const response = await remote(backend, { params }).put(
         "data.bin",
         data,
       );
diff --git a/backend/main.js b/backend/main.js
index 90c1c45..3bec0ec 100644
--- a/backend/main.js
+++ b/backend/main.js
@@ -6,17 +6,12 @@
  * imports nothing of rfetch: it gets all from the request and from `env`.
  *
  * A backend on top of another remote, for example crypt, sends its requests
- * to that remote with `env.REMOTE.fetch`, as a service binding of
- * Cloudflare. With no `REMOTE`, it uses the global `fetch`.
+ * to that remote with the global `fetch`, for example
+ * `fetch(":memory:/path")`. The host sets the global `fetch` that reads
+ * such a path: `mod.js` in Node.js, and `_worker.js` in a Worker.
  *
  * @typedef {Object} Backend
- * @property {(request: Request, env?: Env) => Response | Promise<Response>} fetch
- */
-
-/**
- * @typedef {Object} Env
- * @property {{ fetch: typeof fetch }} [REMOTE] Gets the requests to the
- *   remote under the backend.
+ * @property {(request: Request, env?: Object) => Response | Promise<Response>} fetch
  */
 
 export { default as alias } from "./alias/main.js";
diff --git a/lib/testing/remote.js b/lib/testing/remote.js
index 26c73ba..bc91d98 100644
--- a/lib/testing/remote.js
+++ b/lib/testing/remote.js
@@ -11,7 +11,7 @@ const ORIGIN = "http://rfetch.test";
  * @param {{ fetch: (request: Request, env?: object) => Response | Promise<Response> }} backend
  * @param {{ params?: Record<string, string>, root?: string, env?: object }} [options]
  *   `root` is a folder, for example `/rfetch-test-abc/`, under which all
- *   paths go. `env` is the env of the backend, for example `REMOTE`.
+ *   paths go. `env` is the env of the backend, for example the credentials of s3.
  */
 export function remote(backend, { params = {}, root = "/", env = {} } = {}) {
   /**
diff --git a/lib/testing/suite.js b/lib/testing/suite.js
index 21d06c1..94a5a4b 100644
--- a/lib/testing/suite.js
+++ b/lib/testing/suite.js
@@ -57,7 +57,7 @@ const FILE2 = `hello? sausage/êé/Hello, 世界/ " ' @ < > & ? + ≠/z.txt`;
  *   emptyFolders?: boolean,
  * }} [options] `params` go in the query of each request, for example the
  *   options of the backend. `env` is the env of the backend, for example
- *   `REMOTE`. The tests skip the names that match `skipName`,
+ *   the credentials of s3. The tests skip the names that match `skipName`,
  *   for a limit that the backend has in rclone too. For a backend that is
  *   read only, the PUT and DELETE requests go to `writer`, with no `params`:
  *   a backend that writes the files that the backend under test reads.
diff --git a/mod.js b/mod.js
index 8b66cc2..24fe81c 100644
--- a/mod.js
+++ b/mod.js
@@ -39,8 +39,9 @@ export { Progress } from "./lib/streams/progress.js";
 const globalFetch = globalThis.fetch;
 
 /**
- * A `fetch` with support for remote URL. It does not replace the global
- * `fetch`: import it.
+ * A `fetch` with support for remote URL. The import of this module sets it
+ * as the global `fetch`. Thus a backend on top of other remotes, for example
+ * crypt, calls `fetch(":memory:/path")` and does not import rfetch.
  *
  * The syntax of the paths passed to the rfetch command are as follows.
  *
@@ -229,18 +230,13 @@ export async function fetch(input, init = {}) {
   const url = new URL(`${pathname}?${params}`, import.meta.url || `file:`);
   // Creates a new request with the initial init.
   const request = new Request(url, init);
-  // Clones that request and updates the headers. A backend on top of other
-  // remotes, for example crypt, sends its requests to them with this fetch.
+  // Clones that request and updates the headers.
   return backend.fetch(
     new Request(request, {
       headers,
     }),
-    REMOTE,
   );
 }
 
-/**
- * The env of a backend: `REMOTE` gets the requests of a backend to the
- * remote under it, for example `:memory:/path` for crypt.
- */
-const REMOTE = { REMOTE: { fetch } };
+// The other URLs go to the original `fetch`.
+globalThis.fetch = fetch;

From 2839bc8bb410fde48c8d06b91311072d849a672e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sat, 17 Oct 2026 15:34:23 +0000
Subject: [PATCH 48/87] refactor: move the code of one backend into its folder

lib/list.js goes to backend/http, lib/xml.js goes to backend/s3, and lib/streams/chunker.js goes to backend/drive. Only that backend uses each of these files.
---
 .github/workflows/ci.yml                  | 2 +-
 CONTRIBUTING.md                           | 2 +-
 {lib/streams => backend/drive}/chunker.js | 0
 backend/drive/create.js                   | 2 +-
 {lib => backend/http}/list.js             | 0
 {lib => backend/http}/list_test.js        | 0
 backend/http/main.js                      | 2 +-
 backend/s3/main.js                        | 2 +-
 {lib => backend/s3}/xml.js                | 0
 {lib => backend/s3}/xml_test.js           | 0
 10 files changed, 5 insertions(+), 5 deletions(-)
 rename {lib/streams => backend/drive}/chunker.js (100%)
 rename {lib => backend/http}/list.js (100%)
 rename {lib => backend/http}/list_test.js (100%)
 rename {lib => backend/s3}/xml.js (100%)
 rename {lib => backend/s3}/xml_test.js (100%)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 761d036..d9f399e 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -36,7 +36,7 @@ jobs:
           node-version: ${{ matrix.node }}
           cache: npm
 
-      # Go runs the tests of lib/list.js against encoding/csv.
+      # Go runs the tests of backend/http/list.js against encoding/csv.
       - uses: actions/setup-go@v5
         with:
           go-version: stable
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 3d04c62..c655ded 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -185,7 +185,7 @@ Run all the tests with `npm test`, or the tests of one backend with
 Some tests compare rfetch with rclone, for example the tests of `lib/ini.js` and
 the files `rclone_test.js` of the backends. They run when `rclone` is in the
 `PATH`, or when the variable `RCLONE` is the path of rclone. Else they are
-skipped. The tests of `lib/list.js` compare it with the `encoding/csv` package
+skipped. The tests of `backend/http/list.js` compare it with the `encoding/csv` package
 of Go, when `go` is in the `PATH` or when the variable `GO` is its path.
 
 The tests of `s3` use `rclone serve s3`, a server of the S3 API on a local
diff --git a/lib/streams/chunker.js b/backend/drive/chunker.js
similarity index 100%
rename from lib/streams/chunker.js
rename to backend/drive/chunker.js
diff --git a/backend/drive/create.js b/backend/drive/create.js
index 63628b7..3656dae 100644
--- a/backend/drive/create.js
+++ b/backend/drive/create.js
@@ -1,4 +1,4 @@
-import { Chunker } from "../../lib/streams/chunker.js";
+import { Chunker } from "./chunker.js";
 
 /**
  * @param {Request} request
diff --git a/lib/list.js b/backend/http/list.js
similarity index 100%
rename from lib/list.js
rename to backend/http/list.js
diff --git a/lib/list_test.js b/backend/http/list_test.js
similarity index 100%
rename from lib/list_test.js
rename to backend/http/list_test.js
diff --git a/backend/http/main.js b/backend/http/main.js
index 0698902..32a8c0a 100644
--- a/backend/http/main.js
+++ b/backend/http/main.js
@@ -25,7 +25,7 @@
  */
 
 import { HTMLRewriter } from "@sntran/html-rewriter";
-import { parseList } from "../../lib/list.js";
+import { parseList } from "./list.js";
 import { childOf, renderListing } from "../../lib/listing.js";
 import { mimeType } from "../../lib/mime.js";
 import { decodePath, encodePath } from "../../lib/path.js";
diff --git a/backend/s3/main.js b/backend/s3/main.js
index 73aaa89..b8650fc 100644
--- a/backend/s3/main.js
+++ b/backend/s3/main.js
@@ -54,7 +54,7 @@ import {
   isXMLText,
   parseXML,
   textOf,
-} from "../../lib/xml.js";
+} from "./xml.js";
 import { EMPTY_PAYLOAD, sign, UNSIGNED_PAYLOAD, uriEncode } from "./sigv4.js";
 
 export const options = {
diff --git a/lib/xml.js b/backend/s3/xml.js
similarity index 100%
rename from lib/xml.js
rename to backend/s3/xml.js
diff --git a/lib/xml_test.js b/backend/s3/xml_test.js
similarity index 100%
rename from lib/xml_test.js
rename to backend/s3/xml_test.js

From d692274819770c0f7bf51aef34f38358fb58a3ef Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sat, 17 Oct 2026 15:35:07 +0000
Subject: [PATCH 49/87] refactor: each backend is an npm workspace

Each backend is the package @rfetch/NAME, with its own package.json, and can be a Worker of its own. A backend imports only node: modules, the packages of its package.json, and the files in its folder. The test backend/main_test.js makes sure of this rule.

The code that two or more backends use is in the package @rfetch/lib: format, html, listing, mime, obscure, path, range, size and sized. The shared tests and the bench are in the package @rfetch/testing. The commands obscure and reveal use @rfetch/lib/obscure.

rfetch loads a backend at its first use: backend/main.js has a function import() for each backend, with the literal name of the package, thus the bundler of wrangler finds it. A type that is not a backend gives an error, or 404 in the Worker.
---
 CONTRIBUTING.md                               |  72 +++++--
 _worker.js                                    |   6 +-
 backend/alias/main.js                         |   4 +-
 backend/alias/main_test.js                    |   4 +-
 backend/alias/package.json                    |  28 +++
 backend/chunker/main.js                       |  22 +-
 backend/chunker/main_bench.js                 |   2 +-
 backend/chunker/main_test.js                  |   4 +-
 backend/chunker/package.json                  |  28 +++
 backend/chunker/rclone_test.js                |   2 +-
 backend/crypt/main.js                         |  12 +-
 backend/crypt/main_test.js                    |   6 +-
 backend/crypt/package.json                    |  34 +++
 backend/crypt/rclone_test.js                  |   2 +-
 backend/drive/auth.js                         |   2 +-
 backend/drive/main.js                         |   2 +-
 backend/drive/package.json                    |  25 +++
 backend/http/main.js                          |  16 +-
 backend/http/main_test.js                     |  10 +-
 backend/http/package.json                     |  33 +++
 backend/http/rclone_test.js                   |  10 +-
 backend/local/main.js                         |  10 +-
 backend/local/main_test.js                    |   2 +-
 backend/local/package.json                    |  28 +++
 backend/main.js                               |  37 +++-
 backend/main_test.js                          | 115 ++++++++++
 backend/memory/main.js                        |  10 +-
 backend/memory/main_test.js                   |   2 +-
 backend/memory/package.json                   |  28 +++
 backend/s3/main.js                            |  26 +--
 backend/s3/main_test.js                       |   6 +-
 backend/s3/package.json                       |  29 +++
 backend/s3/rclone_test.js                     |   2 +-
 cmd/help/main.js                              |   2 +-
 cmd/lsjson/main_bench.js                      |   2 +-
 cmd/obscure/main.js                           | 133 +-----------
 cmd/serve/main.js                             |   7 +-
 lib/streams/progress.js                       |   2 +-
 mod.js                                        |  10 +-
 package-lock.json                             | 201 +++++++++++++++++-
 package.json                                  |  19 +-
 {lib => packages/lib}/format.js               |   0
 {lib => packages/lib}/format_test.js          |   0
 {lib => packages/lib}/html.js                 |   0
 {lib => packages/lib}/html_test.js            |   0
 {lib => packages/lib}/listing.js              |   0
 {lib => packages/lib}/mime.js                 |   0
 {lib => packages/lib}/mime_test.js            |   0
 packages/lib/obscure.js                       | 130 +++++++++++
 .../lib/obscure_test.js                       |   2 +-
 packages/lib/package.json                     |  36 ++++
 {lib => packages/lib}/path.js                 |   0
 {lib => packages/lib}/path_test.js            |   0
 {lib => packages/lib}/range.js                |   0
 {lib => packages/lib}/range_test.js           |   0
 {lib => packages/lib}/size.js                 |   0
 {lib => packages/lib}/size_test.js            |   0
 {lib/streams => packages/lib}/sized.js        |   0
 {lib => packages/testing}/bench.js            |   0
 packages/testing/package.json                 |  28 +++
 {lib => packages}/testing/remote.js           |   2 +-
 {lib => packages}/testing/server.js           |   0
 {lib => packages}/testing/suite.js            |   4 +-
 63 files changed, 937 insertions(+), 260 deletions(-)
 create mode 100644 backend/alias/package.json
 create mode 100644 backend/chunker/package.json
 create mode 100644 backend/crypt/package.json
 create mode 100644 backend/drive/package.json
 create mode 100644 backend/http/package.json
 create mode 100644 backend/local/package.json
 create mode 100644 backend/main_test.js
 create mode 100644 backend/memory/package.json
 create mode 100644 backend/s3/package.json
 rename {lib => packages/lib}/format.js (100%)
 rename {lib => packages/lib}/format_test.js (100%)
 rename {lib => packages/lib}/html.js (100%)
 rename {lib => packages/lib}/html_test.js (100%)
 rename {lib => packages/lib}/listing.js (100%)
 rename {lib => packages/lib}/mime.js (100%)
 rename {lib => packages/lib}/mime_test.js (100%)
 create mode 100644 packages/lib/obscure.js
 rename cmd/obscure/main_test.js => packages/lib/obscure_test.js (94%)
 create mode 100644 packages/lib/package.json
 rename {lib => packages/lib}/path.js (100%)
 rename {lib => packages/lib}/path_test.js (100%)
 rename {lib => packages/lib}/range.js (100%)
 rename {lib => packages/lib}/range_test.js (100%)
 rename {lib => packages/lib}/size.js (100%)
 rename {lib => packages/lib}/size_test.js (100%)
 rename {lib/streams => packages/lib}/sized.js (100%)
 rename {lib => packages/testing}/bench.js (100%)
 create mode 100644 packages/testing/package.json
 rename {lib => packages}/testing/remote.js (98%)
 rename {lib => packages}/testing/server.js (100%)
 rename {lib => packages}/testing/suite.js (99%)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index c655ded..442e8e9 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -9,8 +9,12 @@ Choose a name. The docs here will use `remote` as an example.
 Note that in rfetch terminology a file system backend is called a remote or an
 fs.
 
-- Make the folder "backend/remote" with the files "main.js" and "main_test.js"
-  for the new backend. The tests use the test runner of Node.js (`node:test`).
+- Make the folder "backend/remote" with the files "package.json", "main.js" and
+  "main_test.js" for the new backend. The tests use the test runner of Node.js
+  (`node:test`).
+- Add the backend to `backends` in `backend/main.js`, as
+  `remote: () => import("@rfetch/remote")`, and to the `dependencies` of the
+  root "package.json". rfetch loads a backend at its first use.
 - Implements a `fetch` default export function that handles "GET", "PUT" and
   "DELETE".
 - Uses `backend/local/main.js` as reference, or the boilerplate below:
@@ -82,6 +86,42 @@ To count or change the requests to the remote in a test, replace the global
 `fetch` with `t.mock.method(globalThis, "fetch", …)`. The test runner puts the
 original `fetch` back at the end of the test.
 
+## Workspaces
+
+Each backend is an npm workspace with the name `@rfetch/NAME`, and can be a
+Worker of its own: "main.js" is the entry of the Worker. The "package.json" of a
+new backend is:
+
+```json
+{
+  "name": "@rfetch/remote",
+  "version": "0.1.0",
+  "type": "module",
+  "exports": { ".": "./main.js" },
+  "scripts": { "test": "node --test" },
+  "dependencies": { "@rfetch/lib": "^0.1.0" },
+  "devDependencies": { "@rfetch/testing": "^0.1.0" }
+}
+```
+
+Then run `npm install`: npm links the workspace into `node_modules`.
+
+A backend imports only:
+
+- the modules `node:` of Node.js,
+- the packages of its "package.json", for example `@rfetch/lib/listing`,
+- the files in its folder.
+
+The tests and the benches of a backend can also import its `devDependencies`,
+and `../../mod.js` for the global `fetch`. The test `backend/main_test.js` makes
+sure of this rule.
+
+The code that two or more backends use is in the package `@rfetch/lib`, in
+`packages/lib`: `format`, `html`, `listing`, `mime`, `obscure`, `path`, `range`,
+`size` and `sized`. The code that only one backend uses is in the folder of that
+backend, for example `backend/s3/xml.js`. The shared tests are in the package
+`@rfetch/testing`, in `packages/testing`.
+
 ## Architecture
 
 - `GET /folder/`: displays HTML page with folder content.
@@ -102,12 +142,12 @@ The answers:
   `Content-Range` and the `Content-Length` of the range, as RFC 9110. A range
   with no byte of the file gives 416. A request with more ranges, or with a
   range that is not correct, gets all the file. Use `parseRange` of
-  `lib/range.js`.
+  `@rfetch/lib/range`.
 
-The path of a request has percent-encoding. Use `decodePath` of `lib/path.js` to
-get the path with no percent-encoding. It gives `null` for a path that is not
-safe, for example `/..%2Fsecret.txt`, which becomes `/../secret.txt` after the
-decoding. For `null`, give 400.
+The path of a request has percent-encoding. Use `decodePath` of
+`@rfetch/lib/path` to get the path with no percent-encoding. It gives `null` for
+a path that is not safe, for example `/..%2Fsecret.txt`, which becomes
+`/../secret.txt` after the decoding. For `null`, give 400.
 
 For displaying folder content, any HTML can be used, but the listing itself
 should be in a `<table>`, whose each rows are for each file or folder inside.
@@ -118,23 +158,23 @@ modification time.
 
 - The `href` is the name with percent-encoding (`encodeURIComponent`), with a
   `/` at the end for a folder.
-- The text of the link is the name with `escapeHTML` of `lib/html.js`. Do not
-  put a name in the HTML with no escape: a file with the name `<script>.txt`
+- The text of the link is the name with `escapeHTML` of `@rfetch/lib/html`. Do
+  not put a name in the HTML with no escape: a file with the name `<script>.txt`
   must not add a script to the page.
 - `<data value>` is the size in bytes, for a file only.
 - `<time datetime>` is the time in ISO 8601.
 
-`renderListing` of `lib/listing.js` writes such a list from the entries of a
-folder, and `readListing` reads it.
+`renderListing` of `@rfetch/lib/listing` writes such a list from the entries of
+a folder, and `readListing` reads it.
 
 ## Tests of a backend
 
-Each backend must pass the shared tests of `lib/testing/suite.js`. These tests
+Each backend must pass the shared tests of `@rfetch/testing/suite`. These tests
 are as the tests `fstests` of rclone, for the contract above. The file
 "main_test.js" of the backend calls the suite one time:
 
 ```js
-import { backendSuite } from "../../lib/testing/suite.js";
+import { backendSuite } from "@rfetch/testing/suite";
 import backend from "./main.js";
 
 backendSuite("remote", backend);
@@ -180,13 +220,13 @@ For example, the tests of the local backend make sure that a path cannot go out
 of the root folder.
 
 Run all the tests with `npm test`, or the tests of one backend with
-`node --test backend/remote`.
+`npm test -w @rfetch/remote`.
 
 Some tests compare rfetch with rclone, for example the tests of `lib/ini.js` and
 the files `rclone_test.js` of the backends. They run when `rclone` is in the
 `PATH`, or when the variable `RCLONE` is the path of rclone. Else they are
-skipped. The tests of `backend/http/list.js` compare it with the `encoding/csv` package
-of Go, when `go` is in the `PATH` or when the variable `GO` is its path.
+skipped. The tests of `backend/http/list.js` compare it with the `encoding/csv`
+package of Go, when `go` is in the `PATH` or when the variable `GO` is its path.
 
 The tests of `s3` use `rclone serve s3`, a server of the S3 API on a local
 folder. They also run on a real service when the variables `S3_TEST_ENDPOINT`
diff --git a/_worker.js b/_worker.js
index f154e26..bad9370 100644
--- a/_worker.js
+++ b/_worker.js
@@ -1,4 +1,4 @@
-import * as backends from "./backend/main.js";
+import { load } from "./backend/main.js";
 // Sets the global `fetch` that reads the paths of remotes.
 import "./mod.js";
 
@@ -23,10 +23,10 @@ import "./mod.js";
  * @param {string} [params.path]
  * @returns {Promise<Response}
  */
-function remote(request, env, params) {
+async function remote(request, env, params) {
   let { remote, path = "/" } = params;
 
-  const backend = backends[remote];
+  const backend = await load(remote);
   if (!backend) {
     return new Response("Remote not found.", { status: 404 });
   }
diff --git a/backend/alias/main.js b/backend/alias/main.js
index ab5ab7f..c9c92a9 100644
--- a/backend/alias/main.js
+++ b/backend/alias/main.js
@@ -19,8 +19,8 @@
  * allowed as a remote. To alias the current directory use `.` instead.
  */
 
-import { relink } from "../../lib/listing.js";
-import { decodePath, encodePath } from "../../lib/path.js";
+import { relink } from "@rfetch/lib/listing";
+import { decodePath, encodePath } from "@rfetch/lib/path";
 
 /**
  * Sends the requests to the remote of the alias with the global `fetch`.
diff --git a/backend/alias/main_test.js b/backend/alias/main_test.js
index 3fdc81a..6219816 100644
--- a/backend/alias/main_test.js
+++ b/backend/alias/main_test.js
@@ -4,8 +4,8 @@ import { readdir } from "node:fs/promises";
 import { join } from "node:path";
 import assert from "node:assert/strict";
 
-import { backendSuite } from "../../lib/testing/suite.js";
-import { remote } from "../../lib/testing/remote.js";
+import { backendSuite } from "@rfetch/testing/suite";
+import { remote } from "@rfetch/testing/remote";
 // Sets the global `fetch` that reads the paths of remotes.
 import "../../mod.js";
 import backend from "./main.js";
diff --git a/backend/alias/package.json b/backend/alias/package.json
new file mode 100644
index 0000000..13aac15
--- /dev/null
+++ b/backend/alias/package.json
@@ -0,0 +1,28 @@
+{
+  "name": "@rfetch/alias",
+  "version": "0.1.0",
+  "description": "The alias backend of rfetch: a new name for a path in a remote.",
+  "type": "module",
+  "exports": {
+    ".": "./main.js"
+  },
+  "scripts": {
+    "test": "node --test"
+  },
+  "engines": {
+    "node": ">=22.2.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sntran/rfetch.git",
+    "directory": "backend/alias"
+  },
+  "author": "Trần Nguyễn Sơn",
+  "license": "ISC",
+  "dependencies": {
+    "@rfetch/lib": "^0.1.0"
+  },
+  "devDependencies": {
+    "@rfetch/testing": "^0.1.0"
+  }
+}
diff --git a/backend/chunker/main.js b/backend/chunker/main.js
index 0d4fcfa..6bbac68 100644
--- a/backend/chunker/main.js
+++ b/backend/chunker/main.js
@@ -101,17 +101,17 @@
  * metadata enabled.
  */
 import { createHash } from "node:crypto";
-import { readListing, renderListing } from "../../lib/listing.js";
-import { mimeType } from "../../lib/mime.js";
-import { decodePath, encodePath } from "../../lib/path.js";
+import { readListing, renderListing } from "@rfetch/lib/listing";
+import { mimeType } from "@rfetch/lib/mime";
+import { decodePath, encodePath } from "@rfetch/lib/path";
 import {
   notSatisfiable,
   parseRange,
   partialHeaders,
   sliceStream,
-} from "../../lib/range.js";
-import { parseSize } from "../../lib/size.js";
-import { sized } from "../../lib/streams/sized.js";
+} from "@rfetch/lib/range";
+import { parseSize } from "@rfetch/lib/size";
+import { sized } from "@rfetch/lib/sized";
 
 /** The largest metadata that rclone reads, and that it writes, in bytes. */
 const MAX_METADATA_SIZE = 1023;
@@ -403,9 +403,9 @@ async function listRemote(config, dir) {
  * chunks.
  * @typedef {Object} ChunkedFile
  * @property {string} name
- * @property {import("../../lib/listing.js").Entry | undefined} main The
+ * @property {import("@rfetch/lib/listing").Entry | undefined} main The
  *   file with the name on the remote: the file, or its metadata.
- * @property {import("../../lib/listing.js").Entry[] | null} chunks The data
+ * @property {import("@rfetch/lib/listing").Entry[] | null} chunks The data
  *   chunks in their order, or null for a file that is not composite.
  * @property {number} size
  * @property {string} modTime
@@ -416,14 +416,14 @@ async function listRemote(config, dir) {
  * `processEntries` of the chunker of rclone. A file with missing chunks is
  * not in the result.
  * @param {Config} config
- * @param {import("../../lib/listing.js").Entry[]} entries
+ * @param {import("@rfetch/lib/listing").Entry[]} entries
  * @param {(name: string) => Promise<Metadata | null>} metadataOf Reads the
  *   metadata of a file, for a composite file of a transaction.
  */
 async function group(config, entries, metadataOf) {
-  /** @type {Map<string, import("../../lib/listing.js").Entry>} */
+  /** @type {Map<string, import("@rfetch/lib/listing").Entry>} */
   const mains = new Map();
-  /** @type {Map<string, Map<string, import("../../lib/listing.js").Entry[]>>} */
+  /** @type {Map<string, Map<string, import("@rfetch/lib/listing").Entry[]>>} */
   const chunks = new Map();
   const folders = [];
 
diff --git a/backend/chunker/main_bench.js b/backend/chunker/main_bench.js
index 12947f1..a72cdab 100644
--- a/backend/chunker/main_bench.js
+++ b/backend/chunker/main_bench.js
@@ -7,7 +7,7 @@ import { spawn } from "node:child_process";
 import { randomBytes } from "node:crypto";
 import { once } from "node:events";
 import { Writable } from "node:stream";
-import { bench } from "../../lib/bench.js";
+import { bench } from "@rfetch/testing/bench";
 import backend from "./main.js";
 
 const buffer = randomBytes(1024 * 1024 * 10); // 10M
diff --git a/backend/chunker/main_test.js b/backend/chunker/main_test.js
index d5658b9..1aa0fa7 100644
--- a/backend/chunker/main_test.js
+++ b/backend/chunker/main_test.js
@@ -2,8 +2,8 @@ import { describe, test } from "node:test";
 import assert from "node:assert/strict";
 import { createHash } from "node:crypto";
 
-import { backendSuite } from "../../lib/testing/suite.js";
-import { remote } from "../../lib/testing/remote.js";
+import { backendSuite } from "@rfetch/testing/suite";
+import { remote } from "@rfetch/testing/remote";
 import { fetch } from "../../mod.js";
 import backend from "./main.js";
 
diff --git a/backend/chunker/package.json b/backend/chunker/package.json
new file mode 100644
index 0000000..7e8930d
--- /dev/null
+++ b/backend/chunker/package.json
@@ -0,0 +1,28 @@
+{
+  "name": "@rfetch/chunker",
+  "version": "0.1.0",
+  "description": "The chunker backend of rfetch: it cuts large files into chunks, as rclone.",
+  "type": "module",
+  "exports": {
+    ".": "./main.js"
+  },
+  "scripts": {
+    "test": "node --test"
+  },
+  "engines": {
+    "node": ">=22.2.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sntran/rfetch.git",
+    "directory": "backend/chunker"
+  },
+  "author": "Trần Nguyễn Sơn",
+  "license": "ISC",
+  "dependencies": {
+    "@rfetch/lib": "^0.1.0"
+  },
+  "devDependencies": {
+    "@rfetch/testing": "^0.1.0"
+  }
+}
diff --git a/backend/chunker/rclone_test.js b/backend/chunker/rclone_test.js
index 5719aaf..646618b 100644
--- a/backend/chunker/rclone_test.js
+++ b/backend/chunker/rclone_test.js
@@ -19,7 +19,7 @@ import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import process from "node:process";
 
-import { remote } from "../../lib/testing/remote.js";
+import { remote } from "@rfetch/testing/remote";
 // Sets the global `fetch` that reads the paths of remotes.
 import "../../mod.js";
 import chunker from "./main.js";
diff --git a/backend/crypt/main.js b/backend/crypt/main.js
index f686f8b..49867fa 100644
--- a/backend/crypt/main.js
+++ b/backend/crypt/main.js
@@ -95,17 +95,17 @@
 
 import { scryptAsync as scrypt } from "@noble/hashes/scrypt";
 import { HTMLRewriter } from "@sntran/html-rewriter";
-import { formatBytes } from "../../lib/format.js";
-import { mimeType } from "../../lib/mime.js";
-import { decodePath } from "../../lib/path.js";
+import { formatBytes } from "@rfetch/lib/format";
+import { mimeType } from "@rfetch/lib/mime";
+import { decodePath } from "@rfetch/lib/path";
 import {
   notSatisfiable,
   parseRange,
   partialHeaders,
   sliceStream,
-} from "../../lib/range.js";
-import { sized } from "../../lib/streams/sized.js";
-import { reveal } from "../../cmd/obscure/main.js";
+} from "@rfetch/lib/range";
+import { sized } from "@rfetch/lib/sized";
+import { reveal } from "@rfetch/lib/obscure";
 import PathCipher from "./PathCipher.js";
 import {
   decryptedSize,
diff --git a/backend/crypt/main_test.js b/backend/crypt/main_test.js
index 339e4fb..ad1d79b 100644
--- a/backend/crypt/main_test.js
+++ b/backend/crypt/main_test.js
@@ -5,10 +5,10 @@ import process from "node:process";
 import assert from "node:assert/strict";
 import fc from "fast-check";
 
-import { backendSuite } from "../../lib/testing/suite.js";
-import { remote } from "../../lib/testing/remote.js";
+import { backendSuite } from "@rfetch/testing/suite";
+import { remote } from "@rfetch/testing/remote";
 import { fetch } from "../../mod.js";
-import { mimeType } from "../../lib/mime.js";
+import { mimeType } from "@rfetch/lib/mime";
 import { decode, default as crypt, deriveKey, encode } from "./main.js";
 
 // The password "123456" and the salt, obscured.
diff --git a/backend/crypt/package.json b/backend/crypt/package.json
new file mode 100644
index 0000000..7206aa3
--- /dev/null
+++ b/backend/crypt/package.json
@@ -0,0 +1,34 @@
+{
+  "name": "@rfetch/crypt",
+  "version": "0.1.0",
+  "description": "The crypt backend of rfetch: it encrypts the files and their names, as rclone.",
+  "type": "module",
+  "exports": {
+    ".": "./main.js"
+  },
+  "scripts": {
+    "test": "node --test"
+  },
+  "engines": {
+    "node": ">=22.2.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sntran/rfetch.git",
+    "directory": "backend/crypt"
+  },
+  "author": "Trần Nguyễn Sơn",
+  "license": "ISC",
+  "dependencies": {
+    "@noble/ciphers": "^0.5.3",
+    "@noble/hashes": "^1.4.0",
+    "@rfetch/lib": "^0.1.0",
+    "@sntran/html-rewriter": "^0.2.0",
+    "base32-decode": "^1.0.0",
+    "base32-encode": "^2.0.0"
+  },
+  "devDependencies": {
+    "@rfetch/testing": "^0.1.0",
+    "fast-check": "^3.19.0"
+  }
+}
diff --git a/backend/crypt/rclone_test.js b/backend/crypt/rclone_test.js
index 60f4f97..6f66ad9 100644
--- a/backend/crypt/rclone_test.js
+++ b/backend/crypt/rclone_test.js
@@ -18,7 +18,7 @@ import { dirname, join } from "node:path";
 import process from "node:process";
 import fc from "fast-check";
 
-import { remote } from "../../lib/testing/remote.js";
+import { remote } from "@rfetch/testing/remote";
 // Sets the global `fetch` that reads the paths of remotes.
 import "../../mod.js";
 import crypt from "./main.js";
diff --git a/backend/drive/auth.js b/backend/drive/auth.js
index 4d0c086..a68d48e 100644
--- a/backend/drive/auth.js
+++ b/backend/drive/auth.js
@@ -1,6 +1,6 @@
 import { Buffer } from "node:buffer";
 
-import { reveal } from "../../cmd/obscure/main.js";
+import { reveal } from "@rfetch/lib/obscure";
 
 const TOKEN_URL = "https://oauth2.googleapis.com/token";
 
diff --git a/backend/drive/main.js b/backend/drive/main.js
index ed5bd2d..493888b 100644
--- a/backend/drive/main.js
+++ b/backend/drive/main.js
@@ -1,4 +1,4 @@
-import { formatBytes } from "../../lib/format.js";
+import { formatBytes } from "@rfetch/lib/format";
 
 import { auth } from "./auth.js";
 import { list } from "./list.js";
diff --git a/backend/drive/package.json b/backend/drive/package.json
new file mode 100644
index 0000000..06d3c09
--- /dev/null
+++ b/backend/drive/package.json
@@ -0,0 +1,25 @@
+{
+  "name": "@rfetch/drive",
+  "version": "0.1.0",
+  "description": "The Google Drive backend of rfetch.",
+  "type": "module",
+  "exports": {
+    ".": "./main.js"
+  },
+  "scripts": {
+    "test": "node --test"
+  },
+  "engines": {
+    "node": ">=22.2.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sntran/rfetch.git",
+    "directory": "backend/drive"
+  },
+  "author": "Trần Nguyễn Sơn",
+  "license": "ISC",
+  "dependencies": {
+    "@rfetch/lib": "^0.1.0"
+  }
+}
diff --git a/backend/http/main.js b/backend/http/main.js
index 32a8c0a..e0ba06d 100644
--- a/backend/http/main.js
+++ b/backend/http/main.js
@@ -26,9 +26,9 @@
 
 import { HTMLRewriter } from "@sntran/html-rewriter";
 import { parseList } from "./list.js";
-import { childOf, renderListing } from "../../lib/listing.js";
-import { mimeType } from "../../lib/mime.js";
-import { decodePath, encodePath } from "../../lib/path.js";
+import { childOf, renderListing } from "@rfetch/lib/listing";
+import { mimeType } from "@rfetch/lib/mime";
+import { decodePath, encodePath } from "@rfetch/lib/path";
 
 export const options = {
   boolean: [
@@ -243,14 +243,14 @@ async function getFolder(url, method, headers, noHead, query) {
  * of a table of rfetch also give the size and the time.
  * @param {Response} response
  * @param {URL} base The URL of the folder.
- * @returns {Promise<import("../../lib/listing.js").Entry[]>}
+ * @returns {Promise<import("@rfetch/lib/listing").Entry[]>}
  */
 async function readIndex(response, base) {
-  /** @type {import("../../lib/listing.js").Entry[]} */
+  /** @type {import("@rfetch/lib/listing").Entry[]} */
   const entries = [];
   const seen = new Set();
   let inRow = false;
-  /** @type {import("../../lib/listing.js").Entry | null} */
+  /** @type {import("@rfetch/lib/listing").Entry | null} */
   let current = null;
 
   await new HTMLRewriter()
@@ -305,10 +305,10 @@ async function readIndex(response, base) {
  * Sends a HEAD request for each file with no size, as rclone does for each
  * file of a list. As in rclone, a file is not in the list when its HEAD
  * request fails.
- * @param {import("../../lib/listing.js").Entry[]} entries
+ * @param {import("@rfetch/lib/listing").Entry[]} entries
  * @param {URL} base The URL of the folder.
  * @param {Headers} headers
- * @returns {Promise<import("../../lib/listing.js").Entry[]>}
+ * @returns {Promise<import("@rfetch/lib/listing").Entry[]>}
  */
 async function head(entries, base, headers) {
   const files = entries.filter((entry) => !entry.IsDir && entry.Size < 0);
diff --git a/backend/http/main_test.js b/backend/http/main_test.js
index 38a3eca..613e5ee 100644
--- a/backend/http/main_test.js
+++ b/backend/http/main_test.js
@@ -2,11 +2,11 @@ import { after, describe, test } from "node:test";
 import assert from "node:assert/strict";
 import { gzipSync } from "node:zlib";
 
-import { mimeType } from "../../lib/mime.js";
-import { backendSuite } from "../../lib/testing/suite.js";
-import { remote } from "../../lib/testing/remote.js";
-import { listen } from "../../lib/testing/server.js";
-import memory from "../memory/main.js";
+import { mimeType } from "@rfetch/lib/mime";
+import { backendSuite } from "@rfetch/testing/suite";
+import { remote } from "@rfetch/testing/remote";
+import { listen } from "@rfetch/testing/server";
+import memory from "@rfetch/memory";
 import backend from "./main.js";
 
 /** A server of the memory backend, with the headers of each request. */
diff --git a/backend/http/package.json b/backend/http/package.json
new file mode 100644
index 0000000..4829eef
--- /dev/null
+++ b/backend/http/package.json
@@ -0,0 +1,33 @@
+{
+  "name": "@rfetch/http",
+  "version": "0.1.0",
+  "description": "The http backend of rfetch: it reads the folders of a web site, as rclone.",
+  "type": "module",
+  "exports": {
+    ".": "./main.js"
+  },
+  "scripts": {
+    "test": "node --test"
+  },
+  "engines": {
+    "node": ">=22.2.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sntran/rfetch.git",
+    "directory": "backend/http"
+  },
+  "author": "Trần Nguyễn Sơn",
+  "license": "ISC",
+  "dependencies": {
+    "@rfetch/lib": "^0.1.0",
+    "@sntran/html-rewriter": "^0.2.0"
+  },
+  "devDependencies": {
+    "@rfetch/chunker": "^0.1.0",
+    "@rfetch/crypt": "^0.1.0",
+    "@rfetch/memory": "^0.1.0",
+    "@rfetch/testing": "^0.1.0",
+    "fast-check": "^3.19.0"
+  }
+}
diff --git a/backend/http/rclone_test.js b/backend/http/rclone_test.js
index 040dcce..23f1365 100644
--- a/backend/http/rclone_test.js
+++ b/backend/http/rclone_test.js
@@ -11,13 +11,13 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import process from "node:process";
 
-import { remote } from "../../lib/testing/remote.js";
-import { listen } from "../../lib/testing/server.js";
+import { remote } from "@rfetch/testing/remote";
+import { listen } from "@rfetch/testing/server";
 // Sets the global `fetch` that reads the paths of remotes.
 import "../../mod.js";
-import chunker from "../chunker/main.js";
-import crypt from "../crypt/main.js";
-import memory from "../memory/main.js";
+import chunker from "@rfetch/chunker";
+import crypt from "@rfetch/crypt";
+import memory from "@rfetch/memory";
 import http from "./main.js";
 
 const RCLONE = process.env.RCLONE || "rclone";
diff --git a/backend/local/main.js b/backend/local/main.js
index fb6ef5c..da39409 100644
--- a/backend/local/main.js
+++ b/backend/local/main.js
@@ -1,10 +1,10 @@
 import process from "node:process";
 import { dirname, isAbsolute, join, relative, sep } from "node:path";
-import { formatBytes } from "../../lib/format.js";
-import { escapeHTML } from "../../lib/html.js";
-import { mimeType } from "../../lib/mime.js";
-import { decodePath } from "../../lib/path.js";
-import { notSatisfiable, parseRange, partialHeaders } from "../../lib/range.js";
+import { formatBytes } from "@rfetch/lib/format";
+import { escapeHTML } from "@rfetch/lib/html";
+import { mimeType } from "@rfetch/lib/mime";
+import { decodePath } from "@rfetch/lib/path";
+import { notSatisfiable, parseRange, partialHeaders } from "@rfetch/lib/range";
 
 /**
  * Serves a local remote: the files and the folders in the current folder.
diff --git a/backend/local/main_test.js b/backend/local/main_test.js
index c63fd68..ea1f163 100644
--- a/backend/local/main_test.js
+++ b/backend/local/main_test.js
@@ -12,7 +12,7 @@ import {
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 
-import { backendSuite } from "../../lib/testing/suite.js";
+import { backendSuite } from "@rfetch/testing/suite";
 import backend from "./main.js";
 
 // The backend serves the current folder. The tests use a new folder as the
diff --git a/backend/local/package.json b/backend/local/package.json
new file mode 100644
index 0000000..bf2ab58
--- /dev/null
+++ b/backend/local/package.json
@@ -0,0 +1,28 @@
+{
+  "name": "@rfetch/local",
+  "version": "0.1.0",
+  "description": "The local backend of rfetch: the files of the local disk.",
+  "type": "module",
+  "exports": {
+    ".": "./main.js"
+  },
+  "scripts": {
+    "test": "node --test"
+  },
+  "engines": {
+    "node": ">=22.2.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sntran/rfetch.git",
+    "directory": "backend/local"
+  },
+  "author": "Trần Nguyễn Sơn",
+  "license": "ISC",
+  "dependencies": {
+    "@rfetch/lib": "^0.1.0"
+  },
+  "devDependencies": {
+    "@rfetch/testing": "^0.1.0"
+  }
+}
diff --git a/backend/main.js b/backend/main.js
index 3bec0ec..e6dc410 100644
--- a/backend/main.js
+++ b/backend/main.js
@@ -14,11 +14,32 @@
  * @property {(request: Request, env?: Object) => Response | Promise<Response>} fetch
  */
 
-export { default as alias } from "./alias/main.js";
-export { default as chunker } from "./chunker/main.js";
-export { default as crypt } from "./crypt/main.js";
-export { default as drive } from "./drive/main.js";
-export { default as http } from "./http/main.js";
-export { default as local } from "./local/main.js";
-export { default as memory } from "./memory/main.js";
-export { default as s3 } from "./s3/main.js";
+/**
+ * The backends of rfetch, by type. Each backend is the npm package
+ * `@rfetch/TYPE`. It loads at its first use, thus rfetch loads only the
+ * backends that it needs. The names of the packages are literal, thus a
+ * bundler, for example the bundler of wrangler, can find them.
+ * @type {Record<string, () => Promise<{ default: Backend }>>}
+ */
+export const backends = {
+  alias: () => import("@rfetch/alias"),
+  chunker: () => import("@rfetch/chunker"),
+  crypt: () => import("@rfetch/crypt"),
+  drive: () => import("@rfetch/drive"),
+  http: () => import("@rfetch/http"),
+  local: () => import("@rfetch/local"),
+  memory: () => import("@rfetch/memory"),
+  s3: () => import("@rfetch/s3"),
+};
+
+/**
+ * Loads a backend.
+ * @param {string} type For example `crypt`.
+ * @returns {Promise<Backend | undefined>} `undefined` for a type that is not
+ *   a backend of rfetch.
+ */
+export async function load(type) {
+  if (!Object.hasOwn(backends, type)) return undefined;
+  const { default: backend } = await backends[type]();
+  return backend;
+}
diff --git a/backend/main_test.js b/backend/main_test.js
new file mode 100644
index 0000000..1fd1adf
--- /dev/null
+++ b/backend/main_test.js
@@ -0,0 +1,115 @@
+/**
+ * The tests of the registry of the backends, and of the rule of the
+ * workspaces: a backend or a package imports only `node:` modules, the
+ * packages of its `package.json`, and the files in its folder. Thus each one
+ * is standalone, and can be a Worker of its own.
+ */
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { dirname, join, relative, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { backends, load } from "./main.js";
+
+const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+
+/** The folders of the workspaces, for example `backend/crypt`. */
+const WORKSPACES = JSON.parse(readFileSync(join(ROOT, "package.json")))
+  .workspaces.flatMap((pattern) => {
+    const parent = pattern.replace(/\/\*$/, "");
+    return readdirSync(join(ROOT, parent), { withFileTypes: true })
+      .filter((entry) => entry.isDirectory())
+      .map((entry) => `${parent}/${entry.name}`)
+      .filter((folder) => existsSync(join(ROOT, folder, "package.json")));
+  });
+
+/**
+ * The files of a test or a bench. They can import the devDependencies, and
+ * `mod.js` of rfetch: it sets the global `fetch` that reads the paths of
+ * remotes, for the tests of a backend on top of other remotes.
+ * @param {string} file
+ */
+function isTest(file) {
+  return /(_test|_bench)\.js$|^testing\.js$/.test(file.split(sep).at(-1));
+}
+
+/** @param {string} folder @returns {string[]} The JavaScript files. */
+function filesOf(folder) {
+  return readdirSync(folder, { recursive: true })
+    .filter((file) => file.endsWith(".js"))
+    .filter((file) => !file.split(sep).includes("node_modules"));
+}
+
+/** @param {string} source @returns {string[]} The specifiers of imports. */
+function importsOf(source) {
+  const pattern =
+    /\bfrom\s+"([^"]+)"|\bimport\s+"([^"]+)"|\bimport\(\s*"([^"]+)"\s*\)/g;
+  return [...source.matchAll(pattern)].map((match) =>
+    match[1] ?? match[2] ?? match[3]
+  );
+}
+
+/** @param {string} specifier For example `@rfetch/lib/listing`. */
+function packageOf(specifier) {
+  const parts = specifier.split("/");
+  return specifier.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0];
+}
+
+test("each backend is in the registry, with its package name", () => {
+  const folders = WORKSPACES.filter((folder) => folder.startsWith("backend/"))
+    .map((folder) => folder.slice("backend/".length));
+  assert.deepEqual(Object.keys(backends).sort(), folders.sort());
+  for (const name of folders) {
+    const { name: packageName } = JSON.parse(
+      readFileSync(join(ROOT, "backend", name, "package.json")),
+    );
+    assert.equal(packageName, `@rfetch/${name}`);
+  }
+});
+
+test("load gives each backend, and nothing for other names", async () => {
+  for (const type of Object.keys(backends)) {
+    const backend = await load(type);
+    assert.equal(typeof backend?.fetch, "function", type);
+  }
+  for (const type of ["lib", "testing", "constructor", "__proto__", ""]) {
+    assert.equal(await load(type), undefined, type);
+  }
+});
+
+test("each workspace imports only node:, its packages, and its files", () => {
+  for (const folder of WORKSPACES) {
+    const path = join(ROOT, folder);
+    const { dependencies = {}, devDependencies = {} } = JSON.parse(
+      readFileSync(join(path, "package.json")),
+    );
+    for (const file of filesOf(path)) {
+      const source = readFileSync(join(path, file), "utf8");
+      for (const specifier of importsOf(source)) {
+        const where = `${folder}/${file}: ${specifier}`;
+        if (specifier.startsWith("node:")) continue;
+        if (specifier.startsWith(".")) {
+          const target = relative(
+            path,
+            resolve(path, dirname(file), specifier),
+          );
+          const isHost = isTest(file) &&
+            resolve(path, dirname(file), specifier) ===
+              join(ROOT, "mod.js");
+          assert.ok(
+            isHost || !target.startsWith(".."),
+            `${where} is out of the folder`,
+          );
+          continue;
+        }
+        const name = packageOf(specifier);
+        assert.ok(
+          Object.hasOwn(dependencies, name) ||
+            (isTest(file) && Object.hasOwn(devDependencies, name)),
+          `${where} is not in package.json`,
+        );
+      }
+    }
+  }
+});
diff --git a/backend/memory/main.js b/backend/memory/main.js
index bbfdfb6..3acb12f 100644
--- a/backend/memory/main.js
+++ b/backend/memory/main.js
@@ -7,10 +7,10 @@
  * Because it has no parameters you can just use it with the `:memory:` remote
  * name.
  */
-import { renderListing } from "../../lib/listing.js";
-import { mimeType } from "../../lib/mime.js";
-import { decodePath } from "../../lib/path.js";
-import { notSatisfiable, parseRange, partialHeaders } from "../../lib/range.js";
+import { renderListing } from "@rfetch/lib/listing";
+import { mimeType } from "@rfetch/lib/mime";
+import { decodePath } from "@rfetch/lib/path";
+import { notSatisfiable, parseRange, partialHeaders } from "@rfetch/lib/range";
 
 /**
  * The files and the folders, by their path with no percent-encoding. The path
@@ -130,7 +130,7 @@ async function memory(request) {
 function listing(path, searchParams) {
   // The children are the paths in the folder with no other "/" than a "/" at
   // the end for a folder.
-  /** @type {import("../../lib/listing.js").Entry[]} */
+  /** @type {import("@rfetch/lib/listing").Entry[]} */
   const entries = [];
   for (const [key, file] of cache) {
     if (key === path || !key.startsWith(path)) continue;
diff --git a/backend/memory/main_test.js b/backend/memory/main_test.js
index 0a352ed..3f8dfda 100644
--- a/backend/memory/main_test.js
+++ b/backend/memory/main_test.js
@@ -1,4 +1,4 @@
-import { backendSuite } from "../../lib/testing/suite.js";
+import { backendSuite } from "@rfetch/testing/suite";
 import backend from "./main.js";
 
 backendSuite("memory", backend);
diff --git a/backend/memory/package.json b/backend/memory/package.json
new file mode 100644
index 0000000..454f649
--- /dev/null
+++ b/backend/memory/package.json
@@ -0,0 +1,28 @@
+{
+  "name": "@rfetch/memory",
+  "version": "0.1.0",
+  "description": "The memory backend of rfetch: files in memory.",
+  "type": "module",
+  "exports": {
+    ".": "./main.js"
+  },
+  "scripts": {
+    "test": "node --test"
+  },
+  "engines": {
+    "node": ">=22.2.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sntran/rfetch.git",
+    "directory": "backend/memory"
+  },
+  "author": "Trần Nguyễn Sơn",
+  "license": "ISC",
+  "dependencies": {
+    "@rfetch/lib": "^0.1.0"
+  },
+  "devDependencies": {
+    "@rfetch/testing": "^0.1.0"
+  }
+}
diff --git a/backend/s3/main.js b/backend/s3/main.js
index b8650fc..b909d37 100644
--- a/backend/s3/main.js
+++ b/backend/s3/main.js
@@ -37,24 +37,18 @@
  * credentials in `env`, not in a URL.
  */
 import { createHash } from "node:crypto";
-import { renderListing } from "../../lib/listing.js";
-import { mimeType } from "../../lib/mime.js";
-import { decodePath } from "../../lib/path.js";
+import { renderListing } from "@rfetch/lib/listing";
+import { mimeType } from "@rfetch/lib/mime";
+import { decodePath } from "@rfetch/lib/path";
 import {
   notSatisfiable,
   parseRange,
   partialHeaders,
   sliceStream,
-} from "../../lib/range.js";
-import { parseSize } from "../../lib/size.js";
-import { sized } from "../../lib/streams/sized.js";
-import {
-  childrenOf,
-  escapeXML,
-  isXMLText,
-  parseXML,
-  textOf,
-} from "./xml.js";
+} from "@rfetch/lib/range";
+import { parseSize } from "@rfetch/lib/size";
+import { sized } from "@rfetch/lib/sized";
+import { childrenOf, escapeXML, isXMLText, parseXML, textOf } from "./xml.js";
 import { EMPTY_PAYLOAD, sign, UNSIGNED_PAYLOAD, uriEncode } from "./sigv4.js";
 
 export const options = {
@@ -490,7 +484,7 @@ async function getFolder(config, bucket, prefix, method, query) {
 /**
  * The buckets, as folders.
  * @param {Config} config
- * @returns {Promise<import("../../lib/listing.js").Entry[]>}
+ * @returns {Promise<import("@rfetch/lib/listing").Entry[]>}
  */
 async function listBuckets(config) {
   const response = await check(await send(config, "GET", "", ""));
@@ -510,11 +504,11 @@ async function listBuckets(config) {
  * @param {Config} config
  * @param {string} bucket
  * @param {string} prefix "" for the root of the bucket.
- * @returns {Promise<import("../../lib/listing.js").Entry[] | null>} null when
+ * @returns {Promise<import("@rfetch/lib/listing").Entry[] | null>} null when
  *   the folder does not exist.
  */
 async function listFolder(config, bucket, prefix) {
-  /** @type {import("../../lib/listing.js").Entry[]} */
+  /** @type {import("@rfetch/lib/listing").Entry[]} */
   const entries = [];
   let found = false;
   let token = "";
diff --git a/backend/s3/main_test.js b/backend/s3/main_test.js
index e88b270..138055d 100644
--- a/backend/s3/main_test.js
+++ b/backend/s3/main_test.js
@@ -8,9 +8,9 @@ import assert from "node:assert/strict";
 import { spawnSync } from "node:child_process";
 import process from "node:process";
 
-import { backendSuite } from "../../lib/testing/suite.js";
-import { remote } from "../../lib/testing/remote.js";
-import { listen } from "../../lib/testing/server.js";
+import { backendSuite } from "@rfetch/testing/suite";
+import { remote } from "@rfetch/testing/remote";
+import { listen } from "@rfetch/testing/server";
 import s3 from "./main.js";
 import { KEYS, serveS3 } from "./testing.js";
 
diff --git a/backend/s3/package.json b/backend/s3/package.json
new file mode 100644
index 0000000..87bff1b
--- /dev/null
+++ b/backend/s3/package.json
@@ -0,0 +1,29 @@
+{
+  "name": "@rfetch/s3",
+  "version": "0.1.0",
+  "description": "The s3 backend of rfetch: Amazon S3 and the services with the same API, for example Cloudflare R2.",
+  "type": "module",
+  "exports": {
+    ".": "./main.js"
+  },
+  "scripts": {
+    "test": "node --test"
+  },
+  "engines": {
+    "node": ">=22.2.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sntran/rfetch.git",
+    "directory": "backend/s3"
+  },
+  "author": "Trần Nguyễn Sơn",
+  "license": "ISC",
+  "dependencies": {
+    "@rfetch/lib": "^0.1.0"
+  },
+  "devDependencies": {
+    "@rfetch/testing": "^0.1.0",
+    "fast-check": "^3.19.0"
+  }
+}
diff --git a/backend/s3/rclone_test.js b/backend/s3/rclone_test.js
index ae7b244..fd4985a 100644
--- a/backend/s3/rclone_test.js
+++ b/backend/s3/rclone_test.js
@@ -10,7 +10,7 @@ import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import process from "node:process";
 
-import { remote } from "../../lib/testing/remote.js";
+import { remote } from "@rfetch/testing/remote";
 import { KEYS, serveS3 } from "./testing.js";
 import s3 from "./main.js";
 
diff --git a/cmd/help/main.js b/cmd/help/main.js
index bcc23ce..2c67c84 100644
--- a/cmd/help/main.js
+++ b/cmd/help/main.js
@@ -1,4 +1,4 @@
-import * as backends from "../../backend/main.js";
+import { backends } from "../../backend/main.js";
 import * as commands from "../main.js";
 
 /**
diff --git a/cmd/lsjson/main_bench.js b/cmd/lsjson/main_bench.js
index 1693341..1d4743b 100644
--- a/cmd/lsjson/main_bench.js
+++ b/cmd/lsjson/main_bench.js
@@ -8,7 +8,7 @@
  */
 import { spawn } from "node:child_process";
 import { Readable } from "node:stream";
-import { bench } from "../../lib/bench.js";
+import { bench } from "@rfetch/testing/bench";
 import { lsjson } from "./main.js";
 
 const remotes = ["./", "./backend/", "./cmd/"];
diff --git a/cmd/obscure/main.js b/cmd/obscure/main.js
index 9d20f48..25fafd5 100644
--- a/cmd/obscure/main.js
+++ b/cmd/obscure/main.js
@@ -1,130 +1,3 @@
-const ALGORITHM = "AES-CTR";
-
-/** @type {Promise<CryptoKey> | undefined} */
-let key;
-
-/**
- * Gives the key of rclone for `obscure`. The import happens at the first use,
- * not at the load of the module: a top-level await breaks the bundle of a
- * Worker, and a Worker cannot use some APIs at the load.
- * @returns {Promise<CryptoKey>}
- */
-function getKey() {
-  key ??= crypto.subtle.importKey(
-    "raw",
-    // https://github.com/rclone/rclone/blob/10c884552caab3d3d8484ed3401e94f983a23f93/fs/config/obscure/obscure.go#L17-L22
-    Uint8Array.from([
-      0x9c,
-      0x93,
-      0x5b,
-      0x48,
-      0x73,
-      0x0a,
-      0x55,
-      0x4d,
-      0x6b,
-      0xfd,
-      0x7c,
-      0x63,
-      0xc8,
-      0x86,
-      0xa9,
-      0x2b,
-      0xd3,
-      0x90,
-      0x19,
-      0x8e,
-      0xb8,
-      0x12,
-      0x8a,
-      0xfb,
-      0xf4,
-      0xde,
-      0x16,
-      0x2b,
-      0x8b,
-      0x95,
-      0xf6,
-      0x38,
-    ]),
-    ALGORITHM,
-    false,
-    ["encrypt", "decrypt"],
-  );
-  return key;
-}
-
-const BlockSize = 16;
-
-/**
- * Obscrures a password by encrypting them and writing them out in base64.
- * @param {string} password
- * @returns {Promise<Response>} A Response containing the obscured password.
- */
-export async function obscure(password) {
-  const plaintext = new TextEncoder().encode(password);
-  // Constructs the initial empty ciphertext buffer containing the IV and the encrypted text.
-  const ciphertext = new Uint8Array(BlockSize + plaintext.length);
-  // Constructs the IV buffer.
-  const iv = ciphertext.subarray(0, BlockSize);
-  // Fills IV buffer with random bytes.
-  crypto.getRandomValues(iv);
-  // Encrypts the plaintext into the encrypted buffer.
-  const encrypted = await crypto.subtle.encrypt(
-    {
-      name: ALGORITHM,
-      counter: iv,
-      length: 64,
-    },
-    await getKey(),
-    plaintext,
-  );
-  // Copies the encrypted buffer into the ciphertext buffer.
-  ciphertext.set(new Uint8Array(encrypted), BlockSize);
-  // Encodes the ciphertext buffer into a base64 string.
-  const encoded = btoa(String.fromCharCode(...ciphertext));
-
-  return new Response(encoded);
-}
-
-/**
- * Reveals obscured text by decrypting them
- * @param {string} cipherText
- * @returns {Promise<Response>}
- */
-export async function reveal(cipherText) {
-  // Decodes the base64 string into a ciphertext buffer.
-  const bytes = base64(cipherText);
-  // Constructs the IV buffer from the first block of the ciphertext buffer.
-  const iv = bytes.subarray(0, BlockSize);
-  // Constructs the encrypted buffer from the remaining blocks of the ciphertext buffer.
-  const data = bytes.subarray(BlockSize);
-  // Decrypts the encrypted buffer into the plaintext buffer.
-  const plaintext = await crypto.subtle.decrypt(
-    {
-      name: ALGORITHM,
-      counter: iv,
-      length: 64,
-    },
-    await getKey(),
-    data,
-  );
-
-  return new Response(plaintext);
-}
-
-/**
- * Encodes a string into a base64 Uint8Array.
- * @param {string} s
- * @returns {Uint8Array}
- */
-function base64(s) {
-  // Replace non-url compatible chars with base64 standard chars
-  s = s.replace(/-/g, "+").replace(/_/g, "/");
-  // Pad out with standard base64 required padding characters
-  const pad = s.length % 4;
-  if (pad != 0) {
-    s += "====".substring(0, 4 - pad);
-  }
-  return new Uint8Array(atob(s).split("").map((c) => c.charCodeAt(0)));
-}
+// The code of the commands obscure and reveal is in @rfetch/lib, because the
+// backends crypt and drive also use reveal.
+export { obscure, reveal } from "@rfetch/lib/obscure";
diff --git a/cmd/serve/main.js b/cmd/serve/main.js
index a2f798a..aa82171 100644
--- a/cmd/serve/main.js
+++ b/cmd/serve/main.js
@@ -1,5 +1,5 @@
 import { fetch } from "../../mod.js";
-import * as backends from "../../backend/main.js";
+import { load } from "../../backend/main.js";
 
 /**
  * Serves a remote backend
@@ -24,7 +24,10 @@ export async function serve(protocol, remote, flags = {}) {
     }
   });
 
-  const backend = backends[type];
+  const backend = await load(type);
+  if (!backend) {
+    throw new Error(`Backend ${type} not found.`);
+  }
 
   if (protocol === "http") {
     const { serve } = await import("./http/main.js");
diff --git a/lib/streams/progress.js b/lib/streams/progress.js
index 8b4a078..238d2b5 100644
--- a/lib/streams/progress.js
+++ b/lib/streams/progress.js
@@ -1,4 +1,4 @@
-import { formatBytes, formatDuration } from "../format.js";
+import { formatBytes, formatDuration } from "@rfetch/lib/format";
 
 export class Progress extends TransformStream {
   completed = 0;
diff --git a/mod.js b/mod.js
index 24fe81c..be22ae0 100644
--- a/mod.js
+++ b/mod.js
@@ -1,5 +1,5 @@
 import { env } from "node:process";
-import * as backends from "./backend/main.js";
+import { load } from "./backend/main.js";
 import * as commands from "./cmd/main.js";
 import { parse } from "./lib/fspath.js";
 
@@ -222,10 +222,10 @@ export async function fetch(input, init = {}) {
     init.duplex = "half"; // Must set this for stream body.
   }
 
-  /**
-   * @type {import("./backend/main.js").Backend}
-   */
-  const backend = backends[type];
+  const backend = await load(type);
+  if (!backend) {
+    throw new Error(`Backend ${type} not found.`);
+  }
 
   const url = new URL(`${pathname}?${params}`, import.meta.url || `file:`);
   // Creates a new request with the initial init.
diff --git a/package-lock.json b/package-lock.json
index 244f5db..b50eb11 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -8,18 +8,148 @@
       "name": "rfetch",
       "version": "0.1.0",
       "license": "ISC",
+      "workspaces": [
+        "packages/*",
+        "backend/*"
+      ],
+      "dependencies": {
+        "@rfetch/alias": "^0.1.0",
+        "@rfetch/chunker": "^0.1.0",
+        "@rfetch/crypt": "^0.1.0",
+        "@rfetch/drive": "^0.1.0",
+        "@rfetch/http": "^0.1.0",
+        "@rfetch/lib": "^0.1.0",
+        "@rfetch/local": "^0.1.0",
+        "@rfetch/memory": "^0.1.0",
+        "@rfetch/s3": "^0.1.0",
+        "@sntran/html-rewriter": "^0.2.0",
+        "@sntran/serve": "^0.0.1"
+      },
+      "bin": {
+        "rfetch": "main.js"
+      },
+      "devDependencies": {
+        "fast-check": "^3.19.0"
+      },
+      "engines": {
+        "node": ">=22.2.0"
+      }
+    },
+    "backend/alias": {
+      "name": "@rfetch/alias",
+      "version": "0.1.0",
+      "license": "ISC",
+      "dependencies": {
+        "@rfetch/lib": "^0.1.0"
+      },
+      "devDependencies": {
+        "@rfetch/testing": "^0.1.0"
+      },
+      "engines": {
+        "node": ">=22.2.0"
+      }
+    },
+    "backend/chunker": {
+      "name": "@rfetch/chunker",
+      "version": "0.1.0",
+      "license": "ISC",
+      "dependencies": {
+        "@rfetch/lib": "^0.1.0"
+      },
+      "devDependencies": {
+        "@rfetch/testing": "^0.1.0"
+      },
+      "engines": {
+        "node": ">=22.2.0"
+      }
+    },
+    "backend/crypt": {
+      "name": "@rfetch/crypt",
+      "version": "0.1.0",
+      "license": "ISC",
       "dependencies": {
         "@noble/ciphers": "^0.5.3",
         "@noble/hashes": "^1.4.0",
+        "@rfetch/lib": "^0.1.0",
         "@sntran/html-rewriter": "^0.2.0",
-        "@sntran/serve": "^0.0.1",
         "base32-decode": "^1.0.0",
         "base32-encode": "^2.0.0"
       },
-      "bin": {
-        "rfetch": "main.js"
+      "devDependencies": {
+        "@rfetch/testing": "^0.1.0",
+        "fast-check": "^3.19.0"
+      },
+      "engines": {
+        "node": ">=22.2.0"
+      }
+    },
+    "backend/drive": {
+      "name": "@rfetch/drive",
+      "version": "0.1.0",
+      "license": "ISC",
+      "dependencies": {
+        "@rfetch/lib": "^0.1.0"
+      },
+      "engines": {
+        "node": ">=22.2.0"
+      }
+    },
+    "backend/http": {
+      "name": "@rfetch/http",
+      "version": "0.1.0",
+      "license": "ISC",
+      "dependencies": {
+        "@rfetch/lib": "^0.1.0",
+        "@sntran/html-rewriter": "^0.2.0"
+      },
+      "devDependencies": {
+        "@rfetch/chunker": "^0.1.0",
+        "@rfetch/crypt": "^0.1.0",
+        "@rfetch/memory": "^0.1.0",
+        "@rfetch/testing": "^0.1.0",
+        "fast-check": "^3.19.0"
+      },
+      "engines": {
+        "node": ">=22.2.0"
+      }
+    },
+    "backend/local": {
+      "name": "@rfetch/local",
+      "version": "0.1.0",
+      "license": "ISC",
+      "dependencies": {
+        "@rfetch/lib": "^0.1.0"
+      },
+      "devDependencies": {
+        "@rfetch/testing": "^0.1.0"
+      },
+      "engines": {
+        "node": ">=22.2.0"
+      }
+    },
+    "backend/memory": {
+      "name": "@rfetch/memory",
+      "version": "0.1.0",
+      "license": "ISC",
+      "dependencies": {
+        "@rfetch/lib": "^0.1.0"
+      },
+      "devDependencies": {
+        "@rfetch/testing": "^0.1.0"
+      },
+      "engines": {
+        "node": ">=22.2.0"
+      }
+    },
+    "backend/s3": {
+      "name": "@rfetch/s3",
+      "version": "0.1.0",
+      "license": "ISC",
+      "dependencies": {
+        "@rfetch/lib": "^0.1.0"
       },
       "devDependencies": {
+        "@rfetch/testing": "^0.1.0",
         "fast-check": "^3.19.0"
       },
       "engines": {
@@ -45,6 +175,46 @@
         "url": "https://paulmillr.com/funding/"
       }
     },
+    "node_modules/@rfetch/alias": {
+      "resolved": "backend/alias",
+      "link": true
+    },
+    "node_modules/@rfetch/chunker": {
+      "resolved": "backend/chunker",
+      "link": true
+    },
+    "node_modules/@rfetch/crypt": {
+      "resolved": "backend/crypt",
+      "link": true
+    },
+    "node_modules/@rfetch/drive": {
+      "resolved": "backend/drive",
+      "link": true
+    },
+    "node_modules/@rfetch/http": {
+      "resolved": "backend/http",
+      "link": true
+    },
+    "node_modules/@rfetch/lib": {
+      "resolved": "packages/lib",
+      "link": true
+    },
+    "node_modules/@rfetch/local": {
+      "resolved": "backend/local",
+      "link": true
+    },
+    "node_modules/@rfetch/memory": {
+      "resolved": "backend/memory",
+      "link": true
+    },
+    "node_modules/@rfetch/s3": {
+      "resolved": "backend/s3",
+      "link": true
+    },
+    "node_modules/@rfetch/testing": {
+      "resolved": "packages/testing",
+      "link": true
+    },
     "node_modules/@sntran/html-rewriter": {
       "version": "0.2.0",
       "resolved": "https://registry.npmjs.org/@sntran/html-rewriter/-/html-rewriter-0.2.0.tgz",
@@ -124,6 +294,31 @@
       "engines": {
         "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
       }
+    },
+    "packages/lib": {
+      "name": "@rfetch/lib",
+      "version": "0.1.0",
+      "license": "ISC",
+      "dependencies": {
+        "@sntran/html-rewriter": "^0.2.0"
+      },
+      "devDependencies": {
+        "fast-check": "^3.19.0"
+      },
+      "engines": {
+        "node": ">=22.2.0"
+      }
+    },
+    "packages/testing": {
+      "name": "@rfetch/testing",
+      "version": "0.1.0",
+      "license": "ISC",
+      "dependencies": {
+        "@rfetch/lib": "^0.1.0"
+      },
+      "engines": {
+        "node": ">=22.2.0"
+      }
     }
   }
 }
diff --git a/package.json b/package.json
index 4224964..69452c9 100644
--- a/package.json
+++ b/package.json
@@ -10,6 +10,10 @@
   },
   "main": "mod.js",
   "type": "module",
+  "workspaces": [
+    "packages/*",
+    "backend/*"
+  ],
   "repository": {
     "type": "git",
     "url": "git+https://github.com/sntran/rfetch.git"
@@ -27,12 +31,17 @@
   },
   "homepage": "https://github.com/sntran/rfetch#readme",
   "dependencies": {
-    "@noble/ciphers": "^0.5.3",
-    "@noble/hashes": "^1.4.0",
+    "@rfetch/alias": "^0.1.0",
+    "@rfetch/chunker": "^0.1.0",
+    "@rfetch/crypt": "^0.1.0",
+    "@rfetch/drive": "^0.1.0",
+    "@rfetch/http": "^0.1.0",
+    "@rfetch/lib": "^0.1.0",
+    "@rfetch/local": "^0.1.0",
+    "@rfetch/memory": "^0.1.0",
+    "@rfetch/s3": "^0.1.0",
     "@sntran/html-rewriter": "^0.2.0",
-    "@sntran/serve": "^0.0.1",
-    "base32-decode": "^1.0.0",
-    "base32-encode": "^2.0.0"
+    "@sntran/serve": "^0.0.1"
   },
   "devDependencies": {
     "fast-check": "^3.19.0"
diff --git a/lib/format.js b/packages/lib/format.js
similarity index 100%
rename from lib/format.js
rename to packages/lib/format.js
diff --git a/lib/format_test.js b/packages/lib/format_test.js
similarity index 100%
rename from lib/format_test.js
rename to packages/lib/format_test.js
diff --git a/lib/html.js b/packages/lib/html.js
similarity index 100%
rename from lib/html.js
rename to packages/lib/html.js
diff --git a/lib/html_test.js b/packages/lib/html_test.js
similarity index 100%
rename from lib/html_test.js
rename to packages/lib/html_test.js
diff --git a/lib/listing.js b/packages/lib/listing.js
similarity index 100%
rename from lib/listing.js
rename to packages/lib/listing.js
diff --git a/lib/mime.js b/packages/lib/mime.js
similarity index 100%
rename from lib/mime.js
rename to packages/lib/mime.js
diff --git a/lib/mime_test.js b/packages/lib/mime_test.js
similarity index 100%
rename from lib/mime_test.js
rename to packages/lib/mime_test.js
diff --git a/packages/lib/obscure.js b/packages/lib/obscure.js
new file mode 100644
index 0000000..9d20f48
--- /dev/null
+++ b/packages/lib/obscure.js
@@ -0,0 +1,130 @@
+const ALGORITHM = "AES-CTR";
+
+/** @type {Promise<CryptoKey> | undefined} */
+let key;
+
+/**
+ * Gives the key of rclone for `obscure`. The import happens at the first use,
+ * not at the load of the module: a top-level await breaks the bundle of a
+ * Worker, and a Worker cannot use some APIs at the load.
+ * @returns {Promise<CryptoKey>}
+ */
+function getKey() {
+  key ??= crypto.subtle.importKey(
+    "raw",
+    // https://github.com/rclone/rclone/blob/10c884552caab3d3d8484ed3401e94f983a23f93/fs/config/obscure/obscure.go#L17-L22
+    Uint8Array.from([
+      0x9c,
+      0x93,
+      0x5b,
+      0x48,
+      0x73,
+      0x0a,
+      0x55,
+      0x4d,
+      0x6b,
+      0xfd,
+      0x7c,
+      0x63,
+      0xc8,
+      0x86,
+      0xa9,
+      0x2b,
+      0xd3,
+      0x90,
+      0x19,
+      0x8e,
+      0xb8,
+      0x12,
+      0x8a,
+      0xfb,
+      0xf4,
+      0xde,
+      0x16,
+      0x2b,
+      0x8b,
+      0x95,
+      0xf6,
+      0x38,
+    ]),
+    ALGORITHM,
+    false,
+    ["encrypt", "decrypt"],
+  );
+  return key;
+}
+
+const BlockSize = 16;
+
+/**
+ * Obscrures a password by encrypting them and writing them out in base64.
+ * @param {string} password
+ * @returns {Promise<Response>} A Response containing the obscured password.
+ */
+export async function obscure(password) {
+  const plaintext = new TextEncoder().encode(password);
+  // Constructs the initial empty ciphertext buffer containing the IV and the encrypted text.
+  const ciphertext = new Uint8Array(BlockSize + plaintext.length);
+  // Constructs the IV buffer.
+  const iv = ciphertext.subarray(0, BlockSize);
+  // Fills IV buffer with random bytes.
+  crypto.getRandomValues(iv);
+  // Encrypts the plaintext into the encrypted buffer.
+  const encrypted = await crypto.subtle.encrypt(
+    {
+      name: ALGORITHM,
+      counter: iv,
+      length: 64,
+    },
+    await getKey(),
+    plaintext,
+  );
+  // Copies the encrypted buffer into the ciphertext buffer.
+  ciphertext.set(new Uint8Array(encrypted), BlockSize);
+  // Encodes the ciphertext buffer into a base64 string.
+  const encoded = btoa(String.fromCharCode(...ciphertext));
+
+  return new Response(encoded);
+}
+
+/**
+ * Reveals obscured text by decrypting them
+ * @param {string} cipherText
+ * @returns {Promise<Response>}
+ */
+export async function reveal(cipherText) {
+  // Decodes the base64 string into a ciphertext buffer.
+  const bytes = base64(cipherText);
+  // Constructs the IV buffer from the first block of the ciphertext buffer.
+  const iv = bytes.subarray(0, BlockSize);
+  // Constructs the encrypted buffer from the remaining blocks of the ciphertext buffer.
+  const data = bytes.subarray(BlockSize);
+  // Decrypts the encrypted buffer into the plaintext buffer.
+  const plaintext = await crypto.subtle.decrypt(
+    {
+      name: ALGORITHM,
+      counter: iv,
+      length: 64,
+    },
+    await getKey(),
+    data,
+  );
+
+  return new Response(plaintext);
+}
+
+/**
+ * Encodes a string into a base64 Uint8Array.
+ * @param {string} s
+ * @returns {Uint8Array}
+ */
+function base64(s) {
+  // Replace non-url compatible chars with base64 standard chars
+  s = s.replace(/-/g, "+").replace(/_/g, "/");
+  // Pad out with standard base64 required padding characters
+  const pad = s.length % 4;
+  if (pad != 0) {
+    s += "====".substring(0, 4 - pad);
+  }
+  return new Uint8Array(atob(s).split("").map((c) => c.charCodeAt(0)));
+}
diff --git a/cmd/obscure/main_test.js b/packages/lib/obscure_test.js
similarity index 94%
rename from cmd/obscure/main_test.js
rename to packages/lib/obscure_test.js
index 8a38ea6..1b21e32 100644
--- a/cmd/obscure/main_test.js
+++ b/packages/lib/obscure_test.js
@@ -1,7 +1,7 @@
 import { test } from "node:test";
 import assert from "node:assert/strict";
 import fc from "fast-check";
-import { obscure, reveal } from "./main.js";
+import { obscure, reveal } from "./obscure.js";
 
 /**
  * Asserts a text Response contains the expected string.
diff --git a/packages/lib/package.json b/packages/lib/package.json
new file mode 100644
index 0000000..78568ed
--- /dev/null
+++ b/packages/lib/package.json
@@ -0,0 +1,36 @@
+{
+  "name": "@rfetch/lib",
+  "version": "0.1.0",
+  "description": "The code that the backends of rfetch share: the list of a folder, paths, ranges, types of files, sizes, and the obscure of rclone.",
+  "type": "module",
+  "exports": {
+    "./format": "./format.js",
+    "./html": "./html.js",
+    "./listing": "./listing.js",
+    "./mime": "./mime.js",
+    "./obscure": "./obscure.js",
+    "./path": "./path.js",
+    "./range": "./range.js",
+    "./size": "./size.js",
+    "./sized": "./sized.js"
+  },
+  "scripts": {
+    "test": "node --test"
+  },
+  "engines": {
+    "node": ">=22.2.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sntran/rfetch.git",
+    "directory": "packages/lib"
+  },
+  "author": "Trần Nguyễn Sơn",
+  "license": "ISC",
+  "dependencies": {
+    "@sntran/html-rewriter": "^0.2.0"
+  },
+  "devDependencies": {
+    "fast-check": "^3.19.0"
+  }
+}
diff --git a/lib/path.js b/packages/lib/path.js
similarity index 100%
rename from lib/path.js
rename to packages/lib/path.js
diff --git a/lib/path_test.js b/packages/lib/path_test.js
similarity index 100%
rename from lib/path_test.js
rename to packages/lib/path_test.js
diff --git a/lib/range.js b/packages/lib/range.js
similarity index 100%
rename from lib/range.js
rename to packages/lib/range.js
diff --git a/lib/range_test.js b/packages/lib/range_test.js
similarity index 100%
rename from lib/range_test.js
rename to packages/lib/range_test.js
diff --git a/lib/size.js b/packages/lib/size.js
similarity index 100%
rename from lib/size.js
rename to packages/lib/size.js
diff --git a/lib/size_test.js b/packages/lib/size_test.js
similarity index 100%
rename from lib/size_test.js
rename to packages/lib/size_test.js
diff --git a/lib/streams/sized.js b/packages/lib/sized.js
similarity index 100%
rename from lib/streams/sized.js
rename to packages/lib/sized.js
diff --git a/lib/bench.js b/packages/testing/bench.js
similarity index 100%
rename from lib/bench.js
rename to packages/testing/bench.js
diff --git a/packages/testing/package.json b/packages/testing/package.json
new file mode 100644
index 0000000..c5bc2d3
--- /dev/null
+++ b/packages/testing/package.json
@@ -0,0 +1,28 @@
+{
+  "name": "@rfetch/testing",
+  "version": "0.1.0",
+  "description": "The shared tests of the backends of rfetch, as fstests of rclone, and the tools of the tests.",
+  "type": "module",
+  "exports": {
+    "./bench": "./bench.js",
+    "./remote": "./remote.js",
+    "./server": "./server.js",
+    "./suite": "./suite.js"
+  },
+  "scripts": {
+    "test": "node --test"
+  },
+  "engines": {
+    "node": ">=22.2.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sntran/rfetch.git",
+    "directory": "packages/testing"
+  },
+  "author": "Trần Nguyễn Sơn",
+  "license": "ISC",
+  "dependencies": {
+    "@rfetch/lib": "^0.1.0"
+  }
+}
diff --git a/lib/testing/remote.js b/packages/testing/remote.js
similarity index 98%
rename from lib/testing/remote.js
rename to packages/testing/remote.js
index bc91d98..47cdd15 100644
--- a/lib/testing/remote.js
+++ b/packages/testing/remote.js
@@ -1,4 +1,4 @@
-import { readListing } from "../listing.js";
+import { readListing } from "@rfetch/lib/listing";
 
 /** The origin of the URLs of the requests. A backend reads only the path. */
 const ORIGIN = "http://rfetch.test";
diff --git a/lib/testing/server.js b/packages/testing/server.js
similarity index 100%
rename from lib/testing/server.js
rename to packages/testing/server.js
diff --git a/lib/testing/suite.js b/packages/testing/suite.js
similarity index 99%
rename from lib/testing/suite.js
rename to packages/testing/suite.js
index 94a5a4b..c36a71e 100644
--- a/lib/testing/suite.js
+++ b/packages/testing/suite.js
@@ -11,7 +11,7 @@ import { after, describe, it } from "node:test";
 import assert from "node:assert/strict";
 import { randomBytes } from "node:crypto";
 
-import { mimeType } from "../mime.js";
+import { mimeType } from "@rfetch/lib/mime";
 import { remote } from "./remote.js";
 
 /**
@@ -401,7 +401,7 @@ async function expect(request, status) {
 /**
  * Makes sure that the entries of a list are the expected entries, in any
  * order. A folder has only its name. A file has its name and its size.
- * @param {import("../listing.js").Entry[]} entries
+ * @param {import("@rfetch/lib/listing").Entry[]} entries
  * @param {Array<{ Name: string, IsDir: boolean, Size?: number }>} expected
  */
 function assertEntries(entries, expected) {

From f62b0831a19d683d30ad6b267f4fe14b1c058e41 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sat, 17 Oct 2026 16:15:16 +0000
Subject: [PATCH 50/87] refactor: lib is the workspace @rfetch/lib, with no
 packages folder

The files of packages/lib and the files of lib are now in one workspace, lib, the package @rfetch/lib. The shared tests of the backends are in lib/testing, as @rfetch/lib/testing/suite, and the package @rfetch/testing is removed. lib/streams/progress.js is now lib/progress.js. rfetch and the commands import lib by the name of the package.
---
 CONTRIBUTING.md                       | 19 ++++----
 backend/alias/main_test.js            |  4 +-
 backend/alias/package.json            |  3 --
 backend/chunker/main_bench.js         |  2 +-
 backend/chunker/main_test.js          |  4 +-
 backend/chunker/package.json          |  3 --
 backend/chunker/rclone_test.js        |  2 +-
 backend/crypt/main_test.js            |  4 +-
 backend/crypt/package.json            |  1 -
 backend/crypt/rclone_test.js          |  2 +-
 backend/http/main_test.js             |  6 +--
 backend/http/package.json             |  1 -
 backend/http/rclone_test.js           |  4 +-
 backend/local/main_test.js            |  2 +-
 backend/local/package.json            |  3 --
 backend/main_test.js                  |  5 ++-
 backend/memory/main_test.js           |  2 +-
 backend/memory/package.json           |  3 --
 backend/s3/main_test.js               |  6 +--
 backend/s3/package.json               |  1 -
 backend/s3/rclone_test.js             |  2 +-
 cmd/config/main.js                    |  4 +-
 cmd/lsjson/main.js                    |  4 +-
 cmd/lsjson/main_bench.js              |  2 +-
 {packages/lib => lib}/format.js       |  0
 {packages/lib => lib}/format_test.js  |  0
 {packages/lib => lib}/html.js         |  0
 {packages/lib => lib}/html_test.js    |  0
 {packages/lib => lib}/listing.js      |  0
 {packages/lib => lib}/mime.js         |  0
 {packages/lib => lib}/mime_test.js    |  0
 {packages/lib => lib}/obscure.js      |  0
 {packages/lib => lib}/obscure_test.js |  0
 {packages/lib => lib}/package.json    | 14 ++++--
 {packages/lib => lib}/path.js         |  0
 {packages/lib => lib}/path_test.js    |  0
 lib/{streams => }/progress.js         |  2 +-
 {packages/lib => lib}/range.js        |  0
 {packages/lib => lib}/range_test.js   |  0
 {packages/lib => lib}/size.js         |  0
 {packages/lib => lib}/size_test.js    |  0
 {packages/lib => lib}/sized.js        |  0
 {packages => lib}/testing/bench.js    |  0
 {packages => lib}/testing/remote.js   |  2 +-
 {packages => lib}/testing/server.js   |  0
 {packages => lib}/testing/suite.js    |  4 +-
 mod.js                                |  4 +-
 package-lock.json                     | 62 +++++++--------------------
 package.json                          |  2 +-
 packages/testing/package.json         | 28 ------------
 50 files changed, 71 insertions(+), 136 deletions(-)
 rename {packages/lib => lib}/format.js (100%)
 rename {packages/lib => lib}/format_test.js (100%)
 rename {packages/lib => lib}/html.js (100%)
 rename {packages/lib => lib}/html_test.js (100%)
 rename {packages/lib => lib}/listing.js (100%)
 rename {packages/lib => lib}/mime.js (100%)
 rename {packages/lib => lib}/mime_test.js (100%)
 rename {packages/lib => lib}/obscure.js (100%)
 rename {packages/lib => lib}/obscure_test.js (100%)
 rename {packages/lib => lib}/package.json (55%)
 rename {packages/lib => lib}/path.js (100%)
 rename {packages/lib => lib}/path_test.js (100%)
 rename lib/{streams => }/progress.js (95%)
 rename {packages/lib => lib}/range.js (100%)
 rename {packages/lib => lib}/range_test.js (100%)
 rename {packages/lib => lib}/size.js (100%)
 rename {packages/lib => lib}/size_test.js (100%)
 rename {packages/lib => lib}/sized.js (100%)
 rename {packages => lib}/testing/bench.js (100%)
 rename {packages => lib}/testing/remote.js (98%)
 rename {packages => lib}/testing/server.js (100%)
 rename {packages => lib}/testing/suite.js (99%)
 delete mode 100644 packages/testing/package.json

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 442e8e9..71f5b0c 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -99,8 +99,7 @@ new backend is:
   "type": "module",
   "exports": { ".": "./main.js" },
   "scripts": { "test": "node --test" },
-  "dependencies": { "@rfetch/lib": "^0.1.0" },
-  "devDependencies": { "@rfetch/testing": "^0.1.0" }
+  "dependencies": { "@rfetch/lib": "^0.1.0" }
 }
 ```
 
@@ -116,11 +115,11 @@ The tests and the benches of a backend can also import its `devDependencies`,
 and `../../mod.js` for the global `fetch`. The test `backend/main_test.js` makes
 sure of this rule.
 
-The code that two or more backends use is in the package `@rfetch/lib`, in
-`packages/lib`: `format`, `html`, `listing`, `mime`, `obscure`, `path`, `range`,
-`size` and `sized`. The code that only one backend uses is in the folder of that
-backend, for example `backend/s3/xml.js`. The shared tests are in the package
-`@rfetch/testing`, in `packages/testing`.
+The code that two or more backends use is in the workspace `lib`, the package
+`@rfetch/lib`: for example `listing`, `path`, `range`, `mime` and `obscure`. The
+shared tests of the backends are in it too, in `@rfetch/lib/testing/suite`. The
+code that only one backend uses is in the folder of that backend, for example
+`backend/s3/xml.js`.
 
 ## Architecture
 
@@ -169,12 +168,12 @@ a folder, and `readListing` reads it.
 
 ## Tests of a backend
 
-Each backend must pass the shared tests of `@rfetch/testing/suite`. These tests
-are as the tests `fstests` of rclone, for the contract above. The file
+Each backend must pass the shared tests of `@rfetch/lib/testing/suite`. These
+tests are as the tests `fstests` of rclone, for the contract above. The file
 "main_test.js" of the backend calls the suite one time:
 
 ```js
-import { backendSuite } from "@rfetch/testing/suite";
+import { backendSuite } from "@rfetch/lib/testing/suite";
 import backend from "./main.js";
 
 backendSuite("remote", backend);
diff --git a/backend/alias/main_test.js b/backend/alias/main_test.js
index 6219816..7531ebf 100644
--- a/backend/alias/main_test.js
+++ b/backend/alias/main_test.js
@@ -4,8 +4,8 @@ import { readdir } from "node:fs/promises";
 import { join } from "node:path";
 import assert from "node:assert/strict";
 
-import { backendSuite } from "@rfetch/testing/suite";
-import { remote } from "@rfetch/testing/remote";
+import { backendSuite } from "@rfetch/lib/testing/suite";
+import { remote } from "@rfetch/lib/testing/remote";
 // Sets the global `fetch` that reads the paths of remotes.
 import "../../mod.js";
 import backend from "./main.js";
diff --git a/backend/alias/package.json b/backend/alias/package.json
index 13aac15..02820e4 100644
--- a/backend/alias/package.json
+++ b/backend/alias/package.json
@@ -21,8 +21,5 @@
   "license": "ISC",
   "dependencies": {
     "@rfetch/lib": "^0.1.0"
-  },
-  "devDependencies": {
-    "@rfetch/testing": "^0.1.0"
   }
 }
diff --git a/backend/chunker/main_bench.js b/backend/chunker/main_bench.js
index a72cdab..f5bb5c3 100644
--- a/backend/chunker/main_bench.js
+++ b/backend/chunker/main_bench.js
@@ -7,7 +7,7 @@ import { spawn } from "node:child_process";
 import { randomBytes } from "node:crypto";
 import { once } from "node:events";
 import { Writable } from "node:stream";
-import { bench } from "@rfetch/testing/bench";
+import { bench } from "@rfetch/lib/testing/bench";
 import backend from "./main.js";
 
 const buffer = randomBytes(1024 * 1024 * 10); // 10M
diff --git a/backend/chunker/main_test.js b/backend/chunker/main_test.js
index 1aa0fa7..015acdf 100644
--- a/backend/chunker/main_test.js
+++ b/backend/chunker/main_test.js
@@ -2,8 +2,8 @@ import { describe, test } from "node:test";
 import assert from "node:assert/strict";
 import { createHash } from "node:crypto";
 
-import { backendSuite } from "@rfetch/testing/suite";
-import { remote } from "@rfetch/testing/remote";
+import { backendSuite } from "@rfetch/lib/testing/suite";
+import { remote } from "@rfetch/lib/testing/remote";
 import { fetch } from "../../mod.js";
 import backend from "./main.js";
 
diff --git a/backend/chunker/package.json b/backend/chunker/package.json
index 7e8930d..ed92ae0 100644
--- a/backend/chunker/package.json
+++ b/backend/chunker/package.json
@@ -21,8 +21,5 @@
   "license": "ISC",
   "dependencies": {
     "@rfetch/lib": "^0.1.0"
-  },
-  "devDependencies": {
-    "@rfetch/testing": "^0.1.0"
   }
 }
diff --git a/backend/chunker/rclone_test.js b/backend/chunker/rclone_test.js
index 646618b..fdc574b 100644
--- a/backend/chunker/rclone_test.js
+++ b/backend/chunker/rclone_test.js
@@ -19,7 +19,7 @@ import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import process from "node:process";
 
-import { remote } from "@rfetch/testing/remote";
+import { remote } from "@rfetch/lib/testing/remote";
 // Sets the global `fetch` that reads the paths of remotes.
 import "../../mod.js";
 import chunker from "./main.js";
diff --git a/backend/crypt/main_test.js b/backend/crypt/main_test.js
index ad1d79b..be144bb 100644
--- a/backend/crypt/main_test.js
+++ b/backend/crypt/main_test.js
@@ -5,8 +5,8 @@ import process from "node:process";
 import assert from "node:assert/strict";
 import fc from "fast-check";
 
-import { backendSuite } from "@rfetch/testing/suite";
-import { remote } from "@rfetch/testing/remote";
+import { backendSuite } from "@rfetch/lib/testing/suite";
+import { remote } from "@rfetch/lib/testing/remote";
 import { fetch } from "../../mod.js";
 import { mimeType } from "@rfetch/lib/mime";
 import { decode, default as crypt, deriveKey, encode } from "./main.js";
diff --git a/backend/crypt/package.json b/backend/crypt/package.json
index 7206aa3..5988987 100644
--- a/backend/crypt/package.json
+++ b/backend/crypt/package.json
@@ -28,7 +28,6 @@
     "base32-encode": "^2.0.0"
   },
   "devDependencies": {
-    "@rfetch/testing": "^0.1.0",
     "fast-check": "^3.19.0"
   }
 }
diff --git a/backend/crypt/rclone_test.js b/backend/crypt/rclone_test.js
index 6f66ad9..aa76cea 100644
--- a/backend/crypt/rclone_test.js
+++ b/backend/crypt/rclone_test.js
@@ -18,7 +18,7 @@ import { dirname, join } from "node:path";
 import process from "node:process";
 import fc from "fast-check";
 
-import { remote } from "@rfetch/testing/remote";
+import { remote } from "@rfetch/lib/testing/remote";
 // Sets the global `fetch` that reads the paths of remotes.
 import "../../mod.js";
 import crypt from "./main.js";
diff --git a/backend/http/main_test.js b/backend/http/main_test.js
index 613e5ee..3b00638 100644
--- a/backend/http/main_test.js
+++ b/backend/http/main_test.js
@@ -3,9 +3,9 @@ import assert from "node:assert/strict";
 import { gzipSync } from "node:zlib";
 
 import { mimeType } from "@rfetch/lib/mime";
-import { backendSuite } from "@rfetch/testing/suite";
-import { remote } from "@rfetch/testing/remote";
-import { listen } from "@rfetch/testing/server";
+import { backendSuite } from "@rfetch/lib/testing/suite";
+import { remote } from "@rfetch/lib/testing/remote";
+import { listen } from "@rfetch/lib/testing/server";
 import memory from "@rfetch/memory";
 import backend from "./main.js";
 
diff --git a/backend/http/package.json b/backend/http/package.json
index 4829eef..ac6ebd4 100644
--- a/backend/http/package.json
+++ b/backend/http/package.json
@@ -27,7 +27,6 @@
     "@rfetch/chunker": "^0.1.0",
     "@rfetch/crypt": "^0.1.0",
     "@rfetch/memory": "^0.1.0",
-    "@rfetch/testing": "^0.1.0",
     "fast-check": "^3.19.0"
   }
 }
diff --git a/backend/http/rclone_test.js b/backend/http/rclone_test.js
index 23f1365..24b926d 100644
--- a/backend/http/rclone_test.js
+++ b/backend/http/rclone_test.js
@@ -11,8 +11,8 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import process from "node:process";
 
-import { remote } from "@rfetch/testing/remote";
-import { listen } from "@rfetch/testing/server";
+import { remote } from "@rfetch/lib/testing/remote";
+import { listen } from "@rfetch/lib/testing/server";
 // Sets the global `fetch` that reads the paths of remotes.
 import "../../mod.js";
 import chunker from "@rfetch/chunker";
diff --git a/backend/local/main_test.js b/backend/local/main_test.js
index ea1f163..dd5056f 100644
--- a/backend/local/main_test.js
+++ b/backend/local/main_test.js
@@ -12,7 +12,7 @@ import {
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 
-import { backendSuite } from "@rfetch/testing/suite";
+import { backendSuite } from "@rfetch/lib/testing/suite";
 import backend from "./main.js";
 
 // The backend serves the current folder. The tests use a new folder as the
diff --git a/backend/local/package.json b/backend/local/package.json
index bf2ab58..01dedc5 100644
--- a/backend/local/package.json
+++ b/backend/local/package.json
@@ -21,8 +21,5 @@
   "license": "ISC",
   "dependencies": {
     "@rfetch/lib": "^0.1.0"
-  },
-  "devDependencies": {
-    "@rfetch/testing": "^0.1.0"
   }
 }
diff --git a/backend/main_test.js b/backend/main_test.js
index 1fd1adf..3c24191 100644
--- a/backend/main_test.js
+++ b/backend/main_test.js
@@ -14,10 +14,11 @@ import { backends, load } from "./main.js";
 
 const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..");
 
-/** The folders of the workspaces, for example `backend/crypt`. */
+/** The folders of the workspaces, for example `lib` and `backend/crypt`. */
 const WORKSPACES = JSON.parse(readFileSync(join(ROOT, "package.json")))
   .workspaces.flatMap((pattern) => {
-    const parent = pattern.replace(/\/\*$/, "");
+    if (!pattern.endsWith("/*")) return [pattern];
+    const parent = pattern.slice(0, -2);
     return readdirSync(join(ROOT, parent), { withFileTypes: true })
       .filter((entry) => entry.isDirectory())
       .map((entry) => `${parent}/${entry.name}`)
diff --git a/backend/memory/main_test.js b/backend/memory/main_test.js
index 3f8dfda..db5019f 100644
--- a/backend/memory/main_test.js
+++ b/backend/memory/main_test.js
@@ -1,4 +1,4 @@
-import { backendSuite } from "@rfetch/testing/suite";
+import { backendSuite } from "@rfetch/lib/testing/suite";
 import backend from "./main.js";
 
 backendSuite("memory", backend);
diff --git a/backend/memory/package.json b/backend/memory/package.json
index 454f649..71a9c93 100644
--- a/backend/memory/package.json
+++ b/backend/memory/package.json
@@ -21,8 +21,5 @@
   "license": "ISC",
   "dependencies": {
     "@rfetch/lib": "^0.1.0"
-  },
-  "devDependencies": {
-    "@rfetch/testing": "^0.1.0"
   }
 }
diff --git a/backend/s3/main_test.js b/backend/s3/main_test.js
index 138055d..f548a35 100644
--- a/backend/s3/main_test.js
+++ b/backend/s3/main_test.js
@@ -8,9 +8,9 @@ import assert from "node:assert/strict";
 import { spawnSync } from "node:child_process";
 import process from "node:process";
 
-import { backendSuite } from "@rfetch/testing/suite";
-import { remote } from "@rfetch/testing/remote";
-import { listen } from "@rfetch/testing/server";
+import { backendSuite } from "@rfetch/lib/testing/suite";
+import { remote } from "@rfetch/lib/testing/remote";
+import { listen } from "@rfetch/lib/testing/server";
 import s3 from "./main.js";
 import { KEYS, serveS3 } from "./testing.js";
 
diff --git a/backend/s3/package.json b/backend/s3/package.json
index 87bff1b..6c3aba3 100644
--- a/backend/s3/package.json
+++ b/backend/s3/package.json
@@ -23,7 +23,6 @@
     "@rfetch/lib": "^0.1.0"
   },
   "devDependencies": {
-    "@rfetch/testing": "^0.1.0",
     "fast-check": "^3.19.0"
   }
 }
diff --git a/backend/s3/rclone_test.js b/backend/s3/rclone_test.js
index fd4985a..70d75e7 100644
--- a/backend/s3/rclone_test.js
+++ b/backend/s3/rclone_test.js
@@ -10,7 +10,7 @@ import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import process from "node:process";
 
-import { remote } from "@rfetch/testing/remote";
+import { remote } from "@rfetch/lib/testing/remote";
 import { KEYS, serveS3 } from "./testing.js";
 import s3 from "./main.js";
 
diff --git a/cmd/config/main.js b/cmd/config/main.js
index 4699f7f..eff8a18 100644
--- a/cmd/config/main.js
+++ b/cmd/config/main.js
@@ -1,8 +1,8 @@
 import { env } from "node:process";
 
 import { join } from "node:path";
-import { CONFIG_NAME } from "../../lib/fspath.js";
-import * as INI from "../../lib/ini.js";
+import { CONFIG_NAME } from "@rfetch/lib/fspath";
+import * as INI from "@rfetch/lib/ini";
 
 /**
  * The names of remotes that rclone accepts (`fspath.CheckConfigName`):
diff --git a/cmd/lsjson/main.js b/cmd/lsjson/main.js
index f29f35a..94eb020 100644
--- a/cmd/lsjson/main.js
+++ b/cmd/lsjson/main.js
@@ -1,7 +1,7 @@
 import { basename } from "node:path";
 import { HTMLRewriter } from "@sntran/html-rewriter";
-import { parse } from "../../lib/fspath.js";
-import { toLocaleISOString } from "../../lib/time.js";
+import { parse } from "@rfetch/lib/fspath";
+import { toLocaleISOString } from "@rfetch/lib/time";
 
 import { fetch } from "../../mod.js";
 
diff --git a/cmd/lsjson/main_bench.js b/cmd/lsjson/main_bench.js
index 1d4743b..e4b5502 100644
--- a/cmd/lsjson/main_bench.js
+++ b/cmd/lsjson/main_bench.js
@@ -8,7 +8,7 @@
  */
 import { spawn } from "node:child_process";
 import { Readable } from "node:stream";
-import { bench } from "@rfetch/testing/bench";
+import { bench } from "@rfetch/lib/testing/bench";
 import { lsjson } from "./main.js";
 
 const remotes = ["./", "./backend/", "./cmd/"];
diff --git a/packages/lib/format.js b/lib/format.js
similarity index 100%
rename from packages/lib/format.js
rename to lib/format.js
diff --git a/packages/lib/format_test.js b/lib/format_test.js
similarity index 100%
rename from packages/lib/format_test.js
rename to lib/format_test.js
diff --git a/packages/lib/html.js b/lib/html.js
similarity index 100%
rename from packages/lib/html.js
rename to lib/html.js
diff --git a/packages/lib/html_test.js b/lib/html_test.js
similarity index 100%
rename from packages/lib/html_test.js
rename to lib/html_test.js
diff --git a/packages/lib/listing.js b/lib/listing.js
similarity index 100%
rename from packages/lib/listing.js
rename to lib/listing.js
diff --git a/packages/lib/mime.js b/lib/mime.js
similarity index 100%
rename from packages/lib/mime.js
rename to lib/mime.js
diff --git a/packages/lib/mime_test.js b/lib/mime_test.js
similarity index 100%
rename from packages/lib/mime_test.js
rename to lib/mime_test.js
diff --git a/packages/lib/obscure.js b/lib/obscure.js
similarity index 100%
rename from packages/lib/obscure.js
rename to lib/obscure.js
diff --git a/packages/lib/obscure_test.js b/lib/obscure_test.js
similarity index 100%
rename from packages/lib/obscure_test.js
rename to lib/obscure_test.js
diff --git a/packages/lib/package.json b/lib/package.json
similarity index 55%
rename from packages/lib/package.json
rename to lib/package.json
index 78568ed..02e8971 100644
--- a/packages/lib/package.json
+++ b/lib/package.json
@@ -1,18 +1,26 @@
 {
   "name": "@rfetch/lib",
   "version": "0.1.0",
-  "description": "The code that the backends of rfetch share: the list of a folder, paths, ranges, types of files, sizes, and the obscure of rclone.",
+  "description": "The code that rfetch and its backends share: the list of a folder, paths, ranges, types of files, sizes, the obscure of rclone, and the shared tests of the backends.",
   "type": "module",
   "exports": {
     "./format": "./format.js",
+    "./fspath": "./fspath.js",
     "./html": "./html.js",
+    "./ini": "./ini.js",
     "./listing": "./listing.js",
     "./mime": "./mime.js",
     "./obscure": "./obscure.js",
     "./path": "./path.js",
+    "./progress": "./progress.js",
     "./range": "./range.js",
     "./size": "./size.js",
-    "./sized": "./sized.js"
+    "./sized": "./sized.js",
+    "./time": "./time.js",
+    "./testing/bench": "./testing/bench.js",
+    "./testing/remote": "./testing/remote.js",
+    "./testing/server": "./testing/server.js",
+    "./testing/suite": "./testing/suite.js"
   },
   "scripts": {
     "test": "node --test"
@@ -23,7 +31,7 @@
   "repository": {
     "type": "git",
     "url": "git+https://github.com/sntran/rfetch.git",
-    "directory": "packages/lib"
+    "directory": "lib"
   },
   "author": "Trần Nguyễn Sơn",
   "license": "ISC",
diff --git a/packages/lib/path.js b/lib/path.js
similarity index 100%
rename from packages/lib/path.js
rename to lib/path.js
diff --git a/packages/lib/path_test.js b/lib/path_test.js
similarity index 100%
rename from packages/lib/path_test.js
rename to lib/path_test.js
diff --git a/lib/streams/progress.js b/lib/progress.js
similarity index 95%
rename from lib/streams/progress.js
rename to lib/progress.js
index 238d2b5..d3bceac 100644
--- a/lib/streams/progress.js
+++ b/lib/progress.js
@@ -1,4 +1,4 @@
-import { formatBytes, formatDuration } from "@rfetch/lib/format";
+import { formatBytes, formatDuration } from "./format.js";
 
 export class Progress extends TransformStream {
   completed = 0;
diff --git a/packages/lib/range.js b/lib/range.js
similarity index 100%
rename from packages/lib/range.js
rename to lib/range.js
diff --git a/packages/lib/range_test.js b/lib/range_test.js
similarity index 100%
rename from packages/lib/range_test.js
rename to lib/range_test.js
diff --git a/packages/lib/size.js b/lib/size.js
similarity index 100%
rename from packages/lib/size.js
rename to lib/size.js
diff --git a/packages/lib/size_test.js b/lib/size_test.js
similarity index 100%
rename from packages/lib/size_test.js
rename to lib/size_test.js
diff --git a/packages/lib/sized.js b/lib/sized.js
similarity index 100%
rename from packages/lib/sized.js
rename to lib/sized.js
diff --git a/packages/testing/bench.js b/lib/testing/bench.js
similarity index 100%
rename from packages/testing/bench.js
rename to lib/testing/bench.js
diff --git a/packages/testing/remote.js b/lib/testing/remote.js
similarity index 98%
rename from packages/testing/remote.js
rename to lib/testing/remote.js
index 47cdd15..bc91d98 100644
--- a/packages/testing/remote.js
+++ b/lib/testing/remote.js
@@ -1,4 +1,4 @@
-import { readListing } from "@rfetch/lib/listing";
+import { readListing } from "../listing.js";
 
 /** The origin of the URLs of the requests. A backend reads only the path. */
 const ORIGIN = "http://rfetch.test";
diff --git a/packages/testing/server.js b/lib/testing/server.js
similarity index 100%
rename from packages/testing/server.js
rename to lib/testing/server.js
diff --git a/packages/testing/suite.js b/lib/testing/suite.js
similarity index 99%
rename from packages/testing/suite.js
rename to lib/testing/suite.js
index c36a71e..94a5a4b 100644
--- a/packages/testing/suite.js
+++ b/lib/testing/suite.js
@@ -11,7 +11,7 @@ import { after, describe, it } from "node:test";
 import assert from "node:assert/strict";
 import { randomBytes } from "node:crypto";
 
-import { mimeType } from "@rfetch/lib/mime";
+import { mimeType } from "../mime.js";
 import { remote } from "./remote.js";
 
 /**
@@ -401,7 +401,7 @@ async function expect(request, status) {
 /**
  * Makes sure that the entries of a list are the expected entries, in any
  * order. A folder has only its name. A file has its name and its size.
- * @param {import("@rfetch/lib/listing").Entry[]} entries
+ * @param {import("../listing.js").Entry[]} entries
  * @param {Array<{ Name: string, IsDir: boolean, Size?: number }>} expected
  */
 function assertEntries(entries, expected) {
diff --git a/mod.js b/mod.js
index be22ae0..dd8cbaf 100644
--- a/mod.js
+++ b/mod.js
@@ -1,11 +1,11 @@
 import { env } from "node:process";
 import { load } from "./backend/main.js";
 import * as commands from "./cmd/main.js";
-import { parse } from "./lib/fspath.js";
+import { parse } from "@rfetch/lib/fspath";
 
 export * from "./cmd/main.js";
 
-export { Progress } from "./lib/streams/progress.js";
+export { Progress } from "@rfetch/lib/progress";
 
 /**
  * @typedef {Object<string, string>} Options
diff --git a/package-lock.json b/package-lock.json
index b50eb11..98d12ef 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -9,7 +9,7 @@
       "version": "0.1.0",
       "license": "ISC",
       "workspaces": [
-        "packages/*",
+        "lib",
         "backend/*"
       ],
       "dependencies": {
@@ -42,9 +42,6 @@
       "dependencies": {
         "@rfetch/lib": "^0.1.0"
       },
-      "devDependencies": {
-        "@rfetch/testing": "^0.1.0"
-      },
       "engines": {
         "node": ">=22.2.0"
       }
@@ -56,9 +53,6 @@
       "dependencies": {
         "@rfetch/lib": "^0.1.0"
       },
-      "devDependencies": {
-        "@rfetch/testing": "^0.1.0"
-      },
       "engines": {
         "node": ">=22.2.0"
       }
@@ -76,7 +70,6 @@
         "base32-encode": "^2.0.0"
       },
       "devDependencies": {
-        "@rfetch/testing": "^0.1.0",
         "fast-check": "^3.19.0"
       },
       "engines": {
@@ -106,7 +99,6 @@
         "@rfetch/chunker": "^0.1.0",
         "@rfetch/crypt": "^0.1.0",
         "@rfetch/memory": "^0.1.0",
-        "@rfetch/testing": "^0.1.0",
         "fast-check": "^3.19.0"
       },
       "engines": {
@@ -120,9 +112,6 @@
       "dependencies": {
         "@rfetch/lib": "^0.1.0"
       },
-      "devDependencies": {
-        "@rfetch/testing": "^0.1.0"
-      },
       "engines": {
         "node": ">=22.2.0"
       }
@@ -134,9 +123,6 @@
       "dependencies": {
         "@rfetch/lib": "^0.1.0"
       },
-      "devDependencies": {
-        "@rfetch/testing": "^0.1.0"
-      },
       "engines": {
         "node": ">=22.2.0"
       }
@@ -149,7 +135,20 @@
         "@rfetch/lib": "^0.1.0"
       },
       "devDependencies": {
-        "@rfetch/testing": "^0.1.0",
+        "fast-check": "^3.19.0"
+      },
+      "engines": {
+        "node": ">=22.2.0"
+      }
+    },
+    "lib": {
+      "name": "@rfetch/lib",
+      "version": "0.1.0",
+      "license": "ISC",
+      "dependencies": {
+        "@sntran/html-rewriter": "^0.2.0"
+      },
+      "devDependencies": {
         "fast-check": "^3.19.0"
       },
       "engines": {
@@ -196,7 +195,7 @@
       "link": true
     },
     "node_modules/@rfetch/lib": {
-      "resolved": "packages/lib",
+      "resolved": "lib",
       "link": true
     },
     "node_modules/@rfetch/local": {
@@ -211,10 +210,6 @@
       "resolved": "backend/s3",
       "link": true
     },
-    "node_modules/@rfetch/testing": {
-      "resolved": "packages/testing",
-      "link": true
-    },
     "node_modules/@sntran/html-rewriter": {
       "version": "0.2.0",
       "resolved": "https://registry.npmjs.org/@sntran/html-rewriter/-/html-rewriter-0.2.0.tgz",
@@ -294,31 +289,6 @@
       "engines": {
         "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
       }
-    },
-    "packages/lib": {
-      "name": "@rfetch/lib",
-      "version": "0.1.0",
-      "license": "ISC",
-      "dependencies": {
-        "@sntran/html-rewriter": "^0.2.0"
-      },
-      "devDependencies": {
-        "fast-check": "^3.19.0"
-      },
-      "engines": {
-        "node": ">=22.2.0"
-      }
-    },
-    "packages/testing": {
-      "name": "@rfetch/testing",
-      "version": "0.1.0",
-      "license": "ISC",
-      "dependencies": {
-        "@rfetch/lib": "^0.1.0"
-      },
-      "engines": {
-        "node": ">=22.2.0"
-      }
     }
   }
 }
diff --git a/package.json b/package.json
index 69452c9..b9378f9 100644
--- a/package.json
+++ b/package.json
@@ -11,7 +11,7 @@
   "main": "mod.js",
   "type": "module",
   "workspaces": [
-    "packages/*",
+    "lib",
     "backend/*"
   ],
   "repository": {
diff --git a/packages/testing/package.json b/packages/testing/package.json
deleted file mode 100644
index c5bc2d3..0000000
--- a/packages/testing/package.json
+++ /dev/null
@@ -1,28 +0,0 @@
-{
-  "name": "@rfetch/testing",
-  "version": "0.1.0",
-  "description": "The shared tests of the backends of rfetch, as fstests of rclone, and the tools of the tests.",
-  "type": "module",
-  "exports": {
-    "./bench": "./bench.js",
-    "./remote": "./remote.js",
-    "./server": "./server.js",
-    "./suite": "./suite.js"
-  },
-  "scripts": {
-    "test": "node --test"
-  },
-  "engines": {
-    "node": ">=22.2.0"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/sntran/rfetch.git",
-    "directory": "packages/testing"
-  },
-  "author": "Trần Nguyễn Sơn",
-  "license": "ISC",
-  "dependencies": {
-    "@rfetch/lib": "^0.1.0"
-  }
-}

From c8949b69a072398e68c506a48cce15962b541ba9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sat, 17 Oct 2026 18:43:06 +0000
Subject: [PATCH 51/87] feat(lib): the options of a backend, from the query,
 the headers and env

optionsOf gives an option of a field of the query first, then of the header RCLONE_TYPE_NAME, then of the variable RCLONE_TYPE_NAME of env, as a flag of rclone takes the place of a variable. remoteHeaders gives the headers of a request of a backend to the remote under it: the other options go on, the options of the backend do not, and no option goes to a URL.
---
 lib/options.js      |  72 ++++++++++++++++++++++++++++++
 lib/options_test.js | 105 ++++++++++++++++++++++++++++++++++++++++++++
 lib/package.json    |   1 +
 3 files changed, 178 insertions(+)
 create mode 100644 lib/options.js
 create mode 100644 lib/options_test.js

diff --git a/lib/options.js b/lib/options.js
new file mode 100644
index 0000000..d683039
--- /dev/null
+++ b/lib/options.js
@@ -0,0 +1,72 @@
+/**
+ * The options of a backend, from the three places of rclone: a flag, a
+ * variable of the request, and a variable of the environment.
+ *
+ * A variable has the name of the variable of rclone, for example
+ * `RCLONE_S3_ACCESS_KEY_ID` for the option `access_key_id` of s3. In a
+ * request, it is a header. The names of headers are not case sensitive.
+ */
+
+/** The start of the name of a header that is an option of rclone. */
+const PREFIX = "rclone_";
+
+/**
+ * Gives the options of a backend for a request: a field of the query
+ * first, then the header `RCLONE_TYPE_NAME`, then the variable
+ * `RCLONE_TYPE_NAME` of `env`, as a flag of rclone takes the place of a
+ * variable.
+ *
+ * Use the options to read an option, and the query of the request to make
+ * the links of a list: thus an option of a header or of `env` is never in a
+ * link.
+ * @param {Request} request
+ * @param {string} type The type of the backend, for example `s3`.
+ * @param {Record<string, unknown>} [env]
+ * @returns {URLSearchParams}
+ */
+export function optionsOf(request, type, env = {}) {
+  const options = new URL(request.url).searchParams;
+  const prefix = `${PREFIX}${type.toLowerCase()}_`;
+  for (const [name, value] of request.headers) {
+    if (!name.startsWith(prefix)) continue;
+    const key = name.slice(prefix.length);
+    if (!options.has(key)) options.set(key, value);
+  }
+  const variable = prefix.toUpperCase();
+  for (const [name, value] of Object.entries(env)) {
+    if (!name.startsWith(variable) || typeof value !== "string") continue;
+    const key = name.slice(variable.length).toLowerCase();
+    if (!options.has(key)) options.set(key, value);
+  }
+  return options;
+}
+
+/**
+ * Tells if a header is an option of rclone.
+ * @param {string} name
+ */
+export function isOption(name) {
+  return name.toLowerCase().startsWith(PREFIX);
+}
+
+/**
+ * Gives the headers of a request of a backend to the remote under it.
+ *
+ * The other options of the request go to the remote, for example the
+ * remotes of `RCLONE_CONFIG_NAME_KEY`. The options of the backend itself do
+ * not go: they are not for the remote. When the remote is a URL, no option
+ * goes: a secret must not go out to a server.
+ * @param {HeadersInit} headers The headers of the request of the backend.
+ * @param {string} type The type of the backend, for example `crypt`.
+ * @param {string} remote The remote under the backend.
+ * @returns {Headers}
+ */
+export function remoteHeaders(headers, type, remote) {
+  const result = new Headers(headers);
+  const own = `${PREFIX}${type.toLowerCase()}_`;
+  const url = /^[a-z][a-z0-9+.-]*:\/\//i.test(remote);
+  for (const name of [...result.keys()]) {
+    if (url ? isOption(name) : name.startsWith(own)) result.delete(name);
+  }
+  return result;
+}
diff --git a/lib/options_test.js b/lib/options_test.js
new file mode 100644
index 0000000..8c879c6
--- /dev/null
+++ b/lib/options_test.js
@@ -0,0 +1,105 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import fc from "fast-check";
+
+import { isOption, optionsOf, remoteHeaders } from "./options.js";
+
+test("optionsOf takes the query, then the headers, then env", () => {
+  const request = new Request("https://rfetch.test/a?remote=query", {
+    headers: {
+      RCLONE_CRYPT_REMOTE: "header",
+      RCLONE_CRYPT_PASSWORD: "from-header",
+      RCLONE_S3_ENDPOINT: "not-for-crypt",
+    },
+  });
+  const options = optionsOf(request, "crypt", {
+    RCLONE_CRYPT_REMOTE: "env",
+    RCLONE_CRYPT_PASSWORD: "env",
+    RCLONE_CRYPT_PASSWORD2: "from-env",
+    RCLONE_CRYPT_NUMBER: 1,
+  });
+  assert.equal(options.get("remote"), "query");
+  assert.equal(options.get("password"), "from-header");
+  assert.equal(options.get("password2"), "from-env");
+  assert.equal(options.get("endpoint"), null);
+  // A value of env that is not a text, for example a binding, is not an
+  // option.
+  assert.equal(options.get("number"), null);
+});
+
+test("optionsOf reads the names of headers in each case", () => {
+  for (
+    const name of ["RCLONE_S3_REGION", "rclone_s3_region", "Rclone_S3_Region"]
+  ) {
+    const request = new Request("https://rfetch.test/", {
+      headers: { [name]: "auto" },
+    });
+    assert.equal(optionsOf(request, "s3").get("region"), "auto", name);
+  }
+});
+
+test("optionsOf keeps an option of env with characters of each language", () => {
+  fc.assert(
+    fc.property(fc.string({ unit: "grapheme" }), (value) => {
+      const request = new Request("https://rfetch.test/");
+      const options = optionsOf(request, "alias", {
+        RCLONE_ALIAS_REMOTE: value,
+      });
+      assert.equal(options.get("remote"), value);
+    }),
+  );
+});
+
+test("optionsOf does not change the query of the request", () => {
+  const request = new Request("https://rfetch.test/?a=1", {
+    headers: { RCLONE_ALIAS_REMOTE: "header" },
+  });
+  optionsOf(request, "alias");
+  assert.equal(new URL(request.url).search, "?a=1");
+});
+
+test("isOption tells the headers of rclone", () => {
+  assert.ok(isOption("RCLONE_CONFIG_R2_TYPE"));
+  assert.ok(isOption("rclone_s3_access_key_id"));
+  assert.ok(!isOption("Range"));
+  assert.ok(!isOption("X-Rclone"));
+});
+
+test("remoteHeaders keeps the other options for a remote of rfetch", () => {
+  const headers = remoteHeaders(
+    {
+      Range: "bytes=0-1",
+      RCLONE_CRYPT_PASSWORD: "secret",
+      RCLONE_CONFIG_R2_TYPE: "s3",
+      RCLONE_S3_REGION: "auto",
+    },
+    "crypt",
+    "r2:bucket",
+  );
+  assert.deepEqual([...headers].sort(), [
+    ["range", "bytes=0-1"],
+    ["rclone_config_r2_type", "s3"],
+    ["rclone_s3_region", "auto"],
+  ]);
+});
+
+test("remoteHeaders gives no option to a URL", () => {
+  for (
+    const remote of [
+      "https://example.com/a",
+      "http://127.0.0.1:1",
+      "file:///tmp",
+    ]
+  ) {
+    const headers = remoteHeaders(
+      {
+        Range: "bytes=0-1",
+        RCLONE_CRYPT_PASSWORD: "secret",
+        RCLONE_CONFIG_R2_SECRET_ACCESS_KEY: "secret",
+      },
+      "crypt",
+      remote,
+    );
+    assert.deepEqual([...headers], [["range", "bytes=0-1"]], remote);
+  }
+});
diff --git a/lib/package.json b/lib/package.json
index 02e8971..c6d5bad 100644
--- a/lib/package.json
+++ b/lib/package.json
@@ -11,6 +11,7 @@
     "./listing": "./listing.js",
     "./mime": "./mime.js",
     "./obscure": "./obscure.js",
+    "./options": "./options.js",
     "./path": "./path.js",
     "./progress": "./progress.js",
     "./range": "./range.js",

From 87c8596a874ac59fe58a5ba23da4cd50d94c8dd2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sat, 17 Oct 2026 18:43:27 +0000
Subject: [PATCH 52/87] feat: backends read their options from headers and env

alias, chunker, crypt, drive, http and s3 read an option with optionsOf: the query, then the header RCLONE_TYPE_NAME, then the variable of env. The links of a list keep the query of the request only. The overlays send remoteHeaders to the remote under them. drive keeps its token and its client secret out of its links.

The shared suite takes the type of the backend in rclone. With it, the suite also gives the params in headers and in env, and makes sure that no link of a list has a query.
---
 backend/alias/main.js        | 13 ++++++++++---
 backend/alias/main_test.js   |  5 ++++-
 backend/chunker/main.js      | 33 ++++++++++++++++++++++++---------
 backend/chunker/main_test.js |  3 +++
 backend/crypt/main.js        | 16 ++++++++++------
 backend/crypt/main_test.js   |  2 +-
 backend/drive/main.js        | 34 ++++++++++++++++++++++++++++++----
 backend/http/main.js         | 12 ++++++++----
 backend/http/main_test.js    |  1 +
 backend/s3/main.js           | 14 ++++++--------
 backend/s3/main_test.js      | 17 +++++++++++++++--
 lib/testing/remote.js        | 12 +++++++++---
 lib/testing/suite.js         | 33 ++++++++++++++++++++++++++++++++-
 13 files changed, 153 insertions(+), 42 deletions(-)

diff --git a/backend/alias/main.js b/backend/alias/main.js
index c9c92a9..a06a577 100644
--- a/backend/alias/main.js
+++ b/backend/alias/main.js
@@ -20,18 +20,22 @@
  */
 
 import { relink } from "@rfetch/lib/listing";
+import { optionsOf, remoteHeaders } from "@rfetch/lib/options";
 import { decodePath, encodePath } from "@rfetch/lib/path";
 
 /**
  * Sends the requests to the remote of the alias with the global `fetch`.
  * @param {Request} request
+ * @param {Record<string, unknown>} [env] The options in the variables
+ *   `RCLONE_ALIAS_*`.
  * @returns {Promise<Response>}
  */
-async function alias(request) {
+async function alias(request, env = {}) {
   const { method } = request;
   const { pathname, searchParams } = new URL(request.url);
 
-  const remote = searchParams.get("remote")?.replace(/\/$/, "");
+  const remote = optionsOf(request, "alias", env).get("remote")
+    ?.replace(/\/$/, "");
   if (!remote) {
     return new Response("Missing remote", { status: 400 });
   }
@@ -42,7 +46,10 @@ async function alias(request) {
 
   // Delegates to the underlying remote.
   /** @type {RequestInit} */
-  const init = { method, headers: request.headers };
+  const init = {
+    method,
+    headers: remoteHeaders(request.headers, "alias", remote),
+  };
   if (request.body) {
     init.body = request.body;
     init.duplex = "half";
diff --git a/backend/alias/main_test.js b/backend/alias/main_test.js
index 7531ebf..14e6e18 100644
--- a/backend/alias/main_test.js
+++ b/backend/alias/main_test.js
@@ -35,7 +35,10 @@ test("local path", async () => {
   }
 });
 
-backendSuite("alias", backend, { params: { remote: ":memory:/alias" } });
+backendSuite("alias", backend, {
+  type: "alias",
+  params: { remote: ":memory:/alias" },
+});
 
 test("the links of a list are in the alias", async () => {
   const fs = remote(backend, { params: { remote: ":memory:/links" } });
diff --git a/backend/chunker/main.js b/backend/chunker/main.js
index 6bbac68..1b92b49 100644
--- a/backend/chunker/main.js
+++ b/backend/chunker/main.js
@@ -103,6 +103,7 @@
 import { createHash } from "node:crypto";
 import { readListing, renderListing } from "@rfetch/lib/listing";
 import { mimeType } from "@rfetch/lib/mime";
+import { isOption, optionsOf, remoteHeaders } from "@rfetch/lib/options";
 import { decodePath, encodePath } from "@rfetch/lib/path";
 import {
   notSatisfiable,
@@ -169,22 +170,26 @@ export const options = {
  * @property {boolean} noRename True for the transactions "norename".
  * @property {boolean} failHard
  * @property {ReturnType<typeof nameFormat>} names
+ * @property {Headers} forward The options of the request for the remote,
+ *   for example `RCLONE_CONFIG_NAME_KEY`.
  */
 
 /**
  * Sends the requests to the remote under the chunker with the global
  * `fetch`.
  * @param {Request} request
+ * @param {Record<string, unknown>} [env] The options in the variables
+ *   `RCLONE_CHUNKER_*`.
  * @returns {Promise<Response>}
  */
-async function chunker(request) {
+async function chunker(request, env = {}) {
   const { method } = request;
   const { pathname, searchParams } = new URL(request.url);
 
   /** @type {Config} */
   let config;
   try {
-    config = configOf(searchParams);
+    config = configOf(request, env);
   } catch (error) {
     return new Response(error.message, { status: 400 });
   }
@@ -204,7 +209,7 @@ async function chunker(request) {
     // A folder is a folder of the remote.
     const response = await send(config, path, {
       method,
-      headers: request.headers,
+      headers: remoteHeaders(request.headers, "chunker", config.remote),
     });
     await response.body?.cancel();
     const headers = new Headers();
@@ -245,13 +250,15 @@ class ChunkerError extends Error {
 
 /**
  * Reads the options, as `NewFs` of the chunker of rclone.
- * @param {URLSearchParams} searchParams
+ * @param {Request} request
+ * @param {Record<string, unknown>} env
  * @returns {Config}
  */
-function configOf(searchParams) {
-  const get = (name) => searchParams.get(name) ?? options.default[name];
+function configOf(request, env) {
+  const values = optionsOf(request, "chunker", env);
+  const get = (name) => values.get(name) ?? options.default[name];
 
-  const remote = searchParams.get("remote")?.replace(/\/$/, "");
+  const remote = values.get("remote")?.replace(/\/$/, "");
   if (!remote) throw new Error("Missing remote");
 
   const chunkSize = parseSize(`${get("chunk_size")}`);
@@ -306,6 +313,10 @@ function configOf(searchParams) {
     noRename,
     failHard: get("fail_hard") === "true",
     names: nameFormat(get("name_format"), startFrom),
+    forward: new Headers(
+      [...remoteHeaders(request.headers, "chunker", remote)]
+        .filter(([name]) => isOption(name)),
+    ),
   };
 }
 
@@ -908,8 +919,12 @@ async function deleteFile(config, dir, name) {
  * @param {RequestInit} [init]
  * @returns {Promise<Response>}
  */
-function send(config, path, init) {
-  return fetch(config.remote + encodePath(path), init);
+function send(config, path, init = {}) {
+  const headers = new Headers(init.headers);
+  for (const [name, value] of config.forward) {
+    if (!headers.has(name)) headers.set(name, value);
+  }
+  return fetch(config.remote + encodePath(path), { ...init, headers });
 }
 
 /**
diff --git a/backend/chunker/main_test.js b/backend/chunker/main_test.js
index 015acdf..6af3011 100644
--- a/backend/chunker/main_test.js
+++ b/backend/chunker/main_test.js
@@ -11,11 +11,13 @@ import backend from "./main.js";
 const CHUNK = "64k";
 
 backendSuite("chunker", backend, {
+  type: "chunker",
   params: { remote: ":memory:/chunker", chunk_size: CHUNK },
 });
 // Without metadata, a name is always in chunks. rclone does not read the
 // name of a chunk with "\n": "." of Go does not match it.
 backendSuite("chunker meta_format=none", backend, {
+  type: "chunker",
   params: {
     remote: ":memory:/none",
     chunk_size: CHUNK,
@@ -25,6 +27,7 @@ backendSuite("chunker meta_format=none", backend, {
   skipName: /\n/,
 });
 backendSuite("chunker transactions=norename", backend, {
+  type: "chunker",
   params: {
     remote: ":memory:/norename",
     chunk_size: CHUNK,
diff --git a/backend/crypt/main.js b/backend/crypt/main.js
index 49867fa..19c80f0 100644
--- a/backend/crypt/main.js
+++ b/backend/crypt/main.js
@@ -97,6 +97,7 @@ import { scryptAsync as scrypt } from "@noble/hashes/scrypt";
 import { HTMLRewriter } from "@sntran/html-rewriter";
 import { formatBytes } from "@rfetch/lib/format";
 import { mimeType } from "@rfetch/lib/mime";
+import { optionsOf, remoteHeaders } from "@rfetch/lib/options";
 import { decodePath } from "@rfetch/lib/path";
 import {
   notSatisfiable,
@@ -157,9 +158,11 @@ const SECRETS = ["password", "password2"];
  * Serves a crypted remote. The requests to the remote under crypt go to the
  * global `fetch`.
  * @param {Request} request
+ * @param {Record<string, unknown>} [env] The options in the variables
+ *   `RCLONE_CRYPT_*`.
  * @returns {Promise<Response>}
  */
-async function crypt(request) {
+async function crypt(request, env = {}) {
   const { method } = request;
   const { pathname, searchParams } = new URL(request.url);
 
@@ -168,19 +171,20 @@ async function crypt(request) {
     return new Response(null, { status: 400 });
   }
 
-  const remote = searchParams.get("remote")?.replace(/\/$/, "");
+  const options = optionsOf(request, "crypt", env);
+  const remote = options.get("remote")?.replace(/\/$/, "");
   if (!remote) {
     return new Response("Missing remote", { status: 400 });
   }
-  if (!searchParams.get("password")) {
+  if (!options.get("password")) {
     return new Response("Missing password", { status: 400 });
   }
 
   let cipher;
   try {
     cipher = await cipherOf(
-      searchParams.get("password"),
-      searchParams.get("password2") ?? "",
+      options.get("password"),
+      options.get("password2") ?? "",
     );
   } catch {
     return new Response("The password is not obscured", { status: 400 });
@@ -191,7 +195,7 @@ async function crypt(request) {
 
   // The data on the remote is encrypted, thus a range of the data is not a
   // range of the file.
-  const headers = new Headers(request.headers);
+  const headers = remoteHeaders(request.headers, "crypt", remote);
   headers.delete("Range");
 
   const range = request.headers.get("Range");
diff --git a/backend/crypt/main_test.js b/backend/crypt/main_test.js
index be144bb..62223a3 100644
--- a/backend/crypt/main_test.js
+++ b/backend/crypt/main_test.js
@@ -145,7 +145,7 @@ const params = {
   password2: SALT,
 };
 
-backendSuite("crypt", crypt, { params });
+backendSuite("crypt", crypt, { type: "crypt", params });
 
 describe("crypt", () => {
   const fs = remote(crypt, { params });
diff --git a/backend/drive/main.js b/backend/drive/main.js
index 493888b..0a6e77a 100644
--- a/backend/drive/main.js
+++ b/backend/drive/main.js
@@ -1,4 +1,5 @@
 import { formatBytes } from "@rfetch/lib/format";
+import { optionsOf, remoteHeaders } from "@rfetch/lib/options";
 
 import { auth } from "./auth.js";
 import { list } from "./list.js";
@@ -14,12 +15,37 @@ const FILE_HEADERS = new Headers({
   "Content-Type": "application/octet-stream",
 });
 
+/**
+ * The options that are secret. They are not in the links of a list.
+ */
+const SECRETS = ["token", "client_secret", "service_account_credentials"];
+
 /**
  * Serves a Google Drive remote.
  * @param {Request} request
+ * @param {Record<string, unknown>} [env] The options in the variables
+ *   `RCLONE_DRIVE_*`.
  * @returns {Promise<Response>}
  */
-async function drive(request) {
+async function drive(request, env = {}) {
+  // The links of a list keep the query of the request, with no secret.
+  const links = new URL(request.url).searchParams;
+  for (const name of SECRETS) links.delete(name);
+  // The parts of the backend read the options in the query. The options of
+  // rclone do not go to Google.
+  const target = new URL(request.url);
+  target.search = `${optionsOf(request, "drive", env)}`;
+  request = new Request(target, {
+    method: request.method,
+    headers: remoteHeaders(
+      request.headers,
+      "drive",
+      "https://www.googleapis.com/",
+    ),
+    body: request.body,
+    duplex: "half",
+  });
+
   //#region Auth
   const response = await auth(request);
   if (!response.ok) {
@@ -45,7 +71,7 @@ async function drive(request) {
   let status = 200, body = null;
 
   const { method, url } = request;
-  let { pathname, searchParams } = new URL(url);
+  let { pathname } = new URL(url);
 
   pathname = decodeURIComponent(pathname);
   const isDirectory = pathname.endsWith("/");
@@ -98,7 +124,7 @@ async function drive(request) {
             <tbody>
               <tr>
                 <td>📁</td>
-                <td><a href="../?${searchParams}">Go up</a></td>
+                <td><a href="../?${links}">Go up</a></td>
                 <td>—</td>
                 <td>—</td>
               </tr>
@@ -115,7 +141,7 @@ async function drive(request) {
                 <td>${isDirectory ? "📁" : "📄"}</td>
                 <td>
                   <a
-                    href="${filePath}?${searchParams}"
+                    href="${filePath}?${links}"
                     type="${mimeType}"
                   >${name}</a>
                 </td>
diff --git a/backend/http/main.js b/backend/http/main.js
index e0ba06d..cbb0edb 100644
--- a/backend/http/main.js
+++ b/backend/http/main.js
@@ -28,6 +28,7 @@ import { HTMLRewriter } from "@sntran/html-rewriter";
 import { parseList } from "./list.js";
 import { childOf, renderListing } from "@rfetch/lib/listing";
 import { mimeType } from "@rfetch/lib/mime";
+import { optionsOf } from "@rfetch/lib/options";
 import { decodePath, encodePath } from "@rfetch/lib/path";
 
 export const options = {
@@ -76,15 +77,18 @@ class HTTPError extends Error {
 /**
  * Serves a HTTP remote. It is read only, as the http backend of rclone.
  * @param {Request} request
+ * @param {Record<string, unknown>} [env] The options in the variables
+ *   `RCLONE_HTTP_*`.
  * @returns {Promise<Response>}
  */
-async function http(request) {
+async function http(request, env = {}) {
   const { method } = request;
   const { pathname, searchParams } = new URL(request.url);
+  const options = optionsOf(request, "http", env);
 
   let base;
   try {
-    base = new URL(searchParams.get("url") ?? "");
+    base = new URL(options.get("url") ?? "");
   } catch {
     return new Response("The url option is not a URL", { status: 400 });
   }
@@ -106,7 +110,7 @@ async function http(request) {
 
   let headers;
   try {
-    headers = parseHeaders(searchParams.get("headers") ?? "");
+    headers = parseHeaders(options.get("headers") ?? "");
   } catch (error) {
     return new Response(`The headers option is not correct: ${error.message}`, {
       status: 400,
@@ -118,7 +122,7 @@ async function http(request) {
     if (!path.endsWith("/")) {
       return await getFile(target, method, headers, path, request);
     }
-    const noHead = searchParams.get("no_head") === "true";
+    const noHead = options.get("no_head") === "true";
     const query = new URLSearchParams(searchParams);
     for (const name of SECRETS) query.delete(name);
     return await getFolder(target, method, headers, noHead, `${query}`);
diff --git a/backend/http/main_test.js b/backend/http/main_test.js
index 3b00638..873342c 100644
--- a/backend/http/main_test.js
+++ b/backend/http/main_test.js
@@ -19,6 +19,7 @@ after(() => server.close());
 
 // The suite writes to the memory backend, and reads through the server.
 backendSuite("http", backend, {
+  type: "http",
   params: { url: `${server.url}` },
   writer: memory,
 });
diff --git a/backend/s3/main.js b/backend/s3/main.js
index b909d37..3296a24 100644
--- a/backend/s3/main.js
+++ b/backend/s3/main.js
@@ -39,6 +39,7 @@
 import { createHash } from "node:crypto";
 import { renderListing } from "@rfetch/lib/listing";
 import { mimeType } from "@rfetch/lib/mime";
+import { optionsOf } from "@rfetch/lib/options";
 import { decodePath } from "@rfetch/lib/path";
 import {
   notSatisfiable,
@@ -119,7 +120,7 @@ async function s3(request, env = {}) {
 
   let config;
   try {
-    config = configOf(searchParams, env);
+    config = configOf(request, env);
   } catch (error) {
     return new Response(error.message, { status: 400 });
   }
@@ -179,18 +180,15 @@ async function s3(request, env = {}) {
 
 /**
  * Reads the options of a request, as `NewFs` of the s3 backend of rclone.
- * @param {URLSearchParams} searchParams
+ * @param {Request} request
  * @param {Record<string, unknown>} env
  * @returns {Config}
  * @throws {Error} When an option is not correct.
  */
-function configOf(searchParams, env) {
+function configOf(request, env) {
+  const values = optionsOf(request, "s3", env);
   /** @param {string} name */
-  const get = (name) => {
-    const value = searchParams.get(name) ??
-      env[`RCLONE_S3_${name.toUpperCase()}`];
-    return typeof value === "string" ? value : options.default[name] ?? "";
-  };
+  const get = (name) => values.get(name) ?? options.default[name] ?? "";
   const region = get("region") || "us-east-1";
   let endpoint = get("endpoint") ||
     `https://s3.${region}.amazonaws.com`;
diff --git a/backend/s3/main_test.js b/backend/s3/main_test.js
index f548a35..aad7974 100644
--- a/backend/s3/main_test.js
+++ b/backend/s3/main_test.js
@@ -23,9 +23,15 @@ if (hasRclone) {
   const params = { ...KEYS, endpoint: server.endpoint, region: "us-east-1" };
 
   // S3 has no empty folders with no markers, as rclone.
-  backendSuite("s3", s3, { params, parent: "/rfetch/", emptyFolders: false });
+  backendSuite("s3", s3, {
+    type: "s3",
+    params,
+    parent: "/rfetch/",
+    emptyFolders: false,
+  });
   // Files in parts: upload_cutoff of 100 KiB, and parts of 5 MiB.
   backendSuite("s3 in parts", s3, {
+    type: "s3",
     params: { ...params, upload_cutoff: "100k" },
     parent: "/rfetch/",
     emptyFolders: false,
@@ -182,8 +188,15 @@ if (S3_TEST_ENDPOINT && S3_TEST_BUCKET) {
     region: S3_TEST_REGION ?? "auto",
   };
   const parent = `/${S3_TEST_BUCKET}/`;
-  backendSuite("s3 service", s3, { params, env, parent, emptyFolders: false });
+  backendSuite("s3 service", s3, {
+    type: "s3",
+    params,
+    env,
+    parent,
+    emptyFolders: false,
+  });
   backendSuite("s3 service with folder markers", s3, {
+    type: "s3",
     params: { ...params, directory_markers: "true" },
     env,
     parent,
diff --git a/lib/testing/remote.js b/lib/testing/remote.js
index bc91d98..99cea94 100644
--- a/lib/testing/remote.js
+++ b/lib/testing/remote.js
@@ -9,11 +9,15 @@ const ORIGIN = "http://rfetch.test";
  * puts the percent-encoding in each name, and the parameters of the backend
  * in the query.
  * @param {{ fetch: (request: Request, env?: object) => Response | Promise<Response> }} backend
- * @param {{ params?: Record<string, string>, root?: string, env?: object }} [options]
+ * @param {{ params?: Record<string, string>, root?: string, env?: object, headers?: HeadersInit }} [options]
  *   `root` is a folder, for example `/rfetch-test-abc/`, under which all
  *   paths go. `env` is the env of the backend, for example the credentials of s3.
+ *   `headers` go in each request, for example the options `RCLONE_S3_*`.
  */
-export function remote(backend, { params = {}, root = "/", env = {} } = {}) {
+export function remote(
+  backend,
+  { params = {}, root = "/", env = {}, headers = {} } = {},
+) {
   /**
    * Gives the URL of the path under the root.
    * @param {string} path
@@ -36,8 +40,10 @@ export function remote(backend, { params = {}, root = "/", env = {} } = {}) {
    * @returns {Promise<Response>}
    */
   async function send(path, init = {}) {
+    const all = new Headers(headers);
+    for (const [name, value] of new Headers(init.headers)) all.set(name, value);
     return await backend.fetch(
-      new Request(url(path), { duplex: "half", ...init }),
+      new Request(url(path), { duplex: "half", ...init, headers: all }),
       env,
     );
   }
diff --git a/lib/testing/suite.js b/lib/testing/suite.js
index 94a5a4b..ba58411 100644
--- a/lib/testing/suite.js
+++ b/lib/testing/suite.js
@@ -55,6 +55,7 @@ const FILE2 = `hello? sausage/êé/Hello, 世界/ " ' @ < > & ? + ≠/z.txt`;
  *   writer?: { fetch: (request: Request) => Response | Promise<Response> },
  *   parent?: string,
  *   emptyFolders?: boolean,
+ *   type?: string,
  * }} [options] `params` go in the query of each request, for example the
  *   options of the backend. `env` is the env of the backend, for example
  *   the credentials of s3. The tests skip the names that match `skipName`,
@@ -65,7 +66,9 @@ const FILE2 = `hello? sausage/êé/Hello, 世界/ " ' @ < > & ? + ≠/z.txt`;
  *   bucket `/bucket/` of s3. `emptyFolders` is false for a backend that
  *   cannot have an empty folder, as `CanHaveEmptyDirectories` of rclone:
  *   for example s3 with no folder markers. Then a folder with no file
- *   gives 404, as a folder that does not exist.
+ *   gives 404, as a folder that does not exist. `type` is the type of the
+ *   backend in rclone, for example `s3`: with it, the tests also give the
+ *   `params` in the headers `RCLONE_TYPE_NAME` and in `env`.
  */
 export function backendSuite(
   name,
@@ -77,6 +80,7 @@ export function backendSuite(
     writer,
     parent = "/",
     emptyFolders = true,
+    type,
   } = {},
 ) {
   const root = `${parent}rfetch-test-${randomBytes(6).toString("hex")}/`;
@@ -316,6 +320,33 @@ export function backendSuite(
       });
     });
 
+    it("reads the options from the headers and from env", {
+      skip: type && Object.keys(params).length ? false : "no options",
+    }, async () => {
+      /** @type {Record<string, string>} */
+      const variables = {};
+      for (const [key, value] of Object.entries(params)) {
+        variables[`RCLONE_${type.toUpperCase()}_${key.toUpperCase()}`] = value;
+      }
+      const byHeaders = remote(backend, { root, env, headers: variables });
+      const byEnv = remote(backend, { root, env: { ...env, ...variables } });
+      const content = random(100);
+      if (writer) {
+        await expect(fs.put("options.txt", content), 201);
+      } else {
+        await expect(byHeaders.put("options.txt", content), 201);
+      }
+      for (const client of [byHeaders, byEnv]) {
+        const response = await client.get("options.txt");
+        assert.equal(response.status, 200);
+        assert.deepEqual(new Uint8Array(await response.arrayBuffer()), content);
+        // The options are not in the query, thus no link has a query.
+        const html = await (await client.get("")).text();
+        assert.doesNotMatch(html, /href="[^"]*\?/, "a link has options");
+      }
+      await expect(fs.delete("options.txt"), 204);
+    });
+
     it("deletes the root folder of the tests", async () => {
       await expect(fs.delete(""), 204);
       await expect(fs.get(""), 404);

From 712b960ea89364934474a81807da050b33796e90 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sat, 17 Oct 2026 18:44:05 +0000
Subject: [PATCH 53/87] feat: remotes and options from the headers of a request

The fetch of mod.js reads the headers RCLONE_* of a request as the variables of rclone, in the place of the variables of the process. A remote can come only from variables, RCLONE_CONFIG_NAME_TYPE and its options, as in rclone. Thus a request can give all its configuration, with no config file.

The backend gets the options of the path, the connection string and the flags, in its query. It gets the options of the config file and of the variables in env, thus such an option is never in a link. Before, a variable of another remote, for example RCLONE_CONFIG_OTHER_SECRET_ACCESS_KEY, went into the query of each backend, and from there into the links of a list. The headers RCLONE_* never go out to a URL.

Four tests of main_test.js now find the options of the config file and of the variables in env, not in the query.
---
 CONTRIBUTING.md              |  31 ++++++++
 backend/chunker/main_test.js |  18 +++++
 backend/crypt/main_test.js   |  78 ++++++++++++++++++
 backend/crypt/package.json   |   1 +
 main_test.js                 | 132 +++++++++++++++++++++++++++++--
 mod.js                       | 148 ++++++++++++++++++++++++-----------
 package-lock.json            |   1 +
 7 files changed, 360 insertions(+), 49 deletions(-)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 71f5b0c..a39d16b 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -86,6 +86,34 @@ To count or change the requests to the remote in a test, replace the global
 `fetch` with `t.mock.method(globalThis, "fetch", …)`. The test runner puts the
 original `fetch` back at the end of the test.
 
+## Options of a backend
+
+A backend reads its options with `optionsOf(request, "remote", env)` of
+`@rfetch/lib/options`, in this order:
+
+1. a field of the query, for example `?password=…`;
+2. the header `RCLONE_REMOTE_NAME` of the request, for example
+   `RCLONE_CRYPT_PASSWORD`;
+3. the variable `RCLONE_REMOTE_NAME` of `env`.
+
+These are the names of the variables of rclone. Thus a client can give a secret
+in a header, and a Worker can give it in `env`: then the secret is not in a URL.
+A backend makes the links of a list from the query of the request only, with no
+secret option. Thus an option of a header or of `env` is never in a link.
+
+A backend on top of another remote sends the headers
+`remoteHeaders(request.headers, "remote", remote)` to that remote. The other
+options of the request go on, for example a remote `RCLONE_CONFIG_NAME_TYPE`
+that only the headers tell. The options of the backend itself do not go. When
+the remote is a URL, no option goes: a secret must not go out to a server.
+
+The `fetch` of `mod.js` reads the headers `RCLONE_*` of a request as the
+variables of rclone, in the place of the variables of the process. A remote can
+come only from variables: `RCLONE_CONFIG_NAME_TYPE` and its options, as in
+rclone. The backend gets the options of the path, the connection string and the
+flags, in its query, and all the other options in `env`. The headers `RCLONE_*`
+never go out to a URL.
+
 ## Workspaces
 
 Each backend is an npm workspace with the name `@rfetch/NAME`, and can be a
@@ -213,6 +241,9 @@ Other options are for some backends only:
 - `emptyFolders`: `false` for a backend that cannot have an empty folder, as
   `CanHaveEmptyDirectories` of rclone. For example, `s3` with no folder markers.
   Then the suite accepts 404 for a folder with no file.
+- `type`: the type of the backend in rclone, for example `crypt`. With it, the
+  suite also gives the `params` in the headers `RCLONE_TYPE_NAME` and in `env`,
+  and makes sure that no link of a list has a query.
 
 Put the tests for what only one backend does in the same file, after the suite.
 For example, the tests of the local backend make sure that a path cannot go out
diff --git a/backend/chunker/main_test.js b/backend/chunker/main_test.js
index 6af3011..e725f97 100644
--- a/backend/chunker/main_test.js
+++ b/backend/chunker/main_test.js
@@ -226,3 +226,21 @@ describe("chunker", () => {
     await counted.delete("range.bin");
   });
 });
+
+test("chunker on a named remote of the headers", async () => {
+  // A request to chunker with the headers, as a Worker gets it. Each chunk
+  // goes to the remote `vault`, which only the headers tell.
+  const client = remote(backend, {
+    headers: {
+      RCLONE_CHUNKER_REMOTE: "vault:chunker-headers",
+      RCLONE_CHUNKER_CHUNK_SIZE: "1k",
+      RCLONE_CONFIG_VAULT_TYPE: "memory",
+    },
+  });
+  const data = content(2500);
+  assert.equal((await client.put("big.bin", data)).status, 201);
+  const response = await client.get("big.bin");
+  assert.deepEqual(new Uint8Array(await response.arrayBuffer()), data);
+  const list = await (await fetch(":memory:chunker-headers/")).text();
+  assert.match(list, /big\.bin\.rclone_chunk\.003/);
+});
diff --git a/backend/crypt/main_test.js b/backend/crypt/main_test.js
index 62223a3..1120a51 100644
--- a/backend/crypt/main_test.js
+++ b/backend/crypt/main_test.js
@@ -7,9 +7,11 @@ import fc from "fast-check";
 
 import { backendSuite } from "@rfetch/lib/testing/suite";
 import { remote } from "@rfetch/lib/testing/remote";
+import { listen } from "@rfetch/lib/testing/server";
 import { fetch } from "../../mod.js";
 import { mimeType } from "@rfetch/lib/mime";
 import { decode, default as crypt, deriveKey, encode } from "./main.js";
+import memory from "@rfetch/memory";
 
 // The password "123456" and the salt, obscured.
 const PASSWORD = "UmyLSdRHfew6aual28-ggx78qHqSfQ";
@@ -257,3 +259,79 @@ describe("crypt", () => {
     }
   });
 });
+
+describe("crypt with its options in headers", () => {
+  /** The configuration of a client, with no config file. */
+  const headers = {
+    RCLONE_CRYPT_REMOTE: "vault:crypt-headers",
+    RCLONE_CRYPT_PASSWORD: PASSWORD,
+    RCLONE_CONFIG_VAULT_TYPE: "memory",
+  };
+
+  test("reads a named remote of the headers, and keeps its password", async (t) => {
+    /** The headers of each request of crypt to its remote. */
+    const sent = [];
+    t.mock.method(globalThis, "fetch", (input, init = {}) => {
+      sent.push(new Headers(init.headers));
+      return fetch(input, init);
+    });
+    // A request to crypt with the headers, as a Worker gets it.
+    const client = remote(crypt, { headers });
+    const put = await client.put(
+      "a.txt",
+      new TextEncoder().encode("secret text"),
+    );
+    assert.equal(put.status, 201);
+    assert.equal(await (await client.get("a.txt")).text(), "secret text");
+
+    assert.ok(sent.length > 0);
+    for (const headers of sent) {
+      assert.equal(headers.get("RCLONE_CONFIG_VAULT_TYPE"), "memory");
+      assert.equal(headers.get("RCLONE_CRYPT_PASSWORD"), null);
+      assert.equal(headers.get("RCLONE_CRYPT_REMOTE"), null);
+    }
+    // The file is encrypted in the remote.
+    const list = await (await fetch(":memory:crypt-headers/")).text();
+    assert.doesNotMatch(list, /a\.txt/);
+    assert.match(list, /href="[a-z0-9]+"/);
+  });
+
+  test("gives no option to a remote that is a URL", async (t) => {
+    // What crypt gives to the global fetch: a platform with no rfetch sends
+    // it as it is.
+    /** @type {Headers[]} */
+    const sent = [];
+    t.mock.method(globalThis, "fetch", (input, init = {}) => {
+      sent.push(new Headers(init.headers));
+      return fetch(input, init);
+    });
+    /** @type {Headers[]} */
+    const seen = [];
+    const server = await listen((request) => {
+      seen.push(request.headers);
+      return memory.fetch(request);
+    });
+    try {
+      const client = remote(crypt, {
+        headers: {
+          ...headers,
+          RCLONE_CRYPT_REMOTE: new URL("/crypt-url/", server.url).href,
+        },
+      });
+      assert.equal(
+        (await client.put("b.txt", new TextEncoder().encode("b"))).status,
+        201,
+      );
+      assert.equal(await (await client.get("b.txt")).text(), "b");
+      assert.ok(seen.length > 0);
+      for (const headers of [...sent, ...seen]) {
+        assert.deepEqual(
+          [...headers.keys()].filter((name) => name.startsWith("rclone_")),
+          [],
+        );
+      }
+    } finally {
+      await server.close();
+    }
+  });
+});
diff --git a/backend/crypt/package.json b/backend/crypt/package.json
index 5988987..79ea367 100644
--- a/backend/crypt/package.json
+++ b/backend/crypt/package.json
@@ -28,6 +28,7 @@
     "base32-encode": "^2.0.0"
   },
   "devDependencies": {
+    "@rfetch/memory": "^0.1.0",
     "fast-check": "^3.19.0"
   }
 }
diff --git a/main_test.js b/main_test.js
index 7a0861d..901a6f4 100644
--- a/main_test.js
+++ b/main_test.js
@@ -4,8 +4,21 @@ import { unlink, writeFile } from "node:fs/promises";
 import { serve } from "@sntran/serve";
 import assert from "node:assert/strict";
 
+import { listen } from "@rfetch/lib/testing/server";
 import { config, fetch } from "./mod.js";
 
+/**
+ * Gives an option in the `env` of the backend, from the body of an answer to
+ * `TRACE`: the options of the config file and of the variables are not in
+ * the query, thus they are never in a link.
+ * @param {string} body
+ * @param {string} name For example `RCLONE_ALIAS_REMOTE`.
+ */
+function variableOf(body, name) {
+  const line = body.split("\r").find((line) => line.startsWith(`${name}: `));
+  return line?.slice(name.length + 2);
+}
+
 test("fetch", async (t) => {
   await t.test("global", () => {
     const controller = new AbortController();
@@ -101,7 +114,8 @@ test("fetch", async (t) => {
         const { pathname, searchParams } = new URL(url, "file:");
 
         assert.deepEqual(pathname, "/");
-        assert.deepEqual(searchParams.get("remote"), `source:`);
+        assert(!searchParams.has("remote"), "the config is not in the query");
+        assert.deepEqual(variableOf(body, "RCLONE_ALIAS_REMOTE"), `source:`);
       });
 
       await t.test(
@@ -116,8 +130,9 @@ test("fetch", async (t) => {
             [];
           const { searchParams } = new URL(url, "file:");
 
-          assert.deepEqual(searchParams.get("remote"), `source:`);
-          assert.deepEqual(searchParams.get("skip_links"), `true`);
+          assert(!searchParams.has("skip_links"), "not in the query");
+          assert.deepEqual(variableOf(body, "RCLONE_ALIAS_REMOTE"), `source:`);
+          assert.deepEqual(variableOf(body, "RCLONE_ALIAS_SKIP_LINKS"), `true`);
         },
       );
 
@@ -133,7 +148,8 @@ test("fetch", async (t) => {
             [];
           const { searchParams } = new URL(url, "file:");
 
-          assert.deepEqual(searchParams.get("remote"), `/tmp/1`);
+          assert(!searchParams.has("remote"), "not in the query");
+          assert.deepEqual(variableOf(body, "RCLONE_ALIAS_REMOTE"), `/tmp/1`);
           assert(
             !searchParams.has("alias_remote"),
             "should not have param prefixed with backend type",
@@ -153,7 +169,8 @@ test("fetch", async (t) => {
             [];
           const { searchParams } = new URL(url, "file:");
 
-          assert.deepEqual(searchParams.get("remote"), `/tmp/2`);
+          assert(!searchParams.has("remote"), "not in the query");
+          assert.deepEqual(variableOf(body, "RCLONE_ALIAS_REMOTE"), `/tmp/2`);
           assert(
             !searchParams.has("config_target_remote"),
             "should not have param prefixed with remote name",
@@ -231,3 +248,108 @@ test("fetch", async (t) => {
     delete process.env.RCLONE_CONFIG_TARGET_REMOTE;
   });
 });
+
+test("options in the headers of a request", async (t) => {
+  await t.test("a remote only from the headers, with no config file", async () => {
+    const headers = { RCLONE_CONFIG_MEM_TYPE: "memory" };
+    const put = await fetch("mem:headers/a.txt", {
+      method: "PUT",
+      body: "from the headers",
+      headers,
+    });
+    assert.equal(put.status, 201);
+    const response = await fetch("mem:headers/a.txt", { headers });
+    assert.equal(await response.text(), "from the headers");
+    // The same remote, as a remote on the fly.
+    const plain = await fetch(":memory:headers/a.txt");
+    assert.equal(await plain.text(), "from the headers");
+    await assert.rejects(fetch("mem:headers/a.txt"), /Remote mem not found/);
+  });
+
+  await t.test("a header takes the place of a variable", async () => {
+    process.env.RCLONE_CONFIG_PLACE_TYPE = "alias";
+    process.env.RCLONE_CONFIG_PLACE_REMOTE = "/tmp/env";
+    try {
+      const response = await fetch("place:", {
+        method: "TRACE",
+        headers: { RCLONE_CONFIG_PLACE_REMOTE: "/tmp/header" },
+      });
+      const body = await response.text();
+      assert.equal(variableOf(body, "RCLONE_ALIAS_REMOTE"), "/tmp/header");
+    } finally {
+      delete process.env.RCLONE_CONFIG_PLACE_TYPE;
+      delete process.env.RCLONE_CONFIG_PLACE_REMOTE;
+    }
+  });
+
+  await t.test("the variables of other remotes are not options", async () => {
+    process.env.RCLONE_CONFIG_OTHER_SECRET_ACCESS_KEY = "other-secret";
+    try {
+      const response = await fetch(":memory:leak/", {
+        method: "TRACE",
+        headers: { RCLONE_CONFIG_THIRD_PASSWORD: "third-secret" },
+      });
+      const body = await response.text();
+      assert(!body.includes("RCLONE_MEMORY_CONFIG_"), body);
+      const [, url] = body.match(/^TRACE (.*) HTTP\/1.1$/m);
+      assert.equal(
+        new URL(url, "file:").search,
+        "",
+        "an option is in the query",
+      );
+
+      await fetch(":memory:leak/a.txt", { method: "PUT", body: "a" });
+      const html = await (await fetch(":memory:leak/", {
+        headers: { RCLONE_CONFIG_THIRD_PASSWORD: "third-secret" },
+      })).text();
+      assert(!html.includes("other-secret"), "a variable is in a link");
+      assert(!html.includes("third-secret"), "a header is in a link");
+    } finally {
+      delete process.env.RCLONE_CONFIG_OTHER_SECRET_ACCESS_KEY;
+    }
+  });
+
+  await t.test("no option goes out to a URL", async () => {
+    /** @type {Headers[]} */
+    const seen = [];
+    const server = await listen((request) => {
+      seen.push(request.headers);
+      return new Response("ok");
+    });
+    try {
+      const headers = {
+        RCLONE_S3_SECRET_ACCESS_KEY: "secret",
+        RCLONE_CONFIG_R2_TYPE: "s3",
+        "X-Other": "other",
+      };
+      await (await fetch(`${server.url}`, { headers })).text();
+      await (await fetch(new Request(server.url, { headers }))).text();
+      await (await fetch(server.url, { headers })).text();
+      assert.equal(seen.length, 3);
+      for (const headers of seen) {
+        assert.equal(headers.get("x-other"), "other");
+        assert.deepEqual(
+          [...headers.keys()].filter((name) => name.startsWith("rclone_")),
+          [],
+        );
+      }
+    } finally {
+      await server.close();
+    }
+  });
+
+  await t.test("two requests at the same time, each with its own remote", async () => {
+    await fetch(":memory:one/a.txt", { method: "PUT", body: "one" });
+    await fetch(":memory:two/a.txt", { method: "PUT", body: "two" });
+    /** @param {string} folder */
+    const get = (folder) =>
+      fetch("tenant:a.txt", {
+        headers: {
+          RCLONE_CONFIG_TENANT_TYPE: "alias",
+          RCLONE_CONFIG_TENANT_REMOTE: `:memory:${folder}`,
+        },
+      }).then((response) => response.text());
+    const folders = Array.from({ length: 20 }, (_, i) => i % 2 ? "one" : "two");
+    assert.deepEqual(await Promise.all(folders.map(get)), folders);
+  });
+});
diff --git a/mod.js b/mod.js
index dd8cbaf..4817c60 100644
--- a/mod.js
+++ b/mod.js
@@ -1,7 +1,8 @@
 import { env } from "node:process";
-import { load } from "./backend/main.js";
+import { backends, load } from "./backend/main.js";
 import * as commands from "./cmd/main.js";
 import { parse } from "@rfetch/lib/fspath";
+import { isOption } from "@rfetch/lib/options";
 
 export * from "./cmd/main.js";
 
@@ -92,6 +93,21 @@ const globalFetch = globalThis.fetch;
  * variable `RCLONE_LOCAL_SKIP_LINKS` is set, the command line flag will take
  * preference.
  *
+ * A header of the request with the name of a variable, for example
+ * `RCLONE_CONFIG_MYREMOTE_SKIP_LINKS`, takes the place of the variable of the
+ * environment. A remote can come only from variables, as in rclone:
+ * `RCLONE_CONFIG_MYREMOTE_TYPE` and its options. Thus a request can give
+ * all its configuration, with no config file.
+ *
+ * The backend gets the options of the path, the connection string and the
+ * flags, in the query of its request. It gets the other options in `env`,
+ * the second argument of its `fetch`, with the names of the variables of
+ * rclone, for example `RCLONE_LOCAL_SKIP_LINKS`. A backend makes the links of
+ * a list from the query only, thus an option of `env` is never in a link.
+ *
+ * The headers `RCLONE_*` are only for the backends of rfetch: they never go
+ * out to a URL.
+ *
  * For non backend configuration the order is as follows:
  *
  * - Flag values as supplied on the command line, e.g. `--stats 5s`.
@@ -109,24 +125,20 @@ export async function fetch(input, init = {}) {
     typeof input !== "string" || input.startsWith("https://") ||
     input.startsWith("http://") || input.startsWith("file://")
   ) {
-    return globalFetch(input, init);
+    return globalFetch(...withoutOptions(input, init));
   }
 
   // The parts of the path, as rclone reads them. It throws a SyntaxError
   // for a path that is not correct.
   const parsed = parse(input);
 
-  // The final params.
-  const params = new URLSearchParams();
-
-  /**
-   * Sets backend generic environment vars first.
-   */
-  for (const [key, value] of Object.entries(env)) {
-    if (key.startsWith("RCLONE_")) {
-      const shortKey = key.slice(7).toLowerCase();
-      params.set(shortKey, value);
-    }
+  const headers = new Headers(init.headers);
+  // The variables of rclone: the environment of the process, then the
+  // headers of the request, which take their place.
+  /** @type {Record<string, string>} */
+  const variables = { ...env };
+  for (const [key, value] of headers) {
+    if (isOption(key)) variables[key.toUpperCase()] = value;
   }
 
   let { name } = parsed;
@@ -142,72 +154,94 @@ export async function fetch(input, init = {}) {
     config = { type: name.slice(1) };
     name = "";
   } else {
+    // A remote of the config file, or of the variables, as rclone.
+    const type = variables[`RCLONE_CONFIG_${name.toUpperCase()}_TYPE`];
     const response = await commands.config("show", name, undefined, {
       headers: { "Accept": "application/json" },
-    });
-    if (!response.ok) {
+    }).catch(() => null);
+    if (response?.ok) {
+      config = await response.json();
+    } else if (type) {
+      config = {};
+    } else {
       throw new Error(`Remote ${name} not found in config.`);
     }
-    config = await response.json();
+    if (type) config.type = type;
   }
 
   const type = config.type;
   delete config.type;
 
-  // Stores config into params if not already set, with lowest precedence.
-  Object.entries(config).forEach(([key, value]) => {
-    if (!params.has(key)) {
-      params.set(key, value);
-    }
-  });
+  // The options that are not in the path, from the lowest precedence: the
+  // config file, then the variables.
+  const options = new Map(Object.entries(config));
 
-  // Overrides with backend-specific environment vars.
-  let envPrefix = `RCLONE_${type.toUpperCase()}_`;
-  for (const [key, value] of Object.entries(env)) {
-    if (key.startsWith(envPrefix)) {
-      const shortKey = key.slice(envPrefix.length).toLowerCase();
-      params.set(shortKey, value);
+  // Backend generic variables, for example `RCLONE_SKIP_LINKS`. A variable
+  // of a remote or of a backend is not generic: it is not an option of each
+  // backend.
+  const specific = ["CONFIG", ...Object.keys(backends)]
+    .map((prefix) => `RCLONE_${prefix.toUpperCase()}_`);
+  for (const [key, value] of Object.entries(variables)) {
+    if (!key.startsWith("RCLONE_")) continue;
+    if (specific.some((prefix) => key.startsWith(prefix))) continue;
+    options.set(key.slice("RCLONE_".length).toLowerCase(), value);
+  }
 
-      // Deletes any params that are already set by environment vars.
-      params.delete(`${type}_${shortKey}`);
+  // Backend-specific variables, for example `RCLONE_LOCAL_SKIP_LINKS`.
+  let prefix = `RCLONE_${type.toUpperCase()}_`;
+  for (const [key, value] of Object.entries(variables)) {
+    if (key.startsWith(prefix)) {
+      options.set(key.slice(prefix.length).toLowerCase(), value);
     }
   }
 
-  // Overrides with remote specific environment vars
-  envPrefix = `RCLONE_CONFIG_${name.toUpperCase()}_`;
-  for (const [key, value] of Object.entries(env)) {
-    if (key.startsWith(envPrefix)) {
-      const shortKey = key.slice(envPrefix.length).toLowerCase();
-      params.set(shortKey, value);
-
-      // Deletes any params that are already set by environment vars.
-      params.delete(`config_${name}_${shortKey}`);
+  // Remote specific variables, for example `RCLONE_CONFIG_MYREMOTE_SKIP_LINKS`.
+  if (name) {
+    prefix = `RCLONE_CONFIG_${name.toUpperCase()}_`;
+    for (const [key, value] of Object.entries(variables)) {
+      if (key.startsWith(prefix) && key !== `${prefix}TYPE`) {
+        options.set(key.slice(prefix.length).toLowerCase(), value);
+      }
     }
   }
 
   // `searchParams` may contain other flags not for the current backend.
   const { pathname, searchParams } = new URL(parsed.path, "file:");
 
-  // Overrides with flags in request's search params.
+  // The query of the backend: the flags prefixed with the backend type, then
+  // the parameters in the connection string, which take their place.
+  const params = new URLSearchParams();
   searchParams.forEach((value, key) => {
     if (key.startsWith(`${type}_`)) {
       params.set(key.replace(`${type}_`, ""), value);
     }
   });
-
-  // Overrides with parameters in connection string.
   for (const [key, value] of Object.entries(parsed.config)) {
     params.set(key, value);
   }
 
-  const headers = new Headers(init.headers);
+  // The other options go in `env`. The backend reads its query first, as a
+  // flag takes the place of a variable.
+  /** @type {Record<string, string>} */
+  const optionsEnv = {};
+  for (const [key, value] of options) {
+    optionsEnv[`RCLONE_${type.toUpperCase()}_${key.toUpperCase()}`] = value;
+  }
+  // The headers of this backend are in its options now.
+  const own = `rclone_${type.toLowerCase()}_`;
+  for (const key of [...headers.keys()]) {
+    if (key.startsWith(own)) headers.delete(key);
+  }
 
   if (init.method === "TRACE") {
     let body = `TRACE ${pathname}?${params} HTTP/1.1\r`;
-    // Reflects the request as response body.
+    // Reflects the request as response body, then the options in `env`.
     for (const [name, value] of headers) {
       body += `${name}: ${value}\r`;
     }
+    for (const [name, value] of Object.entries(optionsEnv)) {
+      body += `${name}: ${value}\r`;
+    }
     return new Response(body, {
       status: 200,
       headers: {
@@ -235,8 +269,34 @@ export async function fetch(input, init = {}) {
     new Request(request, {
       headers,
     }),
+    optionsEnv,
   );
 }
 
+/**
+ * Removes the options of rclone from a request to a URL: they are only for
+ * the backends of rfetch.
+ * @param {string | Request | URL} input
+ * @param {RequestInit} init
+ * @returns {[string | Request | URL, RequestInit]}
+ */
+function withoutOptions(input, init) {
+  /** @param {HeadersInit} [from] */
+  const clean = (from) => {
+    const headers = new Headers(from);
+    for (const key of [...headers.keys()]) {
+      if (isOption(key)) headers.delete(key);
+    }
+    return headers;
+  };
+  if (input instanceof Request) {
+    input = new Request(input, { headers: clean(input.headers) });
+  }
+  if (init.headers !== undefined) {
+    init = { ...init, headers: clean(init.headers) };
+  }
+  return [input, init];
+}
+
 // The other URLs go to the original `fetch`.
 globalThis.fetch = fetch;
diff --git a/package-lock.json b/package-lock.json
index 98d12ef..9aca153 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -70,6 +70,7 @@
         "base32-encode": "^2.0.0"
       },
       "devDependencies": {
+        "@rfetch/memory": "^0.1.0",
         "fast-check": "^3.19.0"
       },
       "engines": {

From 6f3c902ac00a4f8ce11e2b12531df84209e861d9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sun, 18 Oct 2026 12:08:43 +0000
Subject: [PATCH 54/87] fix(test): the time of a file in the shared suite, with
 whole seconds

Last-Modified has whole seconds, and the clock of a file system can be some milliseconds behind Date.now(). Thus a file put at 02.001 can have the time 01.999, and the Last-Modified 01.000: 1001 ms before the start, out of the window of 1000 ms. The check now starts at the second before the second of the start.
---
 lib/testing/suite.js | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/lib/testing/suite.js b/lib/testing/suite.js
index ba58411..d71e1b4 100644
--- a/lib/testing/suite.js
+++ b/lib/testing/suite.js
@@ -452,8 +452,12 @@ function assertEntries(entries, expected) {
  * @param {string} what
  */
 function assertTime(time, start, end, what) {
+  // `Last-Modified` has whole seconds, and the clock of a file system can be
+  // some milliseconds behind `Date.now()`: thus the second of the time can
+  // start before the second of `start`.
+  const first = Math.floor((start - 100) / 1000) * 1000;
   assert.ok(
-    time >= start - 1000 && time <= end + 1000,
+    time >= first - 1000 && time <= end + 1000,
     `${what} is ${new Date(time).toISOString()}, not between ` +
       `${new Date(start).toISOString()} and ${new Date(end).toISOString()}`,
   );

From aa0edf34ca3321e88a516365b00c3e1272a1c59e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sun, 18 Oct 2026 12:08:43 +0000
Subject: [PATCH 55/87] feat: RFETCH_ as the primary prefix of the options,
 RCLONE_ for compatibility

A backend reads an option of a header or of env with the prefix RFETCH_, for example RFETCH_S3_ACCESS_KEY_ID, or with the prefix RCLONE_ of rclone. In each place, RFETCH_ takes the place of RCLONE_. The fetch of mod.js reads the variables of the process and the headers of the request with both prefixes, and gives the backend its options in env as RFETCH_TYPE_NAME. Neither prefix goes out to a URL. The shared suite gives the options with RFETCH_ in the headers and with RCLONE_ in env.
---
 CONTRIBUTING.md              | 41 +++++++++++----------
 backend/alias/main.js        |  2 +-
 backend/chunker/main.js      |  4 +--
 backend/chunker/main_test.js |  6 ++--
 backend/crypt/main.js        |  2 +-
 backend/crypt/main_test.js   |  5 +--
 backend/drive/main.js        |  2 +-
 backend/http/main.js         |  2 +-
 backend/s3/main.js           |  9 ++---
 backend/s3/main_test.js      | 12 ++++---
 lib/options.js               | 58 ++++++++++++++++++------------
 lib/options_test.js          | 29 +++++++++++++--
 lib/testing/suite.js         | 25 ++++++++++---
 main_test.js                 | 48 ++++++++++++++++++++-----
 mod.js                       | 70 ++++++++++++++++++++++--------------
 15 files changed, 214 insertions(+), 101 deletions(-)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index a39d16b..746654b 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -92,27 +92,30 @@ A backend reads its options with `optionsOf(request, "remote", env)` of
 `@rfetch/lib/options`, in this order:
 
 1. a field of the query, for example `?password=…`;
-2. the header `RCLONE_REMOTE_NAME` of the request, for example
-   `RCLONE_CRYPT_PASSWORD`;
-3. the variable `RCLONE_REMOTE_NAME` of `env`.
+2. the header `RFETCH_REMOTE_NAME` of the request, for example
+   `RFETCH_CRYPT_PASSWORD`;
+3. the variable `RFETCH_REMOTE_NAME` of `env`.
 
-These are the names of the variables of rclone. Thus a client can give a secret
-in a header, and a Worker can give it in `env`: then the secret is not in a URL.
-A backend makes the links of a list from the query of the request only, with no
-secret option. Thus an option of a header or of `env` is never in a link.
+The prefix `RCLONE_` of rclone also works, for compatibility, for example
+`RCLONE_CRYPT_PASSWORD`. In each place, `RFETCH_` takes the place of `RCLONE_`.
+Thus a client can give a secret in a header, and a Worker can give it in `env`:
+then the secret is not in a URL. A backend makes the links of a list from the
+query of the request only, with no secret option. Thus an option of a header or
+of `env` is never in a link.
 
 A backend on top of another remote sends the headers
 `remoteHeaders(request.headers, "remote", remote)` to that remote. The other
-options of the request go on, for example a remote `RCLONE_CONFIG_NAME_TYPE`
+options of the request go on, for example a remote `RFETCH_CONFIG_NAME_TYPE`
 that only the headers tell. The options of the backend itself do not go. When
 the remote is a URL, no option goes: a secret must not go out to a server.
 
-The `fetch` of `mod.js` reads the headers `RCLONE_*` of a request as the
-variables of rclone, in the place of the variables of the process. A remote can
-come only from variables: `RCLONE_CONFIG_NAME_TYPE` and its options, as in
+The `fetch` of `mod.js` reads the headers `RFETCH_*` and `RCLONE_*` of a request
+as the variables, in the place of the variables of the process. A remote can
+come only from variables: `RFETCH_CONFIG_NAME_TYPE` and its options, as in
 rclone. The backend gets the options of the path, the connection string and the
-flags, in its query, and all the other options in `env`. The headers `RCLONE_*`
-never go out to a URL.
+flags, in its query, and all the other options in `env`, as
+`RFETCH_REMOTE_NAME`. The headers `RFETCH_*` and `RCLONE_*` never go out to a
+URL.
 
 ## Workspaces
 
@@ -242,8 +245,9 @@ Other options are for some backends only:
   `CanHaveEmptyDirectories` of rclone. For example, `s3` with no folder markers.
   Then the suite accepts 404 for a folder with no file.
 - `type`: the type of the backend in rclone, for example `crypt`. With it, the
-  suite also gives the `params` in the headers `RCLONE_TYPE_NAME` and in `env`,
-  and makes sure that no link of a list has a query.
+  suite also gives the `params` in the headers `RFETCH_TYPE_NAME` and in the
+  variables `RCLONE_TYPE_NAME` of `env`, and makes sure that no link of a list
+  has a query.
 
 Put the tests for what only one backend does in the same file, after the suite.
 For example, the tests of the local backend make sure that a path cannot go out
@@ -261,9 +265,10 @@ package of Go, when `go` is in the `PATH` or when the variable `GO` is its path.
 The tests of `s3` use `rclone serve s3`, a server of the S3 API on a local
 folder. They also run on a real service when the variables `S3_TEST_ENDPOINT`
 and `S3_TEST_BUCKET` are set, with the region in `S3_TEST_REGION` (`auto` by
-default). Put the credentials in `RCLONE_S3_ACCESS_KEY_ID` and
-`RCLONE_S3_SECRET_ACCESS_KEY`. Use a bucket only for the tests: the tests make
-folders in it and delete them.
+default). Put the credentials in `RFETCH_S3_ACCESS_KEY_ID` and
+`RFETCH_S3_SECRET_ACCESS_KEY`, or in the variables of rclone with the prefix
+`RCLONE_`. Use a bucket only for the tests: the tests make folders in it and
+delete them.
 
 ## Continuous integration
 
diff --git a/backend/alias/main.js b/backend/alias/main.js
index a06a577..ed378c0 100644
--- a/backend/alias/main.js
+++ b/backend/alias/main.js
@@ -27,7 +27,7 @@ import { decodePath, encodePath } from "@rfetch/lib/path";
  * Sends the requests to the remote of the alias with the global `fetch`.
  * @param {Request} request
  * @param {Record<string, unknown>} [env] The options in the variables
- *   `RCLONE_ALIAS_*`.
+ *   `RFETCH_ALIAS_*` or `RCLONE_ALIAS_*`.
  * @returns {Promise<Response>}
  */
 async function alias(request, env = {}) {
diff --git a/backend/chunker/main.js b/backend/chunker/main.js
index 1b92b49..fdcf049 100644
--- a/backend/chunker/main.js
+++ b/backend/chunker/main.js
@@ -171,7 +171,7 @@ export const options = {
  * @property {boolean} failHard
  * @property {ReturnType<typeof nameFormat>} names
  * @property {Headers} forward The options of the request for the remote,
- *   for example `RCLONE_CONFIG_NAME_KEY`.
+ *   for example `RFETCH_CONFIG_NAME_KEY`.
  */
 
 /**
@@ -179,7 +179,7 @@ export const options = {
  * `fetch`.
  * @param {Request} request
  * @param {Record<string, unknown>} [env] The options in the variables
- *   `RCLONE_CHUNKER_*`.
+ *   `RFETCH_CHUNKER_*` or `RCLONE_CHUNKER_*`.
  * @returns {Promise<Response>}
  */
 async function chunker(request, env = {}) {
diff --git a/backend/chunker/main_test.js b/backend/chunker/main_test.js
index e725f97..8fed704 100644
--- a/backend/chunker/main_test.js
+++ b/backend/chunker/main_test.js
@@ -232,9 +232,9 @@ test("chunker on a named remote of the headers", async () => {
   // goes to the remote `vault`, which only the headers tell.
   const client = remote(backend, {
     headers: {
-      RCLONE_CHUNKER_REMOTE: "vault:chunker-headers",
-      RCLONE_CHUNKER_CHUNK_SIZE: "1k",
-      RCLONE_CONFIG_VAULT_TYPE: "memory",
+      RFETCH_CHUNKER_REMOTE: "vault:chunker-headers",
+      RFETCH_CHUNKER_CHUNK_SIZE: "1k",
+      RFETCH_CONFIG_VAULT_TYPE: "memory",
     },
   });
   const data = content(2500);
diff --git a/backend/crypt/main.js b/backend/crypt/main.js
index 19c80f0..cc2badf 100644
--- a/backend/crypt/main.js
+++ b/backend/crypt/main.js
@@ -159,7 +159,7 @@ const SECRETS = ["password", "password2"];
  * global `fetch`.
  * @param {Request} request
  * @param {Record<string, unknown>} [env] The options in the variables
- *   `RCLONE_CRYPT_*`.
+ *   `RFETCH_CRYPT_*` or `RCLONE_CRYPT_*`.
  * @returns {Promise<Response>}
  */
 async function crypt(request, env = {}) {
diff --git a/backend/crypt/main_test.js b/backend/crypt/main_test.js
index 1120a51..5a5eacd 100644
--- a/backend/crypt/main_test.js
+++ b/backend/crypt/main_test.js
@@ -315,7 +315,8 @@ describe("crypt with its options in headers", () => {
       const client = remote(crypt, {
         headers: {
           ...headers,
-          RCLONE_CRYPT_REMOTE: new URL("/crypt-url/", server.url).href,
+          RFETCH_CRYPT_REMOTE: new URL("/crypt-url/", server.url).href,
+          RFETCH_CONFIG_OTHER_TYPE: "memory",
         },
       });
       assert.equal(
@@ -326,7 +327,7 @@ describe("crypt with its options in headers", () => {
       assert.ok(seen.length > 0);
       for (const headers of [...sent, ...seen]) {
         assert.deepEqual(
-          [...headers.keys()].filter((name) => name.startsWith("rclone_")),
+          [...headers.keys()].filter((name) => /^r(clone|fetch)_/.test(name)),
           [],
         );
       }
diff --git a/backend/drive/main.js b/backend/drive/main.js
index 0a6e77a..0dfbbce 100644
--- a/backend/drive/main.js
+++ b/backend/drive/main.js
@@ -24,7 +24,7 @@ const SECRETS = ["token", "client_secret", "service_account_credentials"];
  * Serves a Google Drive remote.
  * @param {Request} request
  * @param {Record<string, unknown>} [env] The options in the variables
- *   `RCLONE_DRIVE_*`.
+ *   `RFETCH_DRIVE_*` or `RCLONE_DRIVE_*`.
  * @returns {Promise<Response>}
  */
 async function drive(request, env = {}) {
diff --git a/backend/http/main.js b/backend/http/main.js
index cbb0edb..531125d 100644
--- a/backend/http/main.js
+++ b/backend/http/main.js
@@ -78,7 +78,7 @@ class HTTPError extends Error {
  * Serves a HTTP remote. It is read only, as the http backend of rclone.
  * @param {Request} request
  * @param {Record<string, unknown>} [env] The options in the variables
- *   `RCLONE_HTTP_*`.
+ *   `RFETCH_HTTP_*` or `RCLONE_HTTP_*`.
  * @returns {Promise<Response>}
  */
 async function http(request, env = {}) {
diff --git a/backend/s3/main.js b/backend/s3/main.js
index 3296a24..8c02691 100644
--- a/backend/s3/main.js
+++ b/backend/s3/main.js
@@ -32,9 +32,10 @@
  *   no marker. A marker is an empty object with the name of the folder and
  *   a `/`, thus a folder can be empty.
  *
- * Each option can also come from `env`, with the name of the variable of
- * rclone, for example `RCLONE_S3_SECRET_ACCESS_KEY`. In a Worker, put the
- * credentials in `env`, not in a URL.
+ * Each option can also come from a header or from `env`, with the name of
+ * the variable of rfetch, for example `RFETCH_S3_SECRET_ACCESS_KEY`, or of
+ * rclone, `RCLONE_S3_SECRET_ACCESS_KEY`. Put the credentials in a header or
+ * in `env`, not in a URL.
  */
 import { createHash } from "node:crypto";
 import { renderListing } from "@rfetch/lib/listing";
@@ -111,7 +112,7 @@ class S3Error extends Error {
  * Serves an S3 remote.
  * @param {Request} request
  * @param {Record<string, unknown>} [env] The options from the variables
- *   `RCLONE_S3_*`.
+ *   `RFETCH_S3_*` or `RCLONE_S3_*`.
  * @returns {Promise<Response>}
  */
 async function s3(request, env = {}) {
diff --git a/backend/s3/main_test.js b/backend/s3/main_test.js
index aad7974..0938389 100644
--- a/backend/s3/main_test.js
+++ b/backend/s3/main_test.js
@@ -175,13 +175,17 @@ test("puts the markers of the parent folders, as rclone", async () => {
 });
 
 // A run on a real service, for example Cloudflare R2, when S3_TEST_ENDPOINT
-// and S3_TEST_BUCKET are set. The credentials are in RCLONE_S3_ACCESS_KEY_ID
-// and RCLONE_S3_SECRET_ACCESS_KEY, thus they are not in a URL.
+// and S3_TEST_BUCKET are set. The credentials are in RFETCH_S3_ACCESS_KEY_ID
+// and RFETCH_S3_SECRET_ACCESS_KEY, or in the variables of rclone with the
+// prefix RCLONE_, thus they are not in a URL.
 const { S3_TEST_ENDPOINT, S3_TEST_BUCKET, S3_TEST_REGION } = process.env;
 if (S3_TEST_ENDPOINT && S3_TEST_BUCKET) {
+  /** @param {string} name */
+  const variable = (name) =>
+    process.env[`RFETCH_S3_${name}`] ?? process.env[`RCLONE_S3_${name}`];
   const env = {
-    RCLONE_S3_ACCESS_KEY_ID: process.env.RCLONE_S3_ACCESS_KEY_ID,
-    RCLONE_S3_SECRET_ACCESS_KEY: process.env.RCLONE_S3_SECRET_ACCESS_KEY,
+    RFETCH_S3_ACCESS_KEY_ID: variable("ACCESS_KEY_ID"),
+    RFETCH_S3_SECRET_ACCESS_KEY: variable("SECRET_ACCESS_KEY"),
   };
   const params = {
     endpoint: S3_TEST_ENDPOINT,
diff --git a/lib/options.js b/lib/options.js
index d683039..050db23 100644
--- a/lib/options.js
+++ b/lib/options.js
@@ -2,19 +2,21 @@
  * The options of a backend, from the three places of rclone: a flag, a
  * variable of the request, and a variable of the environment.
  *
- * A variable has the name of the variable of rclone, for example
- * `RCLONE_S3_ACCESS_KEY_ID` for the option `access_key_id` of s3. In a
- * request, it is a header. The names of headers are not case sensitive.
+ * A variable has the name of the option with the prefix `RFETCH_` and the
+ * type of the backend, for example `RFETCH_S3_ACCESS_KEY_ID` for the option
+ * `access_key_id` of s3. The prefix `RCLONE_` of rclone also works, for
+ * compatibility: `RFETCH_` takes its place when both are set. In a request,
+ * a variable is a header. The names of headers are not case sensitive.
  */
 
-/** The start of the name of a header that is an option of rclone. */
-const PREFIX = "rclone_";
+/** The prefixes of the options, the primary one first. */
+export const PREFIXES = ["rfetch_", "rclone_"];
 
 /**
  * Gives the options of a backend for a request: a field of the query
- * first, then the header `RCLONE_TYPE_NAME`, then the variable
- * `RCLONE_TYPE_NAME` of `env`, as a flag of rclone takes the place of a
- * variable.
+ * first, then the header `RFETCH_TYPE_NAME` or `RCLONE_TYPE_NAME`, then the
+ * variable `RFETCH_TYPE_NAME` or `RCLONE_TYPE_NAME` of `env`, as a flag of
+ * rclone takes the place of a variable.
  *
  * Use the options to read an option, and the query of the request to make
  * the links of a list: thus an option of a header or of `env` is never in a
@@ -26,34 +28,43 @@ const PREFIX = "rclone_";
  */
 export function optionsOf(request, type, env = {}) {
   const options = new URL(request.url).searchParams;
-  const prefix = `${PREFIX}${type.toLowerCase()}_`;
-  for (const [name, value] of request.headers) {
-    if (!name.startsWith(prefix)) continue;
-    const key = name.slice(prefix.length);
+  /** @param {string} key @param {string} value */
+  const add = (key, value) => {
     if (!options.has(key)) options.set(key, value);
+  };
+  for (
+    const prefix of PREFIXES.map((start) => `${start}${type.toLowerCase()}_`)
+  ) {
+    for (const [name, value] of request.headers) {
+      if (name.startsWith(prefix)) add(name.slice(prefix.length), value);
+    }
   }
-  const variable = prefix.toUpperCase();
-  for (const [name, value] of Object.entries(env)) {
-    if (!name.startsWith(variable) || typeof value !== "string") continue;
-    const key = name.slice(variable.length).toLowerCase();
-    if (!options.has(key)) options.set(key, value);
+  for (
+    const prefix of PREFIXES.map((start) => `${start}${type}_`.toUpperCase())
+  ) {
+    for (const [name, value] of Object.entries(env)) {
+      if (name.startsWith(prefix) && typeof value === "string") {
+        add(name.slice(prefix.length).toLowerCase(), value);
+      }
+    }
   }
   return options;
 }
 
 /**
- * Tells if a header is an option of rclone.
+ * Tells if a header is an option of rfetch or of rclone.
  * @param {string} name
  */
 export function isOption(name) {
-  return name.toLowerCase().startsWith(PREFIX);
+  const lower = name.toLowerCase();
+  return PREFIXES.some((prefix) => lower.startsWith(prefix));
 }
 
 /**
  * Gives the headers of a request of a backend to the remote under it.
  *
  * The other options of the request go to the remote, for example the
- * remotes of `RCLONE_CONFIG_NAME_KEY`. The options of the backend itself do
+ * remotes of `RFETCH_CONFIG_NAME_KEY`. The options of the backend itself do
  * not go: they are not for the remote. When the remote is a URL, no option
  * goes: a secret must not go out to a server.
  * @param {HeadersInit} headers The headers of the request of the backend.
@@ -63,10 +74,13 @@ export function isOption(name) {
  */
 export function remoteHeaders(headers, type, remote) {
   const result = new Headers(headers);
-  const own = `${PREFIX}${type.toLowerCase()}_`;
+  const own = PREFIXES.map((prefix) => `${prefix}${type.toLowerCase()}_`);
   const url = /^[a-z][a-z0-9+.-]*:\/\//i.test(remote);
   for (const name of [...result.keys()]) {
-    if (url ? isOption(name) : name.startsWith(own)) result.delete(name);
+    const remove = url
+      ? isOption(name)
+      : own.some((prefix) => name.startsWith(prefix));
+    if (remove) result.delete(name);
   }
   return result;
 }
diff --git a/lib/options_test.js b/lib/options_test.js
index 8c879c6..1fa022c 100644
--- a/lib/options_test.js
+++ b/lib/options_test.js
@@ -27,6 +27,25 @@ test("optionsOf takes the query, then the headers, then env", () => {
   assert.equal(options.get("number"), null);
 });
 
+test("optionsOf takes RFETCH_ in the place of RCLONE_", () => {
+  const request = new Request("https://rfetch.test/", {
+    headers: {
+      RCLONE_S3_REGION: "rclone-header",
+      RFETCH_S3_REGION: "rfetch-header",
+      RCLONE_S3_ENDPOINT: "rclone-header",
+    },
+  });
+  const options = optionsOf(request, "s3", {
+    RCLONE_S3_ENDPOINT: "rclone-env",
+    RCLONE_S3_PROVIDER: "rclone-env",
+    RFETCH_S3_PROVIDER: "rfetch-env",
+  });
+  assert.equal(options.get("region"), "rfetch-header");
+  // A header takes the place of a variable of env, of each prefix.
+  assert.equal(options.get("endpoint"), "rclone-header");
+  assert.equal(options.get("provider"), "rfetch-env");
+});
+
 test("optionsOf reads the names of headers in each case", () => {
   for (
     const name of ["RCLONE_S3_REGION", "rclone_s3_region", "Rclone_S3_Region"]
@@ -58,7 +77,8 @@ test("optionsOf does not change the query of the request", () => {
   assert.equal(new URL(request.url).search, "?a=1");
 });
 
-test("isOption tells the headers of rclone", () => {
+test("isOption tells the headers of rfetch and of rclone", () => {
+  assert.ok(isOption("RFETCH_CONFIG_R2_TYPE"));
   assert.ok(isOption("RCLONE_CONFIG_R2_TYPE"));
   assert.ok(isOption("rclone_s3_access_key_id"));
   assert.ok(!isOption("Range"));
@@ -70,8 +90,9 @@ test("remoteHeaders keeps the other options for a remote of rfetch", () => {
     {
       Range: "bytes=0-1",
       RCLONE_CRYPT_PASSWORD: "secret",
+      RFETCH_CRYPT_PASSWORD2: "secret",
       RCLONE_CONFIG_R2_TYPE: "s3",
-      RCLONE_S3_REGION: "auto",
+      RFETCH_S3_REGION: "auto",
     },
     "crypt",
     "r2:bucket",
@@ -79,7 +100,7 @@ test("remoteHeaders keeps the other options for a remote of rfetch", () => {
   assert.deepEqual([...headers].sort(), [
     ["range", "bytes=0-1"],
     ["rclone_config_r2_type", "s3"],
-    ["rclone_s3_region", "auto"],
+    ["rfetch_s3_region", "auto"],
   ]);
 });
 
@@ -95,7 +116,9 @@ test("remoteHeaders gives no option to a URL", () => {
       {
         Range: "bytes=0-1",
         RCLONE_CRYPT_PASSWORD: "secret",
+        RFETCH_CRYPT_PASSWORD: "secret",
         RCLONE_CONFIG_R2_SECRET_ACCESS_KEY: "secret",
+        RFETCH_CONFIG_R2_SECRET_ACCESS_KEY: "secret",
       },
       "crypt",
       remote,
diff --git a/lib/testing/suite.js b/lib/testing/suite.js
index d71e1b4..374dc1f 100644
--- a/lib/testing/suite.js
+++ b/lib/testing/suite.js
@@ -68,7 +68,8 @@ const FILE2 = `hello? sausage/êé/Hello, 世界/ " ' @ < > & ? + ≠/z.txt`;
  *   for example s3 with no folder markers. Then a folder with no file
  *   gives 404, as a folder that does not exist. `type` is the type of the
  *   backend in rclone, for example `s3`: with it, the tests also give the
- *   `params` in the headers `RCLONE_TYPE_NAME` and in `env`.
+ *   `params` in the headers `RFETCH_TYPE_NAME` and in the variables
+ *   `RCLONE_TYPE_NAME` of `env`.
  */
 export function backendSuite(
   name,
@@ -326,10 +327,26 @@ export function backendSuite(
       /** @type {Record<string, string>} */
       const variables = {};
       for (const [key, value] of Object.entries(params)) {
-        variables[`RCLONE_${type.toUpperCase()}_${key.toUpperCase()}`] = value;
+        variables[`${type.toUpperCase()}_${key.toUpperCase()}`] = value;
       }
-      const byHeaders = remote(backend, { root, env, headers: variables });
-      const byEnv = remote(backend, { root, env: { ...env, ...variables } });
+      /** @param {string} prefix */
+      const named = (prefix) =>
+        Object.fromEntries(
+          Object.entries(variables).map((
+            [key, value],
+          ) => [prefix + key, value]),
+        );
+      // The prefix of rfetch in the headers, and the prefix of rclone in
+      // env: both work.
+      const byHeaders = remote(backend, {
+        root,
+        env,
+        headers: named("RFETCH_"),
+      });
+      const byEnv = remote(backend, {
+        root,
+        env: { ...env, ...named("RCLONE_") },
+      });
       const content = random(100);
       if (writer) {
         await expect(fs.put("options.txt", content), 201);
diff --git a/main_test.js b/main_test.js
index 901a6f4..6b248dd 100644
--- a/main_test.js
+++ b/main_test.js
@@ -12,7 +12,7 @@ import { config, fetch } from "./mod.js";
  * `TRACE`: the options of the config file and of the variables are not in
  * the query, thus they are never in a link.
  * @param {string} body
- * @param {string} name For example `RCLONE_ALIAS_REMOTE`.
+ * @param {string} name For example `RFETCH_ALIAS_REMOTE`.
  */
 function variableOf(body, name) {
   const line = body.split("\r").find((line) => line.startsWith(`${name}: `));
@@ -115,7 +115,7 @@ test("fetch", async (t) => {
 
         assert.deepEqual(pathname, "/");
         assert(!searchParams.has("remote"), "the config is not in the query");
-        assert.deepEqual(variableOf(body, "RCLONE_ALIAS_REMOTE"), `source:`);
+        assert.deepEqual(variableOf(body, "RFETCH_ALIAS_REMOTE"), `source:`);
       });
 
       await t.test(
@@ -131,8 +131,8 @@ test("fetch", async (t) => {
           const { searchParams } = new URL(url, "file:");
 
           assert(!searchParams.has("skip_links"), "not in the query");
-          assert.deepEqual(variableOf(body, "RCLONE_ALIAS_REMOTE"), `source:`);
-          assert.deepEqual(variableOf(body, "RCLONE_ALIAS_SKIP_LINKS"), `true`);
+          assert.deepEqual(variableOf(body, "RFETCH_ALIAS_REMOTE"), `source:`);
+          assert.deepEqual(variableOf(body, "RFETCH_ALIAS_SKIP_LINKS"), `true`);
         },
       );
 
@@ -149,7 +149,7 @@ test("fetch", async (t) => {
           const { searchParams } = new URL(url, "file:");
 
           assert(!searchParams.has("remote"), "not in the query");
-          assert.deepEqual(variableOf(body, "RCLONE_ALIAS_REMOTE"), `/tmp/1`);
+          assert.deepEqual(variableOf(body, "RFETCH_ALIAS_REMOTE"), `/tmp/1`);
           assert(
             !searchParams.has("alias_remote"),
             "should not have param prefixed with backend type",
@@ -170,7 +170,7 @@ test("fetch", async (t) => {
           const { searchParams } = new URL(url, "file:");
 
           assert(!searchParams.has("remote"), "not in the query");
-          assert.deepEqual(variableOf(body, "RCLONE_ALIAS_REMOTE"), `/tmp/2`);
+          assert.deepEqual(variableOf(body, "RFETCH_ALIAS_REMOTE"), `/tmp/2`);
           assert(
             !searchParams.has("config_target_remote"),
             "should not have param prefixed with remote name",
@@ -275,13 +275,43 @@ test("options in the headers of a request", async (t) => {
         headers: { RCLONE_CONFIG_PLACE_REMOTE: "/tmp/header" },
       });
       const body = await response.text();
-      assert.equal(variableOf(body, "RCLONE_ALIAS_REMOTE"), "/tmp/header");
+      assert.equal(variableOf(body, "RFETCH_ALIAS_REMOTE"), "/tmp/header");
     } finally {
       delete process.env.RCLONE_CONFIG_PLACE_TYPE;
       delete process.env.RCLONE_CONFIG_PLACE_REMOTE;
     }
   });
 
+  await t.test("RFETCH_ takes the place of RCLONE_", async () => {
+    process.env.RCLONE_CONFIG_BOTH_TYPE = "alias";
+    process.env.RCLONE_CONFIG_BOTH_REMOTE = "/tmp/rclone-env";
+    process.env.RFETCH_CONFIG_BOTH_REMOTE = "/tmp/rfetch-env";
+    try {
+      /** @param {HeadersInit} headers */
+      const remoteOf = async (headers) => {
+        const response = await fetch("both:", { method: "TRACE", headers });
+        return variableOf(await response.text(), "RFETCH_ALIAS_REMOTE");
+      };
+      assert.equal(await remoteOf({}), "/tmp/rfetch-env");
+      // A header takes the place of a variable of the process.
+      assert.equal(
+        await remoteOf({ RCLONE_CONFIG_BOTH_REMOTE: "/tmp/rclone-header" }),
+        "/tmp/rclone-header",
+      );
+      assert.equal(
+        await remoteOf({
+          RCLONE_CONFIG_BOTH_REMOTE: "/tmp/rclone-header",
+          RFETCH_CONFIG_BOTH_REMOTE: "/tmp/rfetch-header",
+        }),
+        "/tmp/rfetch-header",
+      );
+    } finally {
+      delete process.env.RCLONE_CONFIG_BOTH_TYPE;
+      delete process.env.RCLONE_CONFIG_BOTH_REMOTE;
+      delete process.env.RFETCH_CONFIG_BOTH_REMOTE;
+    }
+  });
+
   await t.test("the variables of other remotes are not options", async () => {
     process.env.RCLONE_CONFIG_OTHER_SECRET_ACCESS_KEY = "other-secret";
     try {
@@ -320,6 +350,8 @@ test("options in the headers of a request", async (t) => {
       const headers = {
         RCLONE_S3_SECRET_ACCESS_KEY: "secret",
         RCLONE_CONFIG_R2_TYPE: "s3",
+        RFETCH_S3_SECRET_ACCESS_KEY: "secret",
+        RFETCH_CONFIG_R2_TYPE: "s3",
         "X-Other": "other",
       };
       await (await fetch(`${server.url}`, { headers })).text();
@@ -329,7 +361,7 @@ test("options in the headers of a request", async (t) => {
       for (const headers of seen) {
         assert.equal(headers.get("x-other"), "other");
         assert.deepEqual(
-          [...headers.keys()].filter((name) => name.startsWith("rclone_")),
+          [...headers.keys()].filter((name) => /^r(clone|fetch)_/.test(name)),
           [],
         );
       }
diff --git a/mod.js b/mod.js
index 4817c60..dee86c5 100644
--- a/mod.js
+++ b/mod.js
@@ -2,7 +2,7 @@ import { env } from "node:process";
 import { backends, load } from "./backend/main.js";
 import * as commands from "./cmd/main.js";
 import { parse } from "@rfetch/lib/fspath";
-import { isOption } from "@rfetch/lib/options";
+import { isOption, PREFIXES } from "@rfetch/lib/options";
 
 export * from "./cmd/main.js";
 
@@ -83,35 +83,40 @@ const globalFetch = globalThis.fetch;
  *
  * - Parameters in connection strings, e.g. `myRemote,skip_links:`
  * - Flag values as supplied on the command line, e.g. `--skip-links`
- * - Remote specific environment vars, e.g. `RCLONE_CONFIG_MYREMOTE_SKIP_LINKS`
- * - Backend-specific environment vars, e.g. `RCLONE_LOCAL_SKIP_LINKS`
- * - Backend generic environment vars, e.g. `RCLONE_SKIP_LINKS`
+ * - Remote specific environment vars, e.g. `RFETCH_CONFIG_MYREMOTE_SKIP_LINKS`
+ * - Backend-specific environment vars, e.g. `RFETCH_LOCAL_SKIP_LINKS`
+ * - Backend generic environment vars, e.g. `RFETCH_SKIP_LINKS`
  * - Config file, e.g. `skip_links = true`.
  * - Default values, e.g. `false` - these can't be changed.
  *
  * So if both `--skip-links` is supplied on the command line and an environment
- * variable `RCLONE_LOCAL_SKIP_LINKS` is set, the command line flag will take
+ * variable `RFETCH_LOCAL_SKIP_LINKS` is set, the command line flag will take
  * preference.
  *
+ * Each variable can also have the prefix `RCLONE_` of rclone, for
+ * compatibility, for example `RCLONE_LOCAL_SKIP_LINKS`. In each place,
+ * `RFETCH_` takes the place of `RCLONE_`.
+ *
  * A header of the request with the name of a variable, for example
- * `RCLONE_CONFIG_MYREMOTE_SKIP_LINKS`, takes the place of the variable of the
+ * `RFETCH_CONFIG_MYREMOTE_SKIP_LINKS`, takes the place of the variable of the
  * environment. A remote can come only from variables, as in rclone:
- * `RCLONE_CONFIG_MYREMOTE_TYPE` and its options. Thus a request can give
+ * `RFETCH_CONFIG_MYREMOTE_TYPE` and its options. Thus a request can give
  * all its configuration, with no config file.
  *
  * The backend gets the options of the path, the connection string and the
  * flags, in the query of its request. It gets the other options in `env`,
  * the second argument of its `fetch`, with the names of the variables of
- * rclone, for example `RCLONE_LOCAL_SKIP_LINKS`. A backend makes the links of
+ * rfetch, for example `RFETCH_LOCAL_SKIP_LINKS`. A backend makes the links of
  * a list from the query only, thus an option of `env` is never in a link.
  *
- * The headers `RCLONE_*` are only for the backends of rfetch: they never go
+ * The headers `RFETCH_*` and `RCLONE_*` are only for the backends of rfetch:
+ * they never go
  * out to a URL.
  *
  * For non backend configuration the order is as follows:
  *
  * - Flag values as supplied on the command line, e.g. `--stats 5s`.
- * - Environment vars, e.g. `RCLONE_STATS=5s`.
+ * - Environment vars, e.g. `RFETCH_STATS=5s`.
  * - Default values, e.g. `1m` - these can't be changed.
  *
  * ## Other environment variables
@@ -133,12 +138,24 @@ export async function fetch(input, init = {}) {
   const parsed = parse(input);
 
   const headers = new Headers(init.headers);
-  // The variables of rclone: the environment of the process, then the
-  // headers of the request, which take their place.
+  // The variables, by their names with no prefix, for example
+  // `CONFIG_R2_TYPE`: the environment of the process, then the headers of
+  // the request, which take their place. In each place, `RFETCH_` takes the
+  // place of `RCLONE_`.
   /** @type {Record<string, string>} */
-  const variables = { ...env };
-  for (const [key, value] of headers) {
-    if (isOption(key)) variables[key.toUpperCase()] = value;
+  const variables = {};
+  const places = [
+    Object.entries(env),
+    [...headers].map(([key, value]) => [key.toUpperCase(), value]),
+  ];
+  for (const entries of places) {
+    for (const prefix of ["RCLONE_", "RFETCH_"]) {
+      for (const [key, value] of entries) {
+        if (key.startsWith(prefix) && typeof value === "string") {
+          variables[key.slice(prefix.length)] = value;
+        }
+      }
+    }
   }
 
   let { name } = parsed;
@@ -155,7 +172,7 @@ export async function fetch(input, init = {}) {
     name = "";
   } else {
     // A remote of the config file, or of the variables, as rclone.
-    const type = variables[`RCLONE_CONFIG_${name.toUpperCase()}_TYPE`];
+    const type = variables[`CONFIG_${name.toUpperCase()}_TYPE`];
     const response = await commands.config("show", name, undefined, {
       headers: { "Accept": "application/json" },
     }).catch(() => null);
@@ -176,28 +193,27 @@ export async function fetch(input, init = {}) {
   // config file, then the variables.
   const options = new Map(Object.entries(config));
 
-  // Backend generic variables, for example `RCLONE_SKIP_LINKS`. A variable
+  // Backend generic variables, for example `RFETCH_SKIP_LINKS`. A variable
   // of a remote or of a backend is not generic: it is not an option of each
   // backend.
   const specific = ["CONFIG", ...Object.keys(backends)]
-    .map((prefix) => `RCLONE_${prefix.toUpperCase()}_`);
+    .map((prefix) => `${prefix.toUpperCase()}_`);
   for (const [key, value] of Object.entries(variables)) {
-    if (!key.startsWith("RCLONE_")) continue;
     if (specific.some((prefix) => key.startsWith(prefix))) continue;
-    options.set(key.slice("RCLONE_".length).toLowerCase(), value);
+    options.set(key.toLowerCase(), value);
   }
 
-  // Backend-specific variables, for example `RCLONE_LOCAL_SKIP_LINKS`.
-  let prefix = `RCLONE_${type.toUpperCase()}_`;
+  // Backend-specific variables, for example `RFETCH_LOCAL_SKIP_LINKS`.
+  let prefix = `${type.toUpperCase()}_`;
   for (const [key, value] of Object.entries(variables)) {
     if (key.startsWith(prefix)) {
       options.set(key.slice(prefix.length).toLowerCase(), value);
     }
   }
 
-  // Remote specific variables, for example `RCLONE_CONFIG_MYREMOTE_SKIP_LINKS`.
+  // Remote specific variables, for example `RFETCH_CONFIG_MYREMOTE_SKIP_LINKS`.
   if (name) {
-    prefix = `RCLONE_CONFIG_${name.toUpperCase()}_`;
+    prefix = `CONFIG_${name.toUpperCase()}_`;
     for (const [key, value] of Object.entries(variables)) {
       if (key.startsWith(prefix) && key !== `${prefix}TYPE`) {
         options.set(key.slice(prefix.length).toLowerCase(), value);
@@ -225,12 +241,12 @@ export async function fetch(input, init = {}) {
   /** @type {Record<string, string>} */
   const optionsEnv = {};
   for (const [key, value] of options) {
-    optionsEnv[`RCLONE_${type.toUpperCase()}_${key.toUpperCase()}`] = value;
+    optionsEnv[`RFETCH_${type.toUpperCase()}_${key.toUpperCase()}`] = value;
   }
   // The headers of this backend are in its options now.
-  const own = `rclone_${type.toLowerCase()}_`;
+  const own = PREFIXES.map((start) => `${start}${type.toLowerCase()}_`);
   for (const key of [...headers.keys()]) {
-    if (key.startsWith(own)) headers.delete(key);
+    if (own.some((start) => key.startsWith(start))) headers.delete(key);
   }
 
   if (init.method === "TRACE") {

From 58d1d8ac1429fada2f1ea809421448720204a74b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sun, 18 Oct 2026 12:11:57 +0000
Subject: [PATCH 56/87] feat(lsjson): the init of the requests of a list

lsjson takes a third argument, the init of each request of the list and of the lists of the folders in it. Thus the headers of a request, with the options RFETCH_*, go to each list.
---
 cmd/lsjson/main.js | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/cmd/lsjson/main.js b/cmd/lsjson/main.js
index 94eb020..5de8b5e 100644
--- a/cmd/lsjson/main.js
+++ b/cmd/lsjson/main.js
@@ -53,16 +53,18 @@ const decoder = new TextDecoder();
  * @param {Object} [flags={}]
  * @param {number} [flags.max_depth=Infinity] - Maximum depth of recursion.
  * @param {boolean} [flags.recursive=false] - Recurse into the listing.
+ * @param {RequestInit} [init] The init of each request of the list, for
+ *   example the headers with the options `RFETCH_*`.
  * @returns {Promise<Response>}
  */
-export async function lsjson(location, flags = {}) {
+export async function lsjson(location, flags = {}, init = {}) {
   // Only the path in the remote has folders: a value of the connection
   // string can have a "/" too, for example `:crypt,remote='a/b':path`.
   const parsed = parse(location);
   const prefix = location.slice(0, location.length - parsed.path.length);
   const path = parsed.path;
   const isDirectory = path === "" || path.endsWith("/");
-  const init = { method: "GET" };
+  init = { ...init, method: "GET" };
   let folder = path;
   let filename;
   // If file, list the parent directory and keep only the file.
@@ -190,7 +192,7 @@ export async function lsjson(location, flags = {}) {
                 const response = await lsjson(child, {
                   ...flags,
                   max_depth: String(maxDepth - 1),
-                });
+                }, init);
 
                 await response.body?.pipeThrough(
                   new TransformStream({

From 2c375f9ae49970d97fb4355091d818211be2c3ae Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sun, 18 Oct 2026 12:11:57 +0000
Subject: [PATCH 57/87] feat(worker): each path through the rfetch fetch, and
 lists as JSON

The path of a request to the Worker is a remote and a path, as for the command: /:s3:bucket/a.txt, /r2:bucket/a.txt with the remote r2 in the headers RFETCH_CONFIG_R2_*, or a connection string with parameters. The fields of the query are parameters of the remote, thus the links of a list work in a browser. A GET with Accept: application/json gives the list of rfetch lsjson, with Depth: N for N levels and Depth: infinity for all. A path with no remote is a static file. A remote that is not correct gives 400, and a remote or a type that does not exist gives 404.
---
 README.md      |  20 +++++++
 _worker.js     | 153 ++++++++++++++++++++++++++++---------------------
 worker_test.js | 142 +++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 250 insertions(+), 65 deletions(-)
 create mode 100644 worker_test.js

diff --git a/README.md b/README.md
index 928ba6a..04cf9c2 100644
--- a/README.md
+++ b/README.md
@@ -23,6 +23,26 @@ These backends adapt or modify other storage providers
 - Chunker [:page_facing_up:](https://rclone.org/chunker/)
 - Crypt: encrypt files [:page_facing_up:](https://rclone.org/crypt/)
 
+## rfetch as a service
+
+`_worker.js` serves rfetch as a Worker of Cloudflare, at `rfetch.pages.dev`. It
+is stateless: it keeps no configuration and no secret. The path of a request is
+a remote and a path, as for the command, and the options come in the headers
+`RFETCH_*`:
+
+```sh
+curl -H "RFETCH_CONFIG_R2_TYPE: s3" \
+  -H "RFETCH_CONFIG_R2_ENDPOINT: https://ACCOUNT_ID.r2.cloudflarestorage.com" \
+  -H "RFETCH_CONFIG_R2_ACCESS_KEY_ID: …" \
+  -H "RFETCH_CONFIG_R2_SECRET_ACCESS_KEY: …" \
+  -H "Accept: application/json" \
+  https://rfetch.pages.dev/r2:bucket/folder/
+```
+
+With `Accept: application/json`, a `GET` gives the list of `rfetch lsjson`, and
+`Depth: N` lists N levels. Else a folder is an HTML page, and a file is its
+bytes, with ranges. The prefix `RCLONE_` of rclone also works.
+
 ## Commands
 
 - `backend`
diff --git a/_worker.js b/_worker.js
index bad9370..a998216 100644
--- a/_worker.js
+++ b/_worker.js
@@ -1,82 +1,105 @@
-import { load } from "./backend/main.js";
-// Sets the global `fetch` that reads the paths of remotes.
-import "./mod.js";
-
 /**
- * A handler
+ * rfetch as a service: a stateless Worker. It keeps no configuration and no
+ * secret: each request gives all that it needs.
  *
- * @callback Handler
- * @param {Request} request
- * @param {Object} env Environment variables.
- * @returns {Response|Promise<Response>}
- */
-
-/**
- * Serves a bare remote, i.e., `/:memory:/path/to/file`
+ * The path of a request is a remote and a path, as for the rfetch command,
+ * for example `/:s3:bucket/a.txt`, `/r2:bucket/a.txt` or
+ * `/:crypt,remote='r2:bucket':a.txt`. The options come in the headers
+ * `RFETCH_*`, or `RCLONE_*` for compatibility, for example
+ * `RFETCH_S3_ACCESS_KEY_ID` or the remote `RFETCH_CONFIG_R2_TYPE: s3`. The
+ * fields of the query are options of the remote too, as the parameters of a
+ * connection string. Do not put a secret in the query: a URL can stay in the
+ * history of a browser and in logs.
  *
- * All configuration must be passed as query parameters.
+ * A `GET` with `Accept: application/json` gives the list of `rfetch lsjson`.
+ * The header `Depth: N` lists N levels, and `Depth: infinity` all of them.
  *
- * @param {Request} request
- * @param {Object} env
- * @param {Object} params
- * @param {string} params.remote
- * @param {string} [params.path]
- * @returns {Promise<Response}
+ * A path with no remote is a static file of the site.
  */
-async function remote(request, env, params) {
-  let { remote, path = "/" } = params;
+// The import also sets the global `fetch`, which reads the paths of remotes.
+import { fetch, lsjson } from "./mod.js";
+import { parse } from "@rfetch/lib/fspath";
 
-  const backend = await load(remote);
-  if (!backend) {
-    return new Response("Remote not found.", { status: 404 });
+/**
+ * Gives the location of a request for the rfetch fetch: the remote of the
+ * path with no percent-encoding, the fields of the query as parameters of
+ * the remote, and the path with its percent-encoding.
+ * @param {URL} url
+ * @returns {string | null} `null` for a path with no remote.
+ * @throws {SyntaxError} When the remote is not correct.
+ */
+function locationOf(url) {
+  const raw = url.pathname.slice(1);
+  if (raw === "") return null;
+  const { name, path } = parse(raw);
+  if (name === "") return null;
+  let remote;
+  try {
+    remote = decodeURIComponent(raw.slice(0, raw.length - path.length));
+  } catch {
+    throw new SyntaxError(
+      "The remote has a percent-encoding that is not correct",
+    );
   }
-
-  if (!path) {
-    path = "/";
+  let params = "";
+  for (const [key, value] of url.searchParams) {
+    params += `,${key}='${value.replaceAll("'", "''")}'`;
   }
-
-  const url = new URL(request.url);
-  url.pathname = path;
-
-  request = new Request(url, request);
-
-  return backend.fetch(request, env);
+  // The remote ends with ":": the parameters go before it.
+  return `${params ? remote.slice(0, -1) + params + ":" : remote}${path}`;
 }
 
-const routes = {
-  "/\\::remote\\:/": remote,
-  "/\\::remote\\:/:path*": remote,
-  "/\\::remote\\:/:path*/": (request, env, params) => {
-    params.path += "/";
-    return remote(request, env, params);
-  },
-};
-
 /**
- * Routes request to the appropriate handler.
- * @param {Object} routes
- * @returns {Handler}
+ * Gives the flags of `lsjson` for the header `Depth`.
+ * @param {string | null} depth
+ * @returns {Record<string, string> | null} `null` for a value that is not
+ *   correct.
  */
-function router(routes = {}) {
-  return function (request, env) {
-    const url = new URL(request.url);
-
-    for (const [route, handler] of Object.entries(routes)) {
-      const [pathname, method] = route.split("@").reverse();
+function flagsOf(depth) {
+  if (depth === null) return {};
+  if (depth === "infinity") return { recursive: "true" };
+  if (!/^[1-9]\d{0,3}$/.test(depth)) return null;
+  return { recursive: "true", max_depth: depth };
+}
 
-      if (method && request.method !== method) continue;
+export default {
+  /**
+   * @param {Request} request
+   * @param {{ ASSETS: { fetch: typeof fetch } }} env
+   */
+  async fetch(request, env) {
+    const url = new URL(request.url);
+    try {
+      const location = locationOf(url);
+      if (location === null) return env.ASSETS.fetch(request);
 
-      const pattern = new URLPattern({ pathname });
-      if (!pattern.test(url)) continue;
+      const { method, headers } = request;
+      const accept = headers.get("Accept") ?? "";
+      if (method === "GET" && /\bapplication\/json\b/.test(accept)) {
+        const flags = flagsOf(headers.get("Depth"));
+        if (flags === null) {
+          return new Response("Depth is a number from 1 to 9999, or infinity", {
+            status: 400,
+          });
+        }
+        return await lsjson(location, flags, { headers });
+      }
 
-      const params = pattern.exec(url)?.pathname?.groups || {};
-      return handler(request, env, params);
+      /** @type {RequestInit} */
+      const init = { method, headers };
+      if (request.body) {
+        init.body = request.body;
+        init.duplex = "half";
+      }
+      return await fetch(location, init);
+    } catch (error) {
+      if (error instanceof SyntaxError) {
+        return new Response(error.message, { status: 400 });
+      }
+      if (/ not found/.test(error.message)) {
+        return new Response(error.message, { status: 404 });
+      }
+      throw error;
     }
-
-    return env.ASSETS.fetch(request);
-  };
-}
-
-export default {
-  fetch: router(routes),
+  },
 };
diff --git a/worker_test.js b/worker_test.js
new file mode 100644
index 0000000..d1caa8f
--- /dev/null
+++ b/worker_test.js
@@ -0,0 +1,142 @@
+/**
+ * The tests of `_worker.js`: rfetch as a service, with no configuration in
+ * the Worker.
+ */
+import { test } from "node:test";
+import assert from "node:assert/strict";
+
+import worker from "./_worker.js";
+
+const PASSWORD = "4OSlj-ZYMGdEIGjcWg_gc-DL4O3TFAvr4ct_yV4";
+
+/** The static files of the site: a stub that tells the path. */
+const env = {
+  ASSETS: {
+    /** @param {Request} request */
+    fetch: (request) =>
+      new Response(`asset ${new URL(request.url).pathname}`, { status: 200 }),
+  },
+};
+
+/**
+ * Sends a request to the Worker.
+ * @param {string} path The path and the query, with percent-encoding.
+ * @param {RequestInit} [init]
+ */
+function send(path, init = {}) {
+  return worker.fetch(
+    new Request(`https://rfetch.test${path}`, { duplex: "half", ...init }),
+    env,
+  );
+}
+
+test("puts and gets a file of a remote on the fly", async () => {
+  const put = await send("/:memory:/worker/a%3F.txt", {
+    method: "PUT",
+    body: "text",
+  });
+  assert.equal(put.status, 201);
+  assert.equal(await (await send("/:memory:/worker/a%3F.txt")).text(), "text");
+  assert.equal((await send("/:memory:/worker/missing.txt")).status, 404);
+});
+
+test("reads a named remote of the headers", async () => {
+  const headers = { RFETCH_CONFIG_MEM_TYPE: "memory" };
+  await send("/mem:worker/b.txt", { method: "PUT", body: "b", headers });
+  const response = await send("/mem:worker/b.txt", { headers });
+  assert.equal(await response.text(), "b");
+  // With no headers, the remote does not exist.
+  assert.equal((await send("/mem:worker/b.txt")).status, 404);
+});
+
+test("the fields of the query are options of the remote", async () => {
+  await send("/:memory:/it's/c.txt", { method: "PUT", body: "c" });
+  const list = await send(
+    `/:alias:/?remote=${encodeURIComponent(":memory:/it's")}`,
+  );
+  assert.equal(list.status, 200);
+  const html = await list.text();
+  // A link of the list works as it is.
+  const href = html.match(/href="(c\.txt[^"]*)"/)?.[1]?.replaceAll(
+    "&amp;",
+    "&",
+  );
+  assert.ok(href, html);
+  const file = await send(`/:alias:/${href}`);
+  assert.equal(await file.text(), "c");
+});
+
+test("gives the list of lsjson for Accept: application/json", async () => {
+  await send("/:memory:/json/a.txt", { method: "PUT", body: "a" });
+  await send("/:memory:/json/sub/b.txt", { method: "PUT", body: "bb" });
+  const headers = { Accept: "application/json" };
+
+  const one = await send("/:memory:/json/", { headers });
+  assert.equal(one.headers.get("Content-Type"), "application/json");
+  assert.deepEqual(
+    (await one.json()).map(({ Path, IsDir }) => ({ Path, IsDir })),
+    [{ Path: "a.txt", IsDir: false }, { Path: "sub", IsDir: true }],
+  );
+
+  const all = await send("/:memory:/json/", {
+    headers: { ...headers, Depth: "infinity" },
+  });
+  assert.deepEqual(
+    (await all.json()).map(({ Path, Size }) => ({ Path, Size })).sort((a, b) =>
+      a.Path < b.Path ? -1 : 1
+    ),
+    [
+      { Path: "a.txt", Size: 1 },
+      { Path: "sub", Size: -1 },
+      { Path: "sub/b.txt", Size: 2 },
+    ],
+  );
+
+  const two = await send("/:memory:/json/", {
+    headers: { ...headers, Depth: "1" },
+  });
+  assert.equal((await two.json()).length, 2);
+
+  for (const depth of ["0", "-1", "a", "99999"]) {
+    const bad = await send("/:memory:/json/", {
+      headers: { ...headers, Depth: depth },
+    });
+    assert.equal(bad.status, 400, depth);
+  }
+});
+
+test("lists crypt on a named remote, all from the headers", async () => {
+  const headers = {
+    RFETCH_CRYPT_REMOTE: "vault:crypt-worker",
+    RFETCH_CRYPT_PASSWORD: PASSWORD,
+    RFETCH_CONFIG_VAULT_TYPE: "memory",
+  };
+  const put = await send("/:crypt:/x%20y.txt", {
+    method: "PUT",
+    body: "secret",
+    headers,
+  });
+  assert.equal(put.status, 201);
+  const list = await send("/:crypt:/", {
+    headers: { ...headers, Accept: "application/json" },
+  });
+  const entries = await list.json();
+  assert.deepEqual(entries.map(({ Name, Size }) => ({ Name, Size })), [
+    { Name: "x y.txt", Size: 6 },
+  ]);
+  const html = await (await send("/:crypt:/", { headers })).text();
+  assert.doesNotMatch(html, new RegExp(PASSWORD));
+  assert.doesNotMatch(html, /href="[^"]*\?/, "a link has options");
+});
+
+test("gives a path with no remote to the static files", async () => {
+  assert.equal(await (await send("/")).text(), "asset /");
+  assert.equal(await (await send("/README.md")).text(), "asset /README.md");
+});
+
+test("gives 400 or 404 for a remote that is not correct", async () => {
+  assert.equal((await send("/:no-such-type:/a")).status, 404);
+  assert.equal((await send("/nobody:a")).status, 404);
+  assert.equal((await send("/:memory:/a?bad%20key=1")).status, 400);
+  assert.equal((await send("/:memory%:/a")).status, 400);
+});

From 359cf820caa3e0ad5da26e77e86729531999bce1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sun, 18 Oct 2026 12:43:56 +0000
Subject: [PATCH 58/87] test(bench): cases of a benchmark in Node.js and in
 workerd

The cases in bench/cases.js measure the time of the backends memory,
crypt, chunker and s3, of renderListing and readListing, and of the
fetch of rfetch. They use only Web APIs, thus they run in Node.js
(bench/node.js) and in a Worker (bench/worker.js, with wrangler dev).

bench/node.js runs each case in a new process: in one process, the time
of a case changes much with the cases before it. CONTRIBUTING.md tells
how to run the two benchmarks.
---
 CONTRIBUTING.md     |  18 +++++
 README.md           |   2 +
 bench/cases.js      | 169 ++++++++++++++++++++++++++++++++++++++++++++
 bench/node.js       |  28 ++++++++
 bench/worker.js     |  25 +++++++
 bench/wrangler.json |   6 ++
 6 files changed, 248 insertions(+)
 create mode 100644 bench/cases.js
 create mode 100644 bench/node.js
 create mode 100644 bench/worker.js
 create mode 100644 bench/wrangler.json

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 746654b..7ad9bee 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -270,6 +270,24 @@ default). Put the credentials in `RFETCH_S3_ACCESS_KEY_ID` and
 `RCLONE_`. Use a bucket only for the tests: the tests make folders in it and
 delete them.
 
+## Benchmarks
+
+The cases of `bench/cases.js` measure the time of the backends, of the code in
+`lib` and of the `fetch` of rfetch. The cases use only Web APIs, thus they run
+in Node.js and in workerd, the runtime of Cloudflare Workers:
+
+- `node bench/node.js` runs each case in a new process, as a command of rfetch
+  does. The time of a case can change much with the work before it in the same
+  process. `node bench/node.js NAME` runs only the case NAME.
+- `npx wrangler dev -c bench/wrangler.json`, then `curl http://localhost:8787/`,
+  runs all the cases in one request of a Worker. The clock of `wrangler dev`
+  moves during the work of a request, thus the times are times of the CPU. The
+  times of workerd change much from one run to the next: run it three times, and
+  use the median.
+
+Measure before and after a change for speed, and write the two times in the
+message of the commit.
+
 ## Continuous integration
 
 The workflow `.github/workflows/ci.yml` runs for each push and each pull
diff --git a/README.md b/README.md
index 04cf9c2..39c499b 100644
--- a/README.md
+++ b/README.md
@@ -70,3 +70,5 @@ bytes, with ranges. The prefix `RCLONE_` of rclone also works.
 - `npm test` to run the tests, with the test runner of Node.js.
 - `npm run bench` to compare some commands with `rclone`, which must be in the
   PATH.
+- `node bench/node.js` to measure the time of the backends. See
+  [CONTRIBUTING.md](CONTRIBUTING.md#benchmarks) for the benchmark in a Worker.
diff --git a/bench/cases.js b/bench/cases.js
new file mode 100644
index 0000000..d5a840a
--- /dev/null
+++ b/bench/cases.js
@@ -0,0 +1,169 @@
+/**
+ * The cases of the benchmark of rfetch. They use no API of Node.js only,
+ * thus they run in Node.js (`bench/node.js`) and in a Worker
+ * (`bench/worker.js`).
+ */
+// The import also sets the global `fetch`, which reads the paths of remotes.
+import { fetch, lsjson } from "../mod.js";
+import { readListing, renderListing } from "@rfetch/lib/listing";
+import memory from "@rfetch/memory";
+import { childrenOf, parseXML, textOf } from "../backend/s3/xml.js";
+import { sign, UNSIGNED_PAYLOAD } from "../backend/s3/sigv4.js";
+
+/** The size of a large file. */
+export const SIZE = 8 * 1024 * 1024;
+/** The number of files in a list. */
+const FILES = 1000;
+
+/** "test-password", obscured by rclone. */
+const PASSWORD = "4OSlj-ZYMGdEIGjcWg_gc-DL4O3TFAvr4ct_yV4";
+const CRYPT = {
+  RFETCH_CRYPT_REMOTE: ":memory:/bench-crypt",
+  RFETCH_CRYPT_PASSWORD: PASSWORD,
+};
+const CRYPT_LIST = {
+  ...CRYPT,
+  RFETCH_CRYPT_REMOTE: ":memory:/bench-crypt-list",
+};
+const CHUNKER = {
+  RFETCH_CHUNKER_REMOTE: ":memory:/bench-chunker",
+  RFETCH_CHUNKER_CHUNK_SIZE: "1M",
+};
+
+/** Bytes that do not compress, with no cost of a random source. */
+function data(size) {
+  const bytes = new Uint8Array(size);
+  let x = 0x9e3779b9;
+  for (let i = 0; i < size; i++) {
+    x ^= x << 13;
+    x ^= x >>> 17;
+    x ^= x << 5;
+    bytes[i] = x;
+  }
+  return bytes;
+}
+
+// The data of the cases. `setup` makes them: a Worker cannot do such work
+// at the start of the module.
+let big = new Uint8Array(0);
+let small = new Uint8Array(0);
+let html = "";
+let xml = "";
+
+/** @param {Response} response */
+async function drain(response) {
+  if (!response.ok) {
+    throw new Error(`${response.status} ${await response.text()}`);
+  }
+  await response.arrayBuffer();
+}
+
+/** @param {string} location @param {Uint8Array} body @param {HeadersInit} [headers] */
+async function put(location, body, headers = {}) {
+  await drain(await fetch(location, { method: "PUT", body, headers }));
+}
+
+/** @param {string} location @param {HeadersInit} [headers] */
+async function get(location, headers = {}) {
+  await drain(await fetch(location, { headers }));
+}
+
+/** The entries of a list of `count` files. */
+function entries(count) {
+  return Array.from({ length: count }, (_, i) => ({
+    Name: `file ${i} é.txt`,
+    IsDir: false,
+    Size: i * 100,
+    MimeType: "text/plain; charset=utf-8",
+    ModTime: new Date(1700000000000 + i * 1000).toISOString(),
+  }));
+}
+
+/** The answer of ListObjectsV2 of S3 for `count` keys. */
+function listXML(count) {
+  const contents = Array.from(
+    { length: count },
+    (_, i) =>
+      `<Contents><Key>folder/file%20${i}.txt</Key>` +
+      `<LastModified>2026-10-18T12:00:00.000Z</LastModified>` +
+      `<ETag>&quot;0123456789abcdef&quot;</ETag><Size>${i}</Size>` +
+      `<StorageClass>STANDARD</StorageClass></Contents>`,
+  ).join("");
+  return `<?xml version="1.0" encoding="UTF-8"?><ListBucketResult>` +
+    `<Name>bucket</Name><Prefix>folder/</Prefix><KeyCount>${count}</KeyCount>` +
+    `<MaxKeys>1000</MaxKeys><EncodingType>url</EncodingType>` +
+    `<IsTruncated>false</IsTruncated>${contents}</ListBucketResult>`;
+}
+
+/** Makes the data, and puts the files that the cases read. */
+export async function setup() {
+  big = data(SIZE);
+  small = data(100);
+  html = await new Response(renderListing(entries(10 * FILES))).text();
+  xml = listXML(FILES);
+  await put(":memory:/bench/big.bin", big);
+  await put(":crypt:big.bin", big, CRYPT);
+  await put(":chunker:big.bin", big, CHUNKER);
+  await put(":memory:/bench/small.txt", small);
+  for (let i = 0; i < FILES; i++) {
+    await put(`:memory:/bench-list/file${i}.txt`, small);
+    await put(`:crypt:file${i}.txt`, small, CRYPT_LIST);
+  }
+}
+
+/** @type {Record<string, () => Promise<void>>} */
+export const cases = {
+  "memory: PUT 8 MiB": () => put(":memory:/bench/put.bin", big),
+  "memory: GET 8 MiB": () => get(":memory:/bench/big.bin"),
+  "crypt: PUT 8 MiB": () => put(":crypt:put.bin", big, CRYPT),
+  "crypt: GET 8 MiB": () => get(":crypt:big.bin", CRYPT),
+  "crypt: GET a range of 1 MiB": () =>
+    get(":crypt:big.bin", { ...CRYPT, Range: "bytes=3000000-4048575" }),
+  "chunker: PUT 8 MiB in chunks of 1 MiB": () =>
+    put(":chunker:put.bin", big, CHUNKER),
+  "chunker: GET 8 MiB in chunks of 1 MiB": () =>
+    get(":chunker:big.bin", CHUNKER),
+  "memory: list 1000 files": () => get(":memory:/bench-list/"),
+  "crypt: list 1000 files": () => get(":crypt:", CRYPT_LIST),
+  "crypt: lsjson of 1000 files": async () => {
+    await drain(await lsjson(":crypt:", {}, { headers: CRYPT_LIST }));
+  },
+  "lib: renderListing of 10000 entries": async () => {
+    await new Response(renderListing(entries(10 * FILES))).arrayBuffer();
+  },
+  "lib: readListing of 10000 entries": async () => {
+    await readListing(new Response(html), new URL("http://bench/folder/"));
+  },
+  "s3: sign 1000 requests": async () => {
+    const credentials = {
+      accessKeyId: "AKIAIOSFODNN7EXAMPLE",
+      secretAccessKey: "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
+      region: "auto",
+    };
+    for (let i = 0; i < FILES; i++) {
+      sign({
+        method: "GET",
+        url: new URL(`https://bucket.example.com/folder/file%20${i}.txt`),
+        headers: new Headers({ Range: "bytes=0-99" }),
+        payload: UNSIGNED_PAYLOAD,
+      }, credentials);
+    }
+  },
+  "s3: read a list of 1000 keys": async () => {
+    const root = parseXML(xml);
+    for (const object of childrenOf(root, "Contents")) {
+      decodeURIComponent(textOf(object, "Key").replaceAll("+", " "));
+      Number(textOf(object, "Size"));
+    }
+  },
+  "rfetch fetch: 1000 GET of a small file": async () => {
+    for (let i = 0; i < FILES; i++) await get(":memory:/bench/small.txt");
+  },
+  "memory, no rfetch fetch: 1000 GET of a small file": async () => {
+    for (let i = 0; i < FILES; i++) {
+      await drain(
+        await memory.fetch(new Request("http://bench/bench/small.txt")),
+      );
+    }
+  },
+};
diff --git a/bench/node.js b/bench/node.js
new file mode 100644
index 0000000..1b1b996
--- /dev/null
+++ b/bench/node.js
@@ -0,0 +1,28 @@
+/**
+ * Runs the cases of the benchmark in Node.js: `node bench/node.js`.
+ *
+ * Each case runs in a new process, as a command of rfetch does: the time of
+ * a case can change much with the work before it in the same process.
+ * `node bench/node.js NAME` runs only the case NAME.
+ */
+import { execFileSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { bench } from "@rfetch/lib/testing/bench";
+import { cases, setup } from "./cases.js";
+
+const [name] = process.argv.slice(2);
+
+if (name) {
+  await setup();
+  await bench("", { [name]: cases[name] }, { runs: 5 });
+} else {
+  console.log("rfetch in Node.js");
+  for (const name of Object.keys(cases)) {
+    const output = execFileSync(
+      process.execPath,
+      [fileURLToPath(import.meta.url), name],
+      { encoding: "utf8" },
+    );
+    process.stdout.write(output.split("\n").slice(1).join("\n"));
+  }
+}
diff --git a/bench/worker.js b/bench/worker.js
new file mode 100644
index 0000000..230504f
--- /dev/null
+++ b/bench/worker.js
@@ -0,0 +1,25 @@
+/**
+ * Runs the cases of the benchmark in a Worker:
+ * `npx wrangler dev -c bench/wrangler.json`, then `curl http://localhost:8787/`.
+ * The clock of `wrangler dev` moves during the work of a request, thus the
+ * times are times of the CPU. A Worker in production has no such clock.
+ */
+import { cases, setup } from "./cases.js";
+
+const RUNS = 5;
+
+export default {
+  async fetch() {
+    await setup();
+    let text = "rfetch in workerd\n";
+    for (const [name, run] of Object.entries(cases)) {
+      await run();
+      const start = performance.now();
+      for (let i = 0; i < RUNS; i++) await run();
+      text += `  ${name}: ${
+        ((performance.now() - start) / RUNS).toFixed(1)
+      } ms\n`;
+    }
+    return new Response(text);
+  },
+};
diff --git a/bench/wrangler.json b/bench/wrangler.json
new file mode 100644
index 0000000..741f4ac
--- /dev/null
+++ b/bench/wrangler.json
@@ -0,0 +1,6 @@
+{
+  "name": "rfetch-bench",
+  "main": "worker.js",
+  "compatibility_date": "2026-09-01",
+  "compatibility_flags": ["nodejs_compat"]
+}

From 6a035df1d90c964485213dce33ecebbfc0720b89 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sun, 18 Oct 2026 12:44:02 +0000
Subject: [PATCH 59/87] perf(mod): read only the variables RFETCH_ and RCLONE_
 of process.env

Node.js reads each value of process.env from the system. The fetch of
rfetch read all the values with Object.entries(process.env) for each
call. Now it reads the names, then only the values of the variables
RFETCH_ and RCLONE_. A change of process.env between two calls still
has an effect.

In Node.js, with 160 variables in the environment, 1000 GET of a small
file of memory: before 327 ms, after 137 ms.
---
 mod.js | 22 +++++++++++++++++++++-
 1 file changed, 21 insertions(+), 1 deletion(-)

diff --git a/mod.js b/mod.js
index dee86c5..94fc003 100644
--- a/mod.js
+++ b/mod.js
@@ -145,7 +145,7 @@ export async function fetch(input, init = {}) {
   /** @type {Record<string, string>} */
   const variables = {};
   const places = [
-    Object.entries(env),
+    variablesOf(env),
     [...headers].map(([key, value]) => [key.toUpperCase(), value]),
   ];
   for (const entries of places) {
@@ -289,6 +289,26 @@ export async function fetch(input, init = {}) {
   );
 }
 
+/**
+ * Gives the variables `RFETCH_*` and `RCLONE_*` of the environment of the
+ * process. It reads only the names, then the values of these variables:
+ * Node.js reads each value of `process.env` from the system, which takes
+ * much time.
+ * @param {Record<string, string | undefined>} variables
+ * @returns {[string, string][]}
+ */
+function variablesOf(variables) {
+  /** @type {[string, string][]} */
+  const entries = [];
+  for (const key of Object.keys(variables)) {
+    if (key.startsWith("RFETCH_") || key.startsWith("RCLONE_")) {
+      const value = variables[key];
+      if (typeof value === "string") entries.push([key, value]);
+    }
+  }
+  return entries;
+}
+
 /**
  * Removes the options of rclone from a request to a URL: they are only for
  * the backends of rfetch.

From 19b3c6757cd27de2c8a63d1b0ca871786fc82a95 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sun, 18 Oct 2026 12:44:10 +0000
Subject: [PATCH 60/87] perf(lib): one number format and one collator for all
 the lists

toLocaleString and localeCompare make a new format or collator of the
locale for each call. Now renderListing uses one Intl.Collator, and
formatBytes uses one Intl.NumberFormat. The text and the order are the
same.

In Node.js, renderListing of 10000 entries: before 69 ms, after 58 ms.
---
 lib/format.js  | 15 ++++++++++++++-
 lib/listing.js | 11 ++++++++++-
 2 files changed, 24 insertions(+), 2 deletions(-)

diff --git a/lib/format.js b/lib/format.js
index 85e48be..c271030 100644
--- a/lib/format.js
+++ b/lib/format.js
@@ -27,7 +27,8 @@ export function formatBytes(bytes, { binary = false, locale = false } = {}) {
   }
   const sign = bytes < 0 ? "-" : "";
   let value = Math.abs(bytes);
-  const text = (number) => locale ? number.toLocaleString() : number.toString();
+  const text = (number) =>
+    locale ? localeFormat().format(number) : number.toString();
   if (value < 1) {
     return `${sign}${text(value)} B`;
   }
@@ -43,6 +44,18 @@ export function formatBytes(bytes, { binary = false, locale = false } = {}) {
   return `${sign}${number} ${unit(exponent, binary)}`;
 }
 
+/** @type {Intl.NumberFormat | undefined} */
+let numberFormat;
+
+/**
+ * Gives the format of numbers of the locale of the runtime. It gives the
+ * same text as `toLocaleString()`, which makes a new format for each call.
+ */
+function localeFormat() {
+  numberFormat ??= new Intl.NumberFormat();
+  return numberFormat;
+}
+
 /**
  * Gives the unit of a power of 1000 or of 1024: B, kB, MB, ... or B, KiB,
  * MiB, ...
diff --git a/lib/listing.js b/lib/listing.js
index 78d8a6b..8936396 100644
--- a/lib/listing.js
+++ b/lib/listing.js
@@ -73,6 +73,13 @@ export async function readListing(response, base) {
   return entries;
 }
 
+/**
+ * The order of the names of a list. It gives the same order as
+ * `localeCompare`, which makes a new collator for each call.
+ * @type {Intl.Collator | undefined}
+ */
+let collator;
+
 /**
  * Writes the list of a folder.
  * @param {Entry[]} entries
@@ -82,7 +89,9 @@ export async function readListing(response, base) {
  */
 export function renderListing(entries, { query = "" } = {}) {
   const suffix = escapeHTML(query ? `?${query}` : "");
-  const rows = entries.toSorted((a, b) => a.Name.localeCompare(b.Name)).map(
+  collator ??= new Intl.Collator();
+  const { compare } = collator;
+  const rows = entries.toSorted((a, b) => compare(a.Name, b.Name)).map(
     ({ Name, IsDir, Size, MimeType, ModTime }) => {
       const href = `${encodeURIComponent(Name)}${IsDir ? "/" : ""}`;
       const time = ModTime ? new Date(ModTime) : null;

From 3364d3438968bd16ff6f0ed603858b92c5ee8e46 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sun, 18 Oct 2026 12:44:15 +0000
Subject: [PATCH 61/87] perf(lib): readListing with no handler of end tags

A handler of an end tag is one more call from the HTML parser into
JavaScript for each row, which costs much time in a Worker. Now the
entry of a row goes in the list at its link. The last link of a row
gives the entry, as before.

The new tests in lib/listing_test.js pass with the old and the new
code.

In workerd, readListing of 10000 entries: before 397 ms, after 375 ms.
---
 lib/listing.js      | 18 +++++++----
 lib/listing_test.js | 76 +++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 88 insertions(+), 6 deletions(-)
 create mode 100644 lib/listing_test.js

diff --git a/lib/listing.js b/lib/listing.js
index 8936396..35fe5ba 100644
--- a/lib/listing.js
+++ b/lib/listing.js
@@ -31,16 +31,18 @@ import { escapeHTML } from "./html.js";
 export async function readListing(response, base) {
   /** @type {Entry[]} */
   const entries = [];
-  /** @type {Entry | null} */
+  /**
+   * The entry of the current row, at the end of `entries`. A handler of an
+   * end tag costs much time in a Worker, thus the entry goes in the list at
+   * its link.
+   * @type {Entry | null}
+   */
   let entry = null;
 
   await new HTMLRewriter()
     .on("tr", {
-      element(element) {
+      element() {
         entry = null;
-        element.onEndTag(() => {
-          if (entry) entries.push(entry);
-        });
       },
     })
     .on("tr a[href]", {
@@ -48,13 +50,17 @@ export async function readListing(response, base) {
         const name = childOf(element.getAttribute("href"), base);
         if (name === null) return;
         const isDir = name.endsWith("/");
-        entry = {
+        const link = {
           Name: isDir ? name.slice(0, -1) : name,
           IsDir: isDir,
           Size: -1,
           MimeType: element.getAttribute("type") || "",
           ModTime: "",
         };
+        // The last link of a row gives the entry of the row.
+        if (entry) entries[entries.length - 1] = link;
+        else entries.push(link);
+        entry = link;
       },
     })
     .on("tr data[value]", {
diff --git a/lib/listing_test.js b/lib/listing_test.js
new file mode 100644
index 0000000..1f08d48
--- /dev/null
+++ b/lib/listing_test.js
@@ -0,0 +1,76 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+
+import { childOf, readListing, renderListing } from "./listing.js";
+
+const base = new URL("http://remote/folder/");
+
+/** @param {string} html */
+const read = (html) => readListing(new Response(html), base);
+
+test("readListing reads the list of renderListing", async () => {
+  const entries = [
+    {
+      Name: "a b?#%.txt",
+      IsDir: false,
+      Size: 3,
+      MimeType: "text/plain",
+      ModTime: "2026-10-18T12:00:00.000Z",
+    },
+    { Name: "folder é", IsDir: true, Size: -1, MimeType: "", ModTime: "" },
+    {
+      Name: "<b>&amp;",
+      IsDir: false,
+      Size: 0,
+      MimeType: "application/octet-stream",
+      ModTime: "2026-10-18T12:00:01.000Z",
+    },
+  ];
+  const html = await new Response(renderListing(entries, { query: "x=1" }))
+    .text();
+  const sorted = entries.toSorted((a, b) => a.Name.localeCompare(b.Name));
+  assert.deepEqual(await read(html), sorted);
+});
+
+test("readListing reads only the links to the children of the folder", async () => {
+  const html = `<table>
+    <tr><td><a href="../">Go up</a></td></tr>
+    <tr><td><a href="/other/a.txt">a</a></td></tr>
+    <tr><td><a href="https://example.com/folder/b.txt">b</a></td></tr>
+    <tr><td><a href="sub/c.txt">c</a></td></tr>
+    <tr><td><a href="d.txt?x=1#y">d</a></td></tr>
+  </table>`;
+  assert.deepEqual((await read(html)).map(({ Name }) => Name), ["d.txt"]);
+});
+
+test("readListing gives one entry for each row, with the last link", async () => {
+  const html = `<table>
+    <tr><td><data value="7">7</data></td><td><a href="a.txt">a</a></td></tr>
+    <tr><td><a href="b.txt">b</a><a href="c.txt" type="text/plain">c</a></td>
+      <td><data value="5">5</data></td>
+      <td><time datetime="2026-10-18T12:00:00Z">now</time></td></tr>
+    <tr><td><a href="../">up</a></td><td><data value="9">9</data></td></tr>
+    <tr><td><a href="e/">e/</a>
+  </table>`;
+  assert.deepEqual(await read(html), [
+    { Name: "a.txt", IsDir: false, Size: -1, MimeType: "", ModTime: "" },
+    {
+      Name: "c.txt",
+      IsDir: false,
+      Size: 5,
+      MimeType: "text/plain",
+      ModTime: "2026-10-18T12:00:00Z",
+    },
+    { Name: "e", IsDir: true, Size: -1, MimeType: "", ModTime: "" },
+  ]);
+});
+
+test("childOf gives the name of a child, or null", () => {
+  assert.equal(childOf("a%20b.txt", base), "a b.txt");
+  assert.equal(childOf("a/", base), "a/");
+  assert.equal(childOf("a%2Fb", base), "a/b");
+  assert.equal(childOf("../", base), null);
+  assert.equal(childOf("a/b", base), null);
+  assert.equal(childOf("%E0", base), null);
+  assert.equal(childOf("//example.com/folder/a", base), null);
+});

From 21c8fdeec026f6f0475976e6e5a5aa009f1c607a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sun, 18 Oct 2026 12:45:50 +0000
Subject: [PATCH 62/87] perf(lsjson): read the lists with readListing

lsjson had its own HTMLRewriter for the rows, and a second
TransformStream to remove the last comma. For --recursive, it parsed
again the JSON lines of each folder below, and it thought that each
chunk was one line.

Now lsjson reads each list with readListing of lib, and one
ReadableStream gives one chunk and line for each entry. The lists of
the folders below start at the same time, as before. The output has a
fixed order now: the entries of a folder, then the entries of each
folder in it. A check of 12 cases against the old code gave the same
output.

A folder below that lsjson cannot list now stops the list with an
error, as 'rclone lsjson -R' exits with an error. Before, the list
ended with no entries of that folder, and with no error.

Crypt lsjson of 1000 files, in workerd: before 188 ms, after 97 ms.
lsjson of 1000 files of memory, in Node.js: before 56 ms, after 43 ms.
---
 cmd/lsjson/main.js      | 339 ++++++++++++++++++----------------------
 cmd/lsjson/main_test.js |  21 +++
 2 files changed, 169 insertions(+), 191 deletions(-)

diff --git a/cmd/lsjson/main.js b/cmd/lsjson/main.js
index 5de8b5e..90d2b56 100644
--- a/cmd/lsjson/main.js
+++ b/cmd/lsjson/main.js
@@ -1,12 +1,13 @@
-import { basename } from "node:path";
-import { HTMLRewriter } from "@sntran/html-rewriter";
 import { parse } from "@rfetch/lib/fspath";
+import { readListing } from "@rfetch/lib/listing";
 import { toLocaleISOString } from "@rfetch/lib/time";
 
 import { fetch } from "../../mod.js";
 
 const encoder = new TextEncoder();
-const decoder = new TextDecoder();
+
+/** The URL of a folder: the links of its list are relative to it. */
+const FOLDER = new URL("http://remote/folder/");
 
 /**
  * List directories and objects in the path in JSON format.
@@ -75,7 +76,7 @@ export async function lsjson(location, flags = {}, init = {}) {
   }
   const params = new URLSearchParams(flags);
   const url = `${prefix}${folder}?${params}`;
-  let response = await fetch(url, init);
+  const response = await fetch(url, init);
 
   if (!response.ok) {
     return response;
@@ -86,192 +87,57 @@ export async function lsjson(location, flags = {}, init = {}) {
     maxDepth = 1;
   }
 
+  const listed = read(response, {
+    location,
+    depth: maxDepth,
+    flags,
+    init,
+    filename,
+  });
+  // The error comes when the stream gets to the folder.
+  listed.catch(() => {});
+  const items = walk(listed, "");
+
   /**
-   * A stream of JSON-encoded file objects, one per chunk/line.
-   * Each JSON stringified line is followed by a comma and a newline.
-   * Note: This stream does not wrap the output in an array.
-   * @type {ReadableStream}
+   * The JSON of the item before, with no comma: only the last item has no
+   * comma after it.
+   * @type {string | null}
    */
-  let body = new ReadableStream({
-    start(controller) {
-      /**
-       * @type {import("../../mod.js").File}
-       */
-      let item;
-      let transformed = Promise.resolve();
-      /**
-       * @type {Promise[]}
-       */
-      const promises = [];
-
-      const rewriter = new HTMLRewriter();
-      rewriter.on(`tbody`, {
-        element(element) {
-          element.onEndTag(() => {
-            Promise.all(promises).then(() => {
-              controller.close();
-            });
-          });
-        },
-      });
-      rewriter.on(`tbody tr`, {
-        element(element) {
-          // Start a new item.
-          item = {
-            Path: "",
-            Name: "",
-            Size: -1,
-            MimeType: "",
-            ModTime: "",
-            IsDir: true,
-          };
-
-          element.onEndTag(() => {
-            if (item) {
-              // We always enqueue the item with trailing comma.
-              // Another transform will remove the trailing comma.
-              const line = JSON.stringify(item) + ",\n";
-              controller.enqueue(encoder.encode(line));
-            }
-          });
-        },
-      });
-      // TODO: match only links relative to the current location
-      rewriter.on(`tr a[href]`, {
-        element(element) {
-          const href = element.getAttribute("href");
-          const { pathname } = new URL(href, "file:");
-
-          if (pathname === "/") {
-            item = null;
-            return;
-          }
-
-          // The link has percent-encoding, and the name has none.
-          const name = decodeURIComponent(basename(pathname));
-
-          // If listing a file, skip other files.
-          if (filename && name !== filename) {
-            item = null;
-            return;
-          }
-
-          item.Name = name;
-
-          /**
-           * The Path field will only show folders below the remote
-           * path being listed. If "remote:path" contains the file
-           * "subfolder/file.txt", the Path for "file.txt" will be
-           * "subfolder/file.txt", not "remote:path/subfolder/file.txt".
-           * When used without --recursive the Path will always be the
-           * same as Name.
-           */
-          item.Path = name;
-
-          const isDir = item.IsDir = pathname.endsWith("/");
+  let previous = null;
 
-          const type = element.getAttribute("type");
-          if (type) {
-            item.MimeType = type;
-          }
-
-          if (isDir) {
-            item.MimeType = "inode/directory";
-            item.Size = -1;
-
-            // Recursively list subdirectories if --recursive
-            if (maxDepth > 1) {
-              // We don't want to block the current iteration, so we
-              // start a new promise for each subdirectory using IIFE.
-              // Inside, we await for the `done` promise to be resolved
-              // before enqueueing the next item.
-              const promise = (async () => {
-                // The name of the folder in the path has percent-encoding,
-                // else a "?" or a "#" in the name starts a query.
-                const child = `${location}${encodeURIComponent(name)}/`;
-                const response = await lsjson(child, {
-                  ...flags,
-                  max_depth: String(maxDepth - 1),
-                }, init);
-
-                await response.body?.pipeThrough(
-                  new TransformStream({
-                    async transform(chunk) {
-                      let line = decoder.decode(chunk).trim();
-
-                      // skips the `[` line.
-                      if (line === "[" || line === "]") {
-                        return;
-                      }
-
-                      const child = JSON.parse(line.replace(/,$/, ""));
-                      child.Path = `${name}/${child.Path}`;
-                      line = JSON.stringify(child);
-
-                      await transformed;
-                      controller.enqueue(encoder.encode(line + ",\n"));
-                    },
-                  }),
-                ).pipeTo(new WritableStream({}));
-              })();
-              promises.push(promise);
-            }
-          }
-        },
-      });
-      rewriter.on(`tr data[value]`, {
-        element(element) {
-          if (!item) return;
-          const value = element.getAttribute("value");
-          item.Size = Number(value);
-        },
-      });
-      rewriter.on(`tr time[datetime]`, {
-        element(element) {
-          if (!item) return;
-          const value = element.getAttribute("datetime");
-          if (value) {
-            item.ModTime = toLocaleISOString(value);
-          }
-        },
-      });
-
-      response = rewriter.transform(response);
-      transformed = response.body.pipeTo(new WritableStream());
-    },
-  });
-
-  // Because the JSON objects always have trailing commas, we need to
-  // do a transform to remove the trailing comma from the last object.
   /**
-   * @type {Uint8Array}
+   * A stream of JSON-encoded file objects, one per chunk and line, in an
+   * array.
+   * @type {ReadableStream<Uint8Array>}
    */
-  let previousChunk;
-  body = body.pipeThrough(
-    new TransformStream({
-      start(controller) {
-        controller.enqueue(encoder.encode("[\n"));
-      },
-      // Because we want to detect the last chunk, we need to delay the
-      // transform by one step, so we can handle it in `flush`.
-      transform(chunk, controller) {
-        if (previousChunk) {
-          controller.enqueue(previousChunk);
+  const body = new ReadableStream({
+    start(controller) {
+      controller.enqueue(encoder.encode("[\n"));
+    },
+    async pull(controller) {
+      for (;;) {
+        const { done, value } = await items.next();
+        if (done) {
+          if (previous !== null) {
+            controller.enqueue(encoder.encode(`${previous}\n`));
+          }
+          controller.enqueue(encoder.encode("]\n"));
+          controller.close();
+          return;
         }
-        previousChunk = chunk;
-      },
-      flush(controller) {
-        if (previousChunk) {
-          const chunk = concat(
-            previousChunk.slice(0, -2),
-            encoder.encode("\n"),
-          );
-          controller.enqueue(chunk);
+        const line = JSON.stringify(value);
+        if (previous !== null) {
+          controller.enqueue(encoder.encode(`${previous},\n`));
+          previous = line;
+          return;
         }
-        controller.enqueue(encoder.encode("]\n"));
-      },
-    }),
-  );
+        previous = line;
+      }
+    },
+    async cancel() {
+      await items.return(undefined);
+    },
+  });
 
   return new Response(body, {
     headers: {
@@ -281,18 +147,109 @@ export async function lsjson(location, flags = {}, init = {}) {
 }
 
 /**
- * Concats two Uint8Arrays
- * @param {Uint8Array} a
- * @param {Uint8Array} b
- * @returns {Uint8Array}
+ * An item of the output of `lsjson`.
+ * @typedef {Object} Item
+ * @property {string} Path The path below the listed folder.
+ * @property {string} Name
+ * @property {number} Size
+ * @property {string} MimeType
+ * @property {string | undefined} ModTime
+ * @property {boolean} IsDir
+ */
+
+/**
+ * The list of a folder: its items, and the lists of its folders.
+ * @typedef {Object} Folder
+ * @property {Item[]} items
+ * @property {{ name: string, folder: Promise<Folder> }[]} folders
+ */
+
+/**
+ * @typedef {Object} Walk
+ * @property {string} location The location of the folder, with a `/` at the
+ *   end.
+ * @property {number} depth The levels to list: 1 is only this folder.
+ * @property {Object} flags
+ * @property {RequestInit} init
+ * @property {string} [filename] When set, only the file with this name.
+ */
+
+/**
+ * Reads the list of a folder. When `depth` is more than 1, it starts to read
+ * the lists of the folders in it at once, thus the requests go at the same
+ * time.
+ * @param {Response} response The list of the folder.
+ * @param {Walk} options
+ * @returns {Promise<Folder>}
  */
-function concat(a, b) {
-  const result = new Uint8Array(a.byteLength + b.byteLength);
-  result.set(a, 0);
-  result.set(b, a.byteLength);
+async function read(response, { location, depth, flags, init, filename }) {
+  const entries = await readListing(response, FOLDER);
+  /** @type {Folder} */
+  const result = { items: [], folders: [] };
+  for (const { Name, IsDir, Size, MimeType, ModTime } of entries) {
+    // If listing a file, skip other files.
+    if (filename && Name !== filename) continue;
+    result.items.push({
+      Path: Name,
+      Name,
+      Size,
+      MimeType: IsDir ? "inode/directory" : MimeType,
+      ModTime: ModTime ? toLocaleISOString(ModTime) : "",
+      IsDir,
+    });
+    if (IsDir && depth > 1) {
+      // The name of the folder in the path has percent-encoding, else a "?"
+      // or a "#" in the name starts a query.
+      const child = `${location}${encodeURIComponent(Name)}/`;
+      const folder = list(Name, {
+        location: child,
+        depth: depth - 1,
+        flags: { ...flags, max_depth: String(depth - 1) },
+        init,
+      });
+      // The error comes when the walk gets to this folder.
+      folder.catch(() => {});
+      result.folders.push({ name: Name, folder });
+    }
+  }
   return result;
 }
 
+/**
+ * Requests the list of a folder, and reads it.
+ * @param {string} name The name of the folder, for the error.
+ * @param {Walk} options
+ * @returns {Promise<Folder>}
+ */
+async function list(name, options) {
+  const params = new URLSearchParams(options.flags);
+  const response = await fetch(`${options.location}?${params}`, options.init);
+  if (!response.ok) {
+    await response.body?.cancel();
+    throw new Error(`Cannot list ${name}: ${response.status}`);
+  }
+  return read(response, options);
+}
+
+/**
+ * Gives the items of a folder, then the items of each folder in it. The
+ * `Path` of an item has the names of the folders above it, below the listed
+ * folder.
+ * @param {Promise<Folder>} folder
+ * @param {string} path The path of the folder, or "" for the listed folder.
+ * @returns {AsyncGenerator<Item>}
+ */
+async function* walk(folder, path) {
+  const { items, folders } = await folder;
+  for (const item of items) {
+    if (path) item.Path = `${path}/${item.Path}`;
+    yield item;
+  }
+  for (const { name, folder } of folders) {
+    yield* walk(folder, path ? `${path}/${name}` : name);
+  }
+}
+
 /**
  * The name of a file in the path of a location, as a backend reads it: with
  * no percent-encoding.
diff --git a/cmd/lsjson/main_test.js b/cmd/lsjson/main_test.js
index 81065c6..a932ec6 100644
--- a/cmd/lsjson/main_test.js
+++ b/cmd/lsjson/main_test.js
@@ -1,5 +1,7 @@
 import { test } from "node:test";
 import assert from "node:assert/strict";
+import { listen } from "@rfetch/lib/testing/server";
+import memory from "@rfetch/memory";
 import { fetch } from "../../mod.js";
 import { lsjson } from "./main.js";
 
@@ -212,3 +214,22 @@ test("lsjson reads a connection string with a / in a value", async () => {
   await putAll(location, HARD);
   assert.deepEqual(await walk(location), entries(HARD));
 });
+
+test("lsjson --recursive gives an error for a folder it cannot list", async () => {
+  // A server of the memory backend, with no list of the folder "bad".
+  const server = await listen((request) =>
+    new URL(request.url).pathname === "/lsjson-error/bad/"
+      ? new Response("no list", { status: 500 })
+      : memory.fetch(request)
+  );
+  try {
+    await putAll(":memory:/lsjson-error/", ["bad/a.txt", "good/b.txt"]);
+    const response = await lsjson(`:http,url='${server.url}lsjson-error/':`, {
+      recursive: "true",
+    });
+    assert.equal(response.status, 200);
+    await assert.rejects(response.text(), /Cannot list bad: 50\d/);
+  } finally {
+    await server.close();
+  }
+});

From 5a60d39eb456a085d09f2b19b073d490b8e5d462 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sun, 18 Oct 2026 13:30:15 +0000
Subject: [PATCH 63/87] perf(crypt): the blocks in WebAssembly, and scrypt of
 node:crypto

The data of rclone crypt is NaCl secretbox: XSalsa20 and Poly1305.
Node.js, WebCrypto and Workers have no Salsa20, thus the blocks went
through @noble/ciphers in JavaScript. Now backend/crypt/secretbox.wasm
seals and opens the blocks, up to 16 blocks for each call. Its source is
the Rust crate in backend/crypt/native, on crypto_secretbox of RustCrypto,
as the crypt NIF of mkfifo. The module has no imports, and it uses the
SIMD of WebAssembly. The tests of rclone (TestEncryptData) and the tests
against real rclone pass.

Node.js, Deno and Bun read the file. A Worker cannot compile a module at
run time, thus the field imports of package.json gives wrangler a file
that imports the module. The new job wasm of CI builds the module again,
and compares its bytes with the file in the repository.

The key of a password now comes from the scrypt of node:crypto, which is
native code in Node.js and in workerd. @noble/ciphers and @noble/hashes
are not dependencies now. The test of the imports of the workspaces
accepts a name of the field imports of package.json, to a file in the
folder.

8 MiB in Node.js: PUT before 78 ms, after 39 ms; GET before 67 ms,
after 37 ms. 8 MiB over memory in workerd: PUT before 200 ms, after
138 ms; GET before 157 ms, after 109 ms. scrypt of a password: in
workerd before 147 ms, after 34 ms; in Node.js before 92 ms, after
48 ms.
---
 .github/workflows/ci.yml                 |  23 ++++
 CONTRIBUTING.md                          |  18 +++
 backend/crypt/main.js                    |  17 ++-
 backend/crypt/native/.cargo/config.toml  |   3 +
 backend/crypt/native/.gitignore          |   1 +
 backend/crypt/native/Cargo.lock          | 151 +++++++++++++++++++++++
 backend/crypt/native/Cargo.toml          |  21 ++++
 backend/crypt/native/build.sh            |   7 ++
 backend/crypt/native/rust-toolchain.toml |   6 +
 backend/crypt/native/src/lib.rs          | 139 +++++++++++++++++++++
 backend/crypt/package.json               |   8 +-
 backend/crypt/secretbox.js               | 140 +++++++++++++++++----
 backend/crypt/secretbox.wasm             | Bin 0 -> 9637 bytes
 backend/crypt/wasm.js                    |  11 ++
 backend/crypt/wasm.workerd.js            |   7 ++
 backend/main_test.js                     |  23 +++-
 package-lock.json                        |  21 ----
 17 files changed, 545 insertions(+), 51 deletions(-)
 create mode 100644 backend/crypt/native/.cargo/config.toml
 create mode 100644 backend/crypt/native/.gitignore
 create mode 100644 backend/crypt/native/Cargo.lock
 create mode 100644 backend/crypt/native/Cargo.toml
 create mode 100755 backend/crypt/native/build.sh
 create mode 100644 backend/crypt/native/rust-toolchain.toml
 create mode 100644 backend/crypt/native/src/lib.rs
 create mode 100755 backend/crypt/secretbox.wasm
 create mode 100644 backend/crypt/wasm.js
 create mode 100644 backend/crypt/wasm.workerd.js

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index d9f399e..a155e6e 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -4,6 +4,8 @@
 #   newer versions. The job installs rclone and Go, thus the tests that
 #   compare rfetch with rclone and with Go run too.
 # - deno fmt --check: the format of the files.
+# - wasm: the build of backend/crypt/secretbox.wasm from its source gives the
+#   same bytes as the file in the repository.
 #
 # This workflow deploys nothing: the Pages project deploys the branches.
 name: CI
@@ -85,3 +87,24 @@ jobs:
           deno-version: 2.9.6
 
       - run: deno fmt --check
+
+  wasm:
+    runs-on: ubuntu-24.04
+    timeout-minutes: 10
+    defaults:
+      run:
+        working-directory: backend/crypt/native
+    steps:
+      - uses: actions/checkout@v4
+
+      # The compiler of rust-toolchain.toml, with the target of WebAssembly.
+      - name: Install Rust
+        run: |
+          channel=$(sed -n 's/^channel = "\(.*\)"$/\1/p' rust-toolchain.toml)
+          rustup toolchain install "$channel" --profile minimal \
+            --target wasm32-unknown-unknown
+
+      - run: ./build.sh
+
+      - name: Compare with the file in the repository
+        run: git diff --exit-code -- ../secretbox.wasm
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 7ad9bee..7894562 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -270,6 +270,24 @@ default). Put the credentials in `RFETCH_S3_ACCESS_KEY_ID` and
 `RCLONE_`. Use a bucket only for the tests: the tests make folders in it and
 delete them.
 
+## WebAssembly of crypt
+
+The crypt backend encrypts the blocks of the data with
+`backend/crypt/secretbox.wasm`: NaCl secretbox (XSalsa20 and Poly1305), as
+rclone. Node.js, WebCrypto and Workers have no Salsa20, and the module is about
+2 times faster than the same code in JavaScript. The module has no imports.
+
+- The source is the Rust crate in `backend/crypt/native`.
+  `backend/crypt/native/build.sh` builds the module, with the compiler of
+  `rust-toolchain.toml` and the versions of `Cargo.lock`.
+- Node.js, Deno and Bun read the file (`wasm.js`). A Worker cannot compile a
+  module at run time, thus wrangler compiles it at the build
+  (`wasm.workerd.js`). The field `imports` of `backend/crypt/package.json`
+  selects the file.
+- After a change of the crate, build the module and commit it with the change.
+  The job `wasm` of CI builds the module again, and fails when its bytes are not
+  the bytes of the file in the repository.
+
 ## Benchmarks
 
 The cases of `bench/cases.js` measure the time of the backends, of the code in
diff --git a/backend/crypt/main.js b/backend/crypt/main.js
index cc2badf..17dccb8 100644
--- a/backend/crypt/main.js
+++ b/backend/crypt/main.js
@@ -93,7 +93,7 @@
  * - 1049120 bytes total (a 0.05% overhead). This is the overhead for big files.
  */
 
-import { scryptAsync as scrypt } from "@noble/hashes/scrypt";
+import { scrypt } from "node:crypto";
 import { HTMLRewriter } from "@sntran/html-rewriter";
 import { formatBytes } from "@rfetch/lib/format";
 import { mimeType } from "@rfetch/lib/mime";
@@ -142,6 +142,8 @@ const N = 2 ** 14; // 16384
 const r = 8;
 const p = 1;
 const dkLen = 32 + 32 + 16;
+/** The memory that scrypt can use: it needs 128 * N * r bytes, 16 MiB. */
+const SCRYPT_MEMORY = 2 * 128 * N * r;
 
 const SECRETBOX_OPTIONS = {
   blockSize: 64 * 1024, // 64 KiB
@@ -584,7 +586,18 @@ export async function deriveKey(password, salt = "") {
     return new Uint8Array(dkLen);
   }
   const saltBytes = bytes(salt).length ? bytes(salt) : DEFAULT_SALT;
-  return await scrypt(bytes(password), saltBytes, { N, r, p, dkLen });
+  // The scrypt of node:crypto is native code, also in a Worker: it is about
+  // 4 times faster than scrypt in JavaScript there.
+  const key = await new Promise((resolve, reject) => {
+    scrypt(
+      bytes(password),
+      saltBytes,
+      dkLen,
+      { N, r, p, maxmem: SCRYPT_MEMORY },
+      (error, key) => error ? reject(error) : resolve(key),
+    );
+  });
+  return new Uint8Array(key.buffer, key.byteOffset, key.length);
 }
 
 /**
diff --git a/backend/crypt/native/.cargo/config.toml b/backend/crypt/native/.cargo/config.toml
new file mode 100644
index 0000000..35abcd0
--- /dev/null
+++ b/backend/crypt/native/.cargo/config.toml
@@ -0,0 +1,3 @@
+# SIMD of WebAssembly: Node.js, Deno, Bun and workerd have it.
+[target.wasm32-unknown-unknown]
+rustflags = ["-C", "target-feature=+simd128"]
diff --git a/backend/crypt/native/.gitignore b/backend/crypt/native/.gitignore
new file mode 100644
index 0000000..eb5a316
--- /dev/null
+++ b/backend/crypt/native/.gitignore
@@ -0,0 +1 @@
+target
diff --git a/backend/crypt/native/Cargo.lock b/backend/crypt/native/Cargo.lock
new file mode 100644
index 0000000..b76c9e1
--- /dev/null
+++ b/backend/crypt/native/Cargo.lock
@@ -0,0 +1,151 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "aead"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d122413f284cf2d62fb1b7db97e02edb8cda96d769b16e443a4f6195e35662b0"
+dependencies = [
+ "crypto-common",
+ "generic-array",
+]
+
+[[package]]
+name = "cipher"
+version = "0.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "773f3b9af64447d2ce9850330c473515014aa235e6a783b02db81ff39e4a3dad"
+dependencies = [
+ "crypto-common",
+ "inout",
+ "zeroize",
+]
+
+[[package]]
+name = "cpufeatures"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "crypto-common"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a"
+dependencies = [
+ "generic-array",
+ "typenum",
+]
+
+[[package]]
+name = "crypto_secretbox"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9d6cf87adf719ddf43a805e92c6870a531aedda35ff640442cbaf8674e141e1"
+dependencies = [
+ "aead",
+ "cipher",
+ "generic-array",
+ "poly1305",
+ "salsa20",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "generic-array"
+version = "0.14.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
+dependencies = [
+ "typenum",
+ "version_check",
+ "zeroize",
+]
+
+[[package]]
+name = "inout"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "879f10e63c20629ecabbb64a8010319738c66a5cd0c29b02d63d272b03751d01"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.191"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "65cd87c9a6d60536580b316ad985726104730a5151c99845f2490428ef91240a"
+
+[[package]]
+name = "opaque-debug"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c08d65885ee38876c4f86fa503fb49d7b507c2b62552df7c70b2fce627e06381"
+
+[[package]]
+name = "poly1305"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8159bd90725d2df49889a078b54f4f79e87f1f8a8444194cdca81d38f5393abf"
+dependencies = [
+ "cpufeatures",
+ "opaque-debug",
+ "universal-hash",
+]
+
+[[package]]
+name = "salsa20"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97a22f5af31f73a954c10289c93e8a50cc23d971e80ee446f1f6f7137a088213"
+dependencies = [
+ "cipher",
+]
+
+[[package]]
+name = "secretbox"
+version = "0.1.0"
+dependencies = [
+ "crypto_secretbox",
+]
+
+[[package]]
+name = "subtle"
+version = "2.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
+
+[[package]]
+name = "typenum"
+version = "1.20.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6f5e870be6c3b371b77fe0ee0bafb859fa4964b4404c27de1d380043c4dda20"
+
+[[package]]
+name = "universal-hash"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc1de2c688dc15305988b563c3854064043356019f97a4b46276fe734c4f07ea"
+dependencies = [
+ "crypto-common",
+ "subtle",
+]
+
+[[package]]
+name = "version_check"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
+
+[[package]]
+name = "zeroize"
+version = "1.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e13084392c5e4bc371903e2935a5eaeed24905a7511356b883835e18a78f6879"
diff --git a/backend/crypt/native/Cargo.toml b/backend/crypt/native/Cargo.toml
new file mode 100644
index 0000000..20e0974
--- /dev/null
+++ b/backend/crypt/native/Cargo.toml
@@ -0,0 +1,21 @@
+# The blocks of the data of rclone crypt: NaCl secretbox (XSalsa20 and
+# Poly1305) in WebAssembly, for Node.js and for Workers. build.sh builds
+# ../secretbox.wasm from it.
+[package]
+name = "secretbox"
+version = "0.1.0"
+edition = "2021"
+publish = false
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+crypto_secretbox = { version = "=0.1.1", default-features = false, features = ["salsa20"] }
+
+[profile.release]
+opt-level = 3
+lto = true
+codegen-units = 1
+panic = "abort"
+strip = true
diff --git a/backend/crypt/native/build.sh b/backend/crypt/native/build.sh
new file mode 100755
index 0000000..ac55eba
--- /dev/null
+++ b/backend/crypt/native/build.sh
@@ -0,0 +1,7 @@
+#!/bin/sh
+# Builds ../secretbox.wasm from the crate in this folder. The compiler comes
+# from rust-toolchain.toml.
+set -eu
+cd "$(dirname "$0")"
+cargo build --release --locked --target wasm32-unknown-unknown
+cp target/wasm32-unknown-unknown/release/secretbox.wasm ../secretbox.wasm
diff --git a/backend/crypt/native/rust-toolchain.toml b/backend/crypt/native/rust-toolchain.toml
new file mode 100644
index 0000000..7209202
--- /dev/null
+++ b/backend/crypt/native/rust-toolchain.toml
@@ -0,0 +1,6 @@
+# The same compiler gives the same secretbox.wasm: the check of CI builds it
+# again and compares the bytes.
+[toolchain]
+channel = "1.97.0"
+targets = ["wasm32-unknown-unknown"]
+profile = "minimal"
diff --git a/backend/crypt/native/src/lib.rs b/backend/crypt/native/src/lib.rs
new file mode 100644
index 0000000..c1963ce
--- /dev/null
+++ b/backend/crypt/native/src/lib.rs
@@ -0,0 +1,139 @@
+//! The blocks of the data of rclone crypt: NaCl secretbox, that is
+//! XSalsa20 and Poly1305, for `../secretbox.js`.
+//!
+//! The module has no imports. JavaScript writes the key, the nonce and the
+//! input into the memory of the module, at the addresses that `key`,
+//! `nonce` and `input` give. Then `seal` or `open` writes the output at the
+//! address that `output` gives. The nonce goes up by 1 for each block, as a
+//! number in little-endian bytes, thus JavaScript reads it back for the
+//! next call.
+#![no_std]
+
+use crypto_secretbox::aead::{AeadInPlace, KeyInit};
+use crypto_secretbox::{Nonce, XSalsa20Poly1305};
+
+/// The size of a Poly1305 tag.
+const TAG: usize = 16;
+/// The size of the input and of the output: 16 boxes of 64 KiB of data.
+const SIZE: usize = 16 * (64 * 1024 + TAG);
+
+static mut KEY: [u8; 32] = [0; 32];
+static mut NONCE: [u8; 24] = [0; 24];
+static mut INPUT: [u8; SIZE] = [0; SIZE];
+static mut OUTPUT: [u8; SIZE] = [0; SIZE];
+
+#[panic_handler]
+fn panic(_: &core::panic::PanicInfo) -> ! {
+    core::arch::wasm32::unreachable()
+}
+
+/// The address of the key: 32 bytes.
+#[no_mangle]
+pub extern "C" fn key() -> *mut u8 {
+    core::ptr::addr_of_mut!(KEY).cast()
+}
+
+/// The address of the nonce: 24 bytes.
+#[no_mangle]
+pub extern "C" fn nonce() -> *mut u8 {
+    core::ptr::addr_of_mut!(NONCE).cast()
+}
+
+/// The address of the input: `size()` bytes.
+#[no_mangle]
+pub extern "C" fn input() -> *mut u8 {
+    core::ptr::addr_of_mut!(INPUT).cast()
+}
+
+/// The address of the output: `size()` bytes.
+#[no_mangle]
+pub extern "C" fn output() -> *mut u8 {
+    core::ptr::addr_of_mut!(OUTPUT).cast()
+}
+
+/// The size of the input and of the output.
+#[no_mangle]
+pub extern "C" fn size() -> usize {
+    SIZE
+}
+
+/// Adds 1 to the nonce: the first byte is the lowest.
+fn increment(nonce: &mut [u8; 24]) {
+    for byte in nonce.iter_mut() {
+        *byte = byte.wrapping_add(1);
+        if *byte != 0 {
+            break;
+        }
+    }
+}
+
+/// Seals the first `len` bytes of the input, in parts of `block` bytes: a
+/// box for each part, with a tag and then the encrypted part. Gives the size
+/// of the output, or 0 when the boxes are larger than the output.
+#[no_mangle]
+pub extern "C" fn seal(len: usize, block: usize) -> usize {
+    if block == 0 || len > SIZE || len + TAG * len.div_ceil(block) > SIZE {
+        return 0;
+    }
+    // SAFETY: JavaScript calls the functions of the module one at a time,
+    // thus no other reference to the statics exists.
+    let (key, nonce, input, output) = unsafe {
+        (
+            &*core::ptr::addr_of!(KEY),
+            &mut *core::ptr::addr_of_mut!(NONCE),
+            &*core::ptr::addr_of!(INPUT),
+            &mut *core::ptr::addr_of_mut!(OUTPUT),
+        )
+    };
+    let cipher = XSalsa20Poly1305::new(key.into());
+    let mut at = 0;
+    for part in input[..len].chunks(block) {
+        let (tag, data) = output[at..at + TAG + part.len()].split_at_mut(TAG);
+        data.copy_from_slice(part);
+        match cipher.encrypt_in_place_detached(Nonce::from_slice(nonce), b"", data) {
+            Ok(mac) => tag.copy_from_slice(&mac),
+            Err(_) => return 0,
+        }
+        at += TAG + part.len();
+        increment(nonce);
+    }
+    at
+}
+
+/// Opens the first `len` bytes of the input: boxes of a tag and `block`
+/// bytes of data, and a last box that can be shorter. Gives the size of the
+/// data in the output, or -1 for a box of `TAG` bytes or less, or for a box
+/// that does not authenticate.
+#[no_mangle]
+pub extern "C" fn open(len: usize, block: usize) -> isize {
+    if block == 0 || len > SIZE {
+        return -1;
+    }
+    // SAFETY: as for `seal`.
+    let (key, nonce, input, output) = unsafe {
+        (
+            &*core::ptr::addr_of!(KEY),
+            &mut *core::ptr::addr_of_mut!(NONCE),
+            &*core::ptr::addr_of!(INPUT),
+            &mut *core::ptr::addr_of_mut!(OUTPUT),
+        )
+    };
+    let cipher = XSalsa20Poly1305::new(key.into());
+    let mut at = 0;
+    for chunk in input[..len].chunks(TAG + block) {
+        if chunk.len() <= TAG {
+            return -1;
+        }
+        let (tag, sealed) = chunk.split_at(TAG);
+        let data = &mut output[at..at + sealed.len()];
+        data.copy_from_slice(sealed);
+        let opened =
+            cipher.decrypt_in_place_detached(Nonce::from_slice(nonce), b"", data, tag.into());
+        if opened.is_err() {
+            return -1;
+        }
+        at += sealed.len();
+        increment(nonce);
+    }
+    at as isize
+}
diff --git a/backend/crypt/package.json b/backend/crypt/package.json
index 79ea367..cb3a738 100644
--- a/backend/crypt/package.json
+++ b/backend/crypt/package.json
@@ -6,6 +6,12 @@
   "exports": {
     ".": "./main.js"
   },
+  "imports": {
+    "#wasm": {
+      "workerd": "./wasm.workerd.js",
+      "default": "./wasm.js"
+    }
+  },
   "scripts": {
     "test": "node --test"
   },
@@ -20,8 +26,6 @@
   "author": "Trần Nguyễn Sơn",
   "license": "ISC",
   "dependencies": {
-    "@noble/ciphers": "^0.5.3",
-    "@noble/hashes": "^1.4.0",
     "@rfetch/lib": "^0.1.0",
     "@sntran/html-rewriter": "^0.2.0",
     "base32-decode": "^1.0.0",
diff --git a/backend/crypt/secretbox.js b/backend/crypt/secretbox.js
index a19927f..dd5ddd9 100644
--- a/backend/crypt/secretbox.js
+++ b/backend/crypt/secretbox.js
@@ -7,7 +7,7 @@
  * data. The nonce goes up by 1 for each block, as a number in little-endian
  * bytes.
  */
-import { xsalsa20poly1305 } from "@noble/ciphers/salsa";
+import module from "#wasm";
 
 /**
  * Options for secretbox
@@ -48,17 +48,17 @@ export class EncryptionStream extends TransformStream {
       },
       transform(chunk, controller) {
         const data = pending.length ? concat(pending, chunk) : chunk;
-        let offset = 0;
-        for (; data.length - offset >= blockSize; offset += blockSize) {
-          const block = data.subarray(offset, offset + blockSize);
-          controller.enqueue(xsalsa20poly1305(key, nonce).encrypt(block));
-          increment(nonce);
+        const size = data.length - data.length % blockSize;
+        if (size > 0) {
+          controller.enqueue(
+            seal(key, nonce, data.subarray(0, size), blockSize),
+          );
         }
-        pending = data.slice(offset);
+        pending = data.slice(size);
       },
       flush(controller) {
         if (pending.length > 0) {
-          controller.enqueue(xsalsa20poly1305(key, nonce).encrypt(pending));
+          controller.enqueue(seal(key, nonce, pending, blockSize));
         }
       },
     });
@@ -89,15 +89,6 @@ export class DecryptionStream extends TransformStream {
     /** The data that is not a full header or block yet. */
     let pending = new Uint8Array(0);
 
-    /** @param {Uint8Array} block */
-    function open(block) {
-      try {
-        return xsalsa20poly1305(key, nonce).decrypt(block);
-      } catch {
-        throw new Error(Errors.BAD_BLOCK);
-      }
-    }
-
     super({
       transform(chunk, controller) {
         const data = pending.length ? concat(pending, chunk) : chunk;
@@ -113,12 +104,13 @@ export class DecryptionStream extends TransformStream {
           nonce = data.slice(magic.length, headerSize);
           offset = headerSize;
         }
-        for (; data.length - offset >= blockLength; offset += blockLength) {
-          controller.enqueue(open(data.subarray(offset, offset + blockLength)));
-          // The nonce goes up by 1 for each block.
-          increment(nonce);
+        const size = data.length - offset -
+          (data.length - offset) % blockLength;
+        if (size > 0) {
+          const boxes = data.subarray(offset, offset + size);
+          controller.enqueue(open(key, nonce, boxes, blockSize));
         }
-        pending = data.slice(offset);
+        pending = data.slice(offset + size);
       },
       flush(controller) {
         if (!nonce) {
@@ -128,7 +120,7 @@ export class DecryptionStream extends TransformStream {
           if (pending.length <= TAG_SIZE) {
             throw new Error(Errors.BAD_HEADER);
           }
-          controller.enqueue(open(pending));
+          controller.enqueue(open(key, nonce, pending, blockSize));
         }
       },
     });
@@ -175,6 +167,108 @@ export function decryptedSize(size, options = {}) {
   return blocks * blockSize + residue;
 }
 
+/**
+ * The functions and the memory of `secretbox.wasm`. The instance comes at
+ * the first use.
+ * @type {any}
+ */
+let wasm;
+
+/**
+ * Gives a view of the memory of `secretbox.wasm`, with the key and the nonce
+ * in it.
+ * @param {Uint8Array} key 32 bytes.
+ * @param {Uint8Array} nonce 24 bytes.
+ */
+function load(key, nonce) {
+  if (key.length !== 32) throw new RangeError("The key must be 32 bytes.");
+  if (nonce.length !== NONCE_SIZE) {
+    throw new RangeError(`The nonce must be ${NONCE_SIZE} bytes.`);
+  }
+  wasm ??= new WebAssembly.Instance(module, {}).exports;
+  const memory = new Uint8Array(wasm.memory.buffer);
+  memory.set(key, wasm.key());
+  memory.set(nonce, wasm.nonce());
+  return memory;
+}
+
+/**
+ * Reads the nonce back from the memory of `secretbox.wasm`, and removes the
+ * key from it.
+ * @param {Uint8Array} memory
+ * @param {Uint8Array} nonce
+ */
+function unload(memory, nonce) {
+  nonce.set(memory.subarray(wasm.nonce(), wasm.nonce() + NONCE_SIZE));
+  memory.fill(0, wasm.key(), wasm.key() + 32);
+}
+
+/**
+ * Seals the data in boxes: a box for each part of `blockSize` bytes, with a
+ * tag and the encrypted part. The nonce goes up by 1 for each box, in place.
+ * @param {Uint8Array} key
+ * @param {Uint8Array} nonce
+ * @param {Uint8Array} data
+ * @param {number} blockSize
+ * @returns {Uint8Array} The boxes.
+ */
+function seal(key, nonce, data, blockSize) {
+  const blocks = Math.ceil(data.length / blockSize);
+  const result = new Uint8Array(data.length + blocks * TAG_SIZE);
+  let at = 0;
+  for (let offset = 0; offset < data.length;) {
+    const memory = load(key, nonce);
+    // The whole blocks that go in the input of the module.
+    const step = Math.floor(wasm.size() / (blockSize + TAG_SIZE)) * blockSize;
+    if (step === 0) throw new RangeError("The block size is too large.");
+    const part = data.subarray(offset, offset + step);
+    memory.set(part, wasm.input());
+    const size = wasm.seal(part.length, blockSize);
+    result.set(memory.subarray(wasm.output(), wasm.output() + size), at);
+    unload(memory, nonce);
+    at += size;
+    offset += part.length;
+  }
+  return result;
+}
+
+/**
+ * Opens the boxes: each box has a tag and `blockSize` bytes of encrypted
+ * data, and the last box can be shorter. The nonce goes up by 1 for each
+ * box, in place.
+ * @param {Uint8Array} key
+ * @param {Uint8Array} nonce
+ * @param {Uint8Array} boxes
+ * @param {number} blockSize
+ * @returns {Uint8Array} The data.
+ * @throws {Error} With the message `Errors.BAD_BLOCK` for a box that does
+ *   not authenticate.
+ */
+function open(key, nonce, boxes, blockSize) {
+  const boxLength = blockSize + TAG_SIZE;
+  const count = Math.ceil(boxes.length / boxLength);
+  const result = new Uint8Array(boxes.length - count * TAG_SIZE);
+  let at = 0;
+  for (let offset = 0; offset < boxes.length;) {
+    const memory = load(key, nonce);
+    // The whole boxes that go in the input of the module.
+    const step = Math.floor(wasm.size() / boxLength) * boxLength;
+    if (step === 0) throw new RangeError("The block size is too large.");
+    const part = boxes.subarray(offset, offset + step);
+    memory.set(part, wasm.input());
+    const size = wasm.open(part.length, blockSize);
+    if (size < 0) {
+      unload(memory, nonce);
+      throw new Error(Errors.BAD_BLOCK);
+    }
+    result.set(memory.subarray(wasm.output(), wasm.output() + size), at);
+    unload(memory, nonce);
+    at += size;
+    offset += part.length;
+  }
+  return result;
+}
+
 /**
  * Generates random bytes using the operating systems crypto strong random
  * @param {number} length The number of the random bytes to generate
diff --git a/backend/crypt/secretbox.wasm b/backend/crypt/secretbox.wasm
new file mode 100755
index 0000000000000000000000000000000000000000..63ab90ffb803667a976d1a16b74a699add11d093
GIT binary patch
literal 9637
zcmeHNdvG1sSwFjbckg5G)m_Q5Ek6={do0_MZCMJ~a<ZhcH$xpfB|K)zOra^UEMMEY
zvL);8^(%2L`IS14rs;!6AwXyY4kd=rLTMp@T3(?IQ2qm^|1i^*7D_RXKP|-X`_8%c
zI(J|w!wfSF(%k#|&e`92?svY&k<?^%!cj^&Bc+4Rg0pZ?se|sqf;#9e@VA4HLM^KB
zT|nJ}^7?v}<9Y?(_k*J6`GM<uzUQd>f--tY7Z;aQSbV4yoM@bwYn^kIKRtW$R9pGp
zOyisi{MotLsfH>R=1w+dRVkP|)#j(wLe`i(u4;vB`iX|BS3b7Ccb(%bY+A&RN~0O=
zkV;gYoKaN|KM~+js!}zoZe3lxs8Xk?@l<4YAE|W3nJ2Zs1_pDMa~zSo82^@Ih}^|k
z$uUIkVk|y&XC@+dF)rp9B6l$^<rpG&F)rsAB6l&a<QO7%F|OtqB6l&K$}vRlV!SWM
z5V?zSEyobKi}7@hA#xYvnH)ppF2=JthR9uv=W+~@yBP1!F+}cSJfCBT+{O4njv;av
z<AoeU<Sxbsa}1HY7$3?pMDAjI*fJ6&QW*YCk4p>AllCBe$(hmakQ^#<hSkQ{V;G1F
z4E?ds5XC{NhFy7Qagjw)qqxMPXm(s?QI1<&;U?8MWGKZ|hC*CpP;pQC$-ln##bWHF
z-+JTXN4>b7e)Z<(o(<wC{nsyC{Hq}DO)GJqw~qqqZKlODRLyji#qt>{XL=P?n`!L~
z1)1)rRn4^T4E1KZmoTERy-Wup_!J3-nGRV*^HQc)Qz*^-Os~nbZ~N_`x^Rn`F0%-3
zA=7I!T_C?RnnwjYTHK4d1w0;jwM^H9QpxlHLBxcdOjoEZJ@#WdR1xOtOqU3A!{o7!
zB9(+&$zq4r;um~8>B)4D)Ymgz=ec472Dm#jt5rNfbO)xa3ym;dJ&Ws9r8Tr#iczM`
z(z!Fcbe<-mXEc=kG!u=oIHJCEp{e_7DkPVpL~RGu6SWoKBx)0&H&KItN}@IZqO^2c
z`-$2na&%e;i5d}k;I!^Z)G*{abE=8jA~HB(qBe^RP9af4kR9gK5~W23XH}wNk-=G=
zD1zL}oVAI%S7dO!MBO7YIDLuQ2)V+X{zR=88JsnVS_iqDsI^iB>Oi6fxQeOk617HT
zP}e7FwaDOXNK`-MQleHdFm+?1`a}lxo<#ME4C=j!iXa!+^#GVUn5Z6+L8V01L<TiZ
zRF&N2DxB$EKUyz`?s2df&s%)XvBHZGQuwY{8Rb+=xX17ey&VN$fFl5m*#KY~hXI(>
z6ae!)1i;iM0a(pJ0M_<60L%SR0CwO#0Bq1>0PM}X0ob)40bnD47=U;EE(|RPb;5lo
zxeu#7?)UPfMqDwMd))6vNe=J?oU2QC8+!qGK@S1&&fW%q<~#_%+x#v7UT^}yJAVKG
z<+>jLZP){Vf=mFQGrIxMzg+-m({}=(VBZ0N&fN!qijHGwu^AKY4%A=^3rpB35nkgh
z+tI|=YdD}3UFJ{$22oA8pK(aZe!s$kyR6U(yMIMW!|v;>k?G3H-uVgl<qm_p8&;ok
zQup-oMwXpVJ81#3%k`gi(g3ozTwPgN@jQH1mhjno(_8*N^!yR&1+z)7IJYVaWAaOt
z83KQeXA1nJ#ZOuMb&J1Y@zWN6(;}83?LKSqw=Dj)#n&zVj>X@#_<I(YEPl@7=Pmxe
z#Xqq4hZg_H;vZXl!{VP<{DQ?VT71*upIZDgi+^qr28Ndn`@sOy!2qkl0IS0QyTJgH
z!2oN)08_*Od%+MJAOo;ZTnRhD029Fg>%ah`#Q^)j0Moz#bHD%#!2pB609(KSGr#~d
zzyJ%tfWyy#bI*Wt&wwM(fYZ)^gPwlLX&OfwemyEz7n}>ulLa_h{`B8*xQJXm>u=#Q
z362&4>7o<+?!G&}ghxX<NEaTdL384wyN~?0vzRU^@@F`l)x}3^P(&)u#KjPXXm1nx
zNQHDEdq>R;neK(q{Uz0e>+ze?hi$IQ2RIUrE8J~5{tk5Pz+acsn`&NH;wl_4dR$gY
zQOMuRKe!ySoJLL1iVQ`nrYD=a%B}-mX+IC<z&qhVg+~j~2izRI*eF^S@s%YkATS3d
z<oG<q+_1c=7lxQii5HLcMVOk*#!YXotYAI}A->J|!1V2}IXs^d4~F6l!VumBQcd0v
zJG<~dni>{aWyi>?!%mXhjBA)Cd1<{FU16gl4zoNH!<4~!#~92__s+*PSwa9`$S(`;
za0kEMVRtwV2-cI}s@1Y`m5!D-cnBo`ZrsP<#H$!o+%JqsuVx0kIy2TXIPn03iq{Ea
zT(4)w1_HS8Mg}Lohe5^nVm}A5Y4wNc+Vz;Iem#y6SZV6VcHA46X<fXD2C&Li2-fb2
zhbX}Qtc^F*#&`?$#an4ZT%rPEzutJ5*2E*|%IA;;@yKwdhgn4QGm`0TG%R5SBC74Q
zO#%?aStZ)cfg0Fb5N3%`rlR1cOmAWl&Erh(piR;oA<-xYH>Tf;4SgunBP@bDl<A$B
z9<p%~M%zL|b~Mb?$1lbMZ)>KvN{^c}y_p~)K$4JWL`L7vQJ-P%$aHMuJFJ5!wp?t)
zPW*z8XbE8*;w|(c@fPNaB}va_R@-=jn}sRsLL=c~V~1&!VER!+SZS8do!O=HG;Jg&
z`)MXx%<y(J>z(FPrIz0Vg&8A-*XW$r^*!+Y4h^P3yNP|@Ca1HwjNq4j(^hs$!|+B>
zqF-_Bc{QwvHh~o~YcsP(n6<jYipa2t#wZ4lz{4{{ltGi(J|bUsa%=&}a>uC*<`DO|
zg*heeaeb%9aq7V=alQv}xI?Rh0qbBPq#B<K2Zv=z&i2|Sl#)+Gq{mpBM+o3TDFF_4
z1E8R)xid3t&P;61%w}_DLMZokK4;^)2QRQ78ckfWOZP&Z`2^}dXbOb;^(rViga<We
zHxPE{HE|g#US@shs5r#CRh)IysyOt|hm|u20xFI`9L=g$ZABGst8GWcp@oB-%b0#Q
z+v6ZA4)rjq3l-nW>Iu!mXj`oQ`WdEK#;-XYI5yB#tDIJC<;)os&z&Qvc<023isw$u
z9TjJFzOAQx9I=v|rizN2oFk{=qN&3)XjPm~$6L<^Pt%?aQE_v=!VG6)JFED1QE{kO
ze{%vcu%azU=qB8=khUT*n{eBZs>oU<+>?;Xv<A{~NG0lnbPN(fMJL?DkcOb76YfDs
zY-Dj-_^c?=`yy*8j)>L!G1k)1{Q*1;p~E;34%8k`@0^{`-Dlhp)zT6>Bk`e7MmN2m
zy%BphO~nxx@#Kh7SNA9gDLf4-8Q8m>g?Hlx)~qK2vI~MkqP0z?Ko$QRo=9>0yy(CW
zMV&}v+uc`ULz2j+uU}kR#5qfET>?hW7>`v_>8;BshY-Hp5hP^~U#vRi&du6O-t7y4
zbRqWKeb|7-OG`?k1RP&%j)%R#nN;88UY0{o0wa{ASCo|rWH5oKsSDx?-_Eg0`W1xb
zR}caCW+u1>P;ubx<8cU%l0OGFXapFK);#Pc0u0WYbveC=34A}g2-1)6bw)D|Fs~B#
zj9eU}P>Ew~_QDu~+~^W78Kof<?5HLPCx65p-{buyY!LY{JcQ|TP%DK91&*+#zzajN
zV0%noLB9c&qNllM4DODquQ+`9sP;#w;?YLcSEa_WHS=8cHK}s*Revj0UcTz<QdP)T
zeM74JeAVAcRgkaxd#NhstG+2!rF_*tNL4vs^)0EY<g5Nss=|ELO{uEptNux<YWb>v
zma3k7)xStpy;GGs^JbSMa;@--lb6FgDp?x8I)u?kW*Ly$G9b}qK-$ZIB$#2^0KZt2
zW(**k=F$lRvj*l2oHT&9!IYMP%s|_~DFdesoH20Lz&Qg?7<kgac?0h?aKXTW0US^n
z>7vC;7B5@8V)3fQr!2nD;x&s;TYSdivljWLfLHQ<i_cs9fW;Rqe$e8FEPmJ`GE-^)
zV-|nh;!jxoNsAw~_)`{t+Tx2Af5zg^TKqYSFIoI~iyyQ2af>etPPmfVO}LW%NixrQ
zI;Zyl+yF4(l7Qhs12}YC;>!oX_ZX0ii3wPAseGq_cNuuhz(In-;aU?;H+G_na#+iV
z$jh)gNJ(b2vRTN}i%W|t-IG4YcCBMJaq7$Ii&FC}Hx(;`?Pm=J*hR5*LrE-Sq6(&j
z%z-Nd1MERiDj6sns2H&7&siiWHm9^1rp-6S$llIHZDwloRGYQh9M)#EHovvmuFZXI
zCT#QKjb=QXGusS$kSFt!XFUvg;Ws>&vsrs#jQq7=+zcF{$G(U^2eiLI2Q%y%V6i#b
zbdfaJU{6Ia@Xl3{CKdRp4;LFzFr&qS`zgHotx$z%5wK;z?onXuxu4>yh$F^A>X=TD
ze<JJhO!(j+dc(ysqB}2Lf4Yf;dHrcFk2ke%#a&J9LQMVR{9vdF?}Gc9L3r}iXU~EL
zMgH<kHJ&%6Gq@VVt8k_Yf^W-cRpqkVX;4eCxPwjIlMbHd(57yQ0eSO;%2OJ?Y`%qo
z*SE1@rFqt<`Bn?Q4KqS|UY@`bIX6cB9#A+BQbqXv?bZ!)cDsf19R3}+ab8CcLARJ%
zWonhFKBz(3W2vR{6d~&qCV~vCqVF`-sm4rqzLl0NuWES@Da6Zn!U+%R{ocDm3eUW2
zexL4Lp@0nv91P;%CL(>A4-b#hIXLN?T{TxFF3EGcY7m@=iw|F|IHgWZ@>(t?LHJ=N
zbN6(hI1-s)HnX_8XDxD$&!p;+W?Dcj*}NUYxc_<R!kuu>9T$b*8`rQlZV7DMg1>>p
zC8$5%AV$ImQ49V;fM^Hr_W*2-XCoF!2>qaD^+#(3*bziDWhy*U^Lc_ZF%;hhG@#&C
zrG$|sUMk`8q+pH!1i8iFN#r7%UF-nOyli9>NMwUZ0;gwLNn|5o4i`AGd86}$BO4BL
zQuKj5-(HjQIzNLUxJH5;lwphh-$N$qf5$^6>KFJW;T`;<#p@PdvG_|CKVk8gEy|w`
z(C&sUBcGRke%0cC?H2lf+zVq4oUaK;Fvl64lup9FAsScEOr@-c_BdaMnYXU-|F*k*
z?T)*xhd6>>`er`jfQNx`O;@F_O07-kuxW+pc@vY|od>!$5B&Hgw#jb#dcIlF<a6O)
zctu=MFSz&=@ChyuOxdvVQkVY{0vE}bBg4%buxSwbb>W8gFE9iDP0@KggvS9t9?-=b
zx^&?@KM(Lnk~@?gpp;4N#vM<^JTJ4OLz{6t30WX`RR8!5UBhz}cj2Ejuqp&f8=Bl-
z6@QxnwTGW=)Q(W=pu$aFfEV;3mWkWqwh7-oaF5(uB$OIccwqc-S14TF1D^-V1zf8=
zy#Ct5Sk6lQGJIyf(0kpifkRXFYbEZ;xuN@{FCH|MetTr--h9*A?WW_>w2zxsF&rkr
zdxSe>eD_H6TE3xoyWuWwh)35kPu!iEsWh>8*?JD1@v=A!i8{{^Nr&OrJcsvgNrhkb
zPD~%Bhv;}?cIw!v*%{)0qoEV0vNj!R5dP(6^od4mZcTQ4da6OwvxggJDQi!*+8Ir@
zX{knsPPM5qd)O3JUu$yqXu~ipdr1@iQ-|h`ka>1wu0^IdRAJPk?PIj0BJ&VEeOt|z
z+ysrsT61&lv7J+st)p{et;W&mtlc^{mbIqFWWqbAT9fTYwsU%J^u7mnJur3T{;7#W
zyASQ&z30f-)bz<?jn?S+&RsiqNeeV>OrF@;$`rRhK7EMAEmLzR&pm#mHFx51nR-Im
z+^H5e#4N<FVt8r$2pyhlWZ1SgotSJ-9izjItUWzD*`A)8eJj}+QR?$5Qa=QHb{3zl
i_zXCassNwFXE0Y@d`tP=D8DWD{4vNqxiUYG@%eYWsfED+

literal 0
HcmV?d00001

diff --git a/backend/crypt/wasm.js b/backend/crypt/wasm.js
new file mode 100644
index 0000000..af0d0f5
--- /dev/null
+++ b/backend/crypt/wasm.js
@@ -0,0 +1,11 @@
+/**
+ * The module of `secretbox.wasm` for Node.js, Deno and Bun: they read the
+ * file and compile it. A Worker cannot compile a module at run time, thus it
+ * imports `wasm.workerd.js` in place of this file (the field `imports` of
+ * `package.json`).
+ */
+import { readFileSync } from "node:fs";
+
+export default new WebAssembly.Module(
+  readFileSync(new URL("./secretbox.wasm", import.meta.url)),
+);
diff --git a/backend/crypt/wasm.workerd.js b/backend/crypt/wasm.workerd.js
new file mode 100644
index 0000000..15ced5b
--- /dev/null
+++ b/backend/crypt/wasm.workerd.js
@@ -0,0 +1,7 @@
+/**
+ * The module of `secretbox.wasm` for a Worker: wrangler compiles it at the
+ * build, and the import gives the module.
+ */
+import module from "./secretbox.wasm";
+
+export default module;
diff --git a/backend/main_test.js b/backend/main_test.js
index 3c24191..17256b1 100644
--- a/backend/main_test.js
+++ b/backend/main_test.js
@@ -82,9 +82,8 @@ test("load gives each backend, and nothing for other names", async () => {
 test("each workspace imports only node:, its packages, and its files", () => {
   for (const folder of WORKSPACES) {
     const path = join(ROOT, folder);
-    const { dependencies = {}, devDependencies = {} } = JSON.parse(
-      readFileSync(join(path, "package.json")),
-    );
+    const { dependencies = {}, devDependencies = {}, imports = {} } = JSON
+      .parse(readFileSync(join(path, "package.json")));
     for (const file of filesOf(path)) {
       const source = readFileSync(join(path, file), "utf8");
       for (const specifier of importsOf(source)) {
@@ -104,6 +103,24 @@ test("each workspace imports only node:, its packages, and its files", () => {
           );
           continue;
         }
+        if (specifier.startsWith("#")) {
+          // A file of the folder, from the field `imports` of package.json.
+          assert.ok(
+            Object.hasOwn(imports, specifier),
+            `${where} is not in imports`,
+          );
+          const targets = JSON.stringify(imports[specifier]).match(
+            /"\.[^"]*"/g,
+          );
+          for (const target of targets ?? []) {
+            const inside = relative(path, resolve(path, JSON.parse(target)));
+            assert.ok(
+              !inside.startsWith(".."),
+              `${where} is out of the folder`,
+            );
+          }
+          continue;
+        }
         const name = packageOf(specifier);
         assert.ok(
           Object.hasOwn(dependencies, name) ||
diff --git a/package-lock.json b/package-lock.json
index 9aca153..3978cde 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -62,8 +62,6 @@
       "version": "0.1.0",
       "license": "ISC",
       "dependencies": {
-        "@noble/ciphers": "^0.5.3",
-        "@noble/hashes": "^1.4.0",
         "@rfetch/lib": "^0.1.0",
         "@sntran/html-rewriter": "^0.2.0",
         "base32-decode": "^1.0.0",
@@ -156,25 +154,6 @@
         "node": ">=22.2.0"
       }
     },
-    "node_modules/@noble/ciphers": {
-      "version": "0.5.3",
-      "resolved": "https://registry.npmjs.org/@noble/ciphers/-/ciphers-0.5.3.tgz",
-      "integrity": "sha512-B0+6IIHiqEs3BPMT0hcRmHvEj2QHOLu+uwt+tqDDeVd0oyVzh7BPrDcPjRnV1PV/5LaknXJJQvOuRGR0zQJz+w==",
-      "funding": {
-        "url": "https://paulmillr.com/funding/"
-      }
-    },
-    "node_modules/@noble/hashes": {
-      "version": "1.4.0",
-      "resolved": "https://registry.npmjs.org/@noble/hashes/-/hashes-1.4.0.tgz",
-      "integrity": "sha512-V1JJ1WTRUqHHrOSh597hURcMqVKVGL/ea3kv0gSnEdsEZ0/+VyPghM1lMNGc00z7CIQorSvbKpuJkxvuHbvdbg==",
-      "engines": {
-        "node": ">= 16"
-      },
-      "funding": {
-        "url": "https://paulmillr.com/funding/"
-      }
-    },
     "node_modules/@rfetch/alias": {
       "resolved": "backend/alias",
       "link": true

From 0ea470e55758d0f5583bdc7121db29a96c297abd Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sun, 18 Oct 2026 13:33:32 +0000
Subject: [PATCH 64/87] perf(memory): bytes in place of a Blob, and the
 children of each folder

The memory backend kept each file as a File, and each folder as a key
with no value. A list read all the keys of all the folders, and a GET
gave the File as the body: a Worker reads a Blob body in chunks of
4 KiB.

Now a file is its bytes, its media type and its time, and a GET gives a
copy of the bytes as the body. Each folder has the names of its
children, thus a list reads only its folder. The behavior is the same,
and the shared suite passes.

A list of 10 files, with 10000 other files in the store, in Node.js:
before 0.39 ms, after 0.13 ms. 8 MiB in workerd, in one run with the
two versions: PUT before 12 ms, after 8 ms; GET with a reader before
31 ms, after 24 ms. A delete of a folder of 10000 files: before 1.5 ms,
after 3.7 ms.
---
 backend/memory/main.js | 151 +++++++++++++++++++++++++----------------
 1 file changed, 94 insertions(+), 57 deletions(-)

diff --git a/backend/memory/main.js b/backend/memory/main.js
index 3acb12f..e477628 100644
--- a/backend/memory/main.js
+++ b/backend/memory/main.js
@@ -13,13 +13,26 @@ import { decodePath } from "@rfetch/lib/path";
 import { notSatisfiable, parseRange, partialHeaders } from "@rfetch/lib/range";
 
 /**
- * The files and the folders, by their path with no percent-encoding. The path
- * of a folder ends with `/`, and a folder has no value.
- * @type {Map<string, File | null>}
+ * A file: its bytes, its media type, and the time of its last change.
+ * @typedef {Object} File
+ * @property {Uint8Array} bytes
+ * @property {string} type
+ * @property {number} modified In milliseconds.
  */
-const cache = new Map();
-// Creates the root folder.
-cache.set("/", null);
+
+/**
+ * The files, by their path with no percent-encoding.
+ * @type {Map<string, File>}
+ */
+const files = new Map();
+
+/**
+ * The folders, by their path with no percent-encoding and with `/` at the
+ * end. The value is the names of the children: `name` for a file and
+ * `name/` for a folder. Thus a list reads only its folder.
+ * @type {Map<string, Set<string>>}
+ */
+const folders = new Map([["/", new Set()]]);
 
 /**
  * Serves a memory remote
@@ -39,76 +52,79 @@ async function memory(request) {
   let status = 200, body = null;
 
   if (method === "HEAD" || method === "GET") {
-    if (!cache.has(path)) {
-      return new Response(null, { status: 404 });
-    }
-
-    const file = cache.get(path);
+    const file = files.get(path);
     if (file) {
+      const { bytes } = file;
       headers.set("Content-Type", file.type || mimeType(path));
-      headers.set("Content-Length", `${file.size}`);
-      headers.set("Last-Modified", new Date(file.lastModified).toUTCString());
+      headers.set("Content-Length", `${bytes.length}`);
+      headers.set("Last-Modified", new Date(file.modified).toUTCString());
       headers.set("Accept-Ranges", "bytes");
-      // A Blob has a size, thus a Worker sends its Content-Length.
       if (method === "GET") {
         let range;
         try {
-          range = parseRange(request.headers.get("Range"), file.size);
+          range = parseRange(request.headers.get("Range"), bytes.length);
         } catch {
-          return notSatisfiable(file.size);
+          return notSatisfiable(bytes.length);
         }
-        body = file;
+        // The body is a copy of the bytes, with a length. A Worker reads a
+        // Blob in chunks of 4 KiB, which is slow.
+        body = bytes;
         if (range) {
           status = 206;
           for (
             const [name, value] of Object.entries(
-              partialHeaders(range, file.size),
+              partialHeaders(range, bytes.length),
             )
           ) {
             headers.set(name, value);
           }
-          body = file.slice(range.start, range.end + 1);
+          body = bytes.subarray(range.start, range.end + 1);
         }
       }
-    } else {
+    } else if (folders.has(path)) {
       headers.set("Content-Type", "text/html;charset=utf-8");
       if (method === "GET") {
         body = listing(path, searchParams);
       }
+    } else {
+      return new Response(null, { status: 404 });
     }
   } else if (method === "PUT") {
+    const slash = path.lastIndexOf("/") + 1;
     // Creates the parent folders, then the folder or the file.
-    const names = path.split("/").slice(1, -1);
-    let folder = "/";
-    for (const name of names) {
-      folder += `${name}/`;
-      cache.set(folder, null);
-    }
-
-    if (!path.endsWith("/")) {
-      const name = path.slice(path.lastIndexOf("/") + 1);
-      const file = new File([await request.arrayBuffer()], name, {
+    makeFolder(path.slice(0, slash));
+    if (slash < path.length) {
+      const name = path.slice(slash);
+      files.set(path, {
+        bytes: new Uint8Array(await request.arrayBuffer()),
         type: request.headers.get("Content-Type") || mimeType(name),
-        lastModified: Date.now(),
+        modified: Date.now(),
       });
-      cache.set(path, file);
+      folders.get(path.slice(0, slash))?.add(name);
     }
 
     status = 201;
     headers.append("Content-Location", pathname);
   } else if (method === "DELETE") {
-    if (!cache.has(path)) {
-      return new Response(null, { status: 404 });
-    }
-
-    // Deletes the file, or the folder and all in it.
-    for (const key of cache.keys()) {
-      if (key === path || (path.endsWith("/") && key.startsWith(path))) {
-        cache.delete(key);
+    if (files.has(path)) {
+      files.delete(path);
+      const slash = path.lastIndexOf("/") + 1;
+      folders.get(path.slice(0, slash))?.delete(path.slice(slash));
+    } else if (folders.has(path)) {
+      // Deletes the folder and all in it. The root folder stays.
+      removeFolder(path);
+      if (path === "/") {
+        folders.set("/", new Set());
+      } else {
+        const parent = path.slice(
+          0,
+          path.lastIndexOf("/", path.length - 2) + 1,
+        );
+        folders.get(parent)?.delete(path.slice(parent.length));
       }
+    } else {
+      return new Response(null, { status: 404 });
     }
-    // The root folder stays.
-    cache.set("/", null);
     status = 204;
   } else {
     status = 405;
@@ -121,6 +137,30 @@ async function memory(request) {
   });
 }
 
+/**
+ * Creates a folder and its parent folders.
+ * @param {string} path The path of the folder, with `/` at the end.
+ */
+function makeFolder(path) {
+  if (folders.has(path)) return;
+  const parent = path.slice(0, path.lastIndexOf("/", path.length - 2) + 1);
+  makeFolder(parent);
+  folders.set(path, new Set());
+  folders.get(parent)?.add(path.slice(parent.length));
+}
+
+/**
+ * Removes a folder, its files and its folders.
+ * @param {string} path The path of the folder, with `/` at the end.
+ */
+function removeFolder(path) {
+  for (const name of folders.get(path) ?? []) {
+    if (name.endsWith("/")) removeFolder(`${path}${name}`);
+    else files.delete(`${path}${name}`);
+  }
+  folders.delete(path);
+}
+
 /**
  * Gives the HTML list of the files and the folders in a folder.
  * @param {string} path The path of the folder, with `/` at the end.
@@ -128,23 +168,10 @@ async function memory(request) {
  * @returns {ReadableStream<Uint8Array>}
  */
 function listing(path, searchParams) {
-  // The children are the paths in the folder with no other "/" than a "/" at
-  // the end for a folder.
   /** @type {import("@rfetch/lib/listing").Entry[]} */
   const entries = [];
-  for (const [key, file] of cache) {
-    if (key === path || !key.startsWith(path)) continue;
-    const child = key.slice(path.length);
-    const slash = child.indexOf("/");
-    if (slash === -1) {
-      entries.push({
-        Name: child,
-        IsDir: false,
-        Size: file.size,
-        MimeType: file.type || mimeType(child),
-        ModTime: new Date(file.lastModified).toISOString(),
-      });
-    } else if (slash === child.length - 1) {
+  for (const child of folders.get(path) ?? []) {
+    if (child.endsWith("/")) {
       entries.push({
         Name: child.slice(0, -1),
         IsDir: true,
@@ -152,6 +179,16 @@ function listing(path, searchParams) {
         MimeType: "",
         ModTime: "",
       });
+    } else {
+      const file = files.get(`${path}${child}`);
+      if (!file) continue;
+      entries.push({
+        Name: child,
+        IsDir: false,
+        Size: file.bytes.length,
+        MimeType: file.type || mimeType(child),
+        ModTime: new Date(file.modified).toISOString(),
+      });
     }
   }
   return renderListing(entries, { query: `${searchParams}` });

From 532790ce8ef4beaee625aebff5cd7a49b2fec86b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sun, 18 Oct 2026 13:34:50 +0000
Subject: [PATCH 65/87] fix(crypt): the same bytes of secretbox.wasm on each
 machine

The module had the path of the crates of cargo on the machine of the
build, for example /root/.cargo/registry/..., thus the job wasm of CI
built other bytes. Now build.sh changes the path of the crates to /cargo
and the path of the crate to /crate, with --remap-path-prefix. Two
builds in two folders, with two homes of cargo, gave the same bytes.

The flags are in build.sh now, in place of .cargo/config.toml: the
variable of the flags takes the place of the flags of the file.
---
 backend/crypt/native/.cargo/config.toml |   3 ---
 backend/crypt/native/build.sh           |  14 +++++++++++++-
 backend/crypt/secretbox.wasm            | Bin 9637 -> 9633 bytes
 3 files changed, 13 insertions(+), 4 deletions(-)
 delete mode 100644 backend/crypt/native/.cargo/config.toml

diff --git a/backend/crypt/native/.cargo/config.toml b/backend/crypt/native/.cargo/config.toml
deleted file mode 100644
index 35abcd0..0000000
--- a/backend/crypt/native/.cargo/config.toml
+++ /dev/null
@@ -1,3 +0,0 @@
-# SIMD of WebAssembly: Node.js, Deno, Bun and workerd have it.
-[target.wasm32-unknown-unknown]
-rustflags = ["-C", "target-feature=+simd128"]
diff --git a/backend/crypt/native/build.sh b/backend/crypt/native/build.sh
index ac55eba..26f99ea 100755
--- a/backend/crypt/native/build.sh
+++ b/backend/crypt/native/build.sh
@@ -1,7 +1,19 @@
 #!/bin/sh
 # Builds ../secretbox.wasm from the crate in this folder. The compiler comes
-# from rust-toolchain.toml.
+# from rust-toolchain.toml, and the versions of the crates from Cargo.lock.
+#
+# The flags:
+# - The SIMD of WebAssembly: Node.js, Deno, Bun and workerd have it.
+# - The paths of the build do not go into the module: the folder of the
+#   crates of cargo becomes /cargo, and this folder becomes /crate. Thus each
+#   machine builds the same bytes, and CI can compare them.
 set -eu
 cd "$(dirname "$0")"
+cargo_home=${CARGO_HOME:-$HOME/.cargo}
+separator=$(printf '\037')
+CARGO_ENCODED_RUSTFLAGS="-Ctarget-feature=+simd128${separator}"
+CARGO_ENCODED_RUSTFLAGS="${CARGO_ENCODED_RUSTFLAGS}--remap-path-prefix=${cargo_home}=/cargo${separator}"
+CARGO_ENCODED_RUSTFLAGS="${CARGO_ENCODED_RUSTFLAGS}--remap-path-prefix=$(pwd)=/crate"
+export CARGO_ENCODED_RUSTFLAGS
 cargo build --release --locked --target wasm32-unknown-unknown
 cp target/wasm32-unknown-unknown/release/secretbox.wasm ../secretbox.wasm
diff --git a/backend/crypt/secretbox.wasm b/backend/crypt/secretbox.wasm
index 63ab90ffb803667a976d1a16b74a699add11d093..e64e3de89dde6526d2a33d725ba058f6e332ee6c 100755
GIT binary patch
delta 453
zcmZ4Lz0iBY0p1_24UG(rj9E$yRt!HTo)zc)i6roI;zv>5Uq}MKKmxy!1b%}A{vZkb
z0Sat<lEcJo#n3<bHnY7_OB>JvMRrF94W<S#lLN#AYf<C`F@J2fVR^{R*s)oTV;#5h
zkER0+3<6yZ4Gjzo+#C#!KbnDj5aR}n@niCPVH?30AnspoW&s5zM~1%)3^yj*h-fkX
zn4B(R!8l>_0+D1E;SP`zm{AIB3Y?BJHj7E-Ff&e=+$@uf#f0xN>Od3ZWdngG6v~RR
zh@SwP&<$~nV?zVbJV#;26_e*F>T%8mITUF5j?GsUUodh%VrFCjsbJu~G5Lh@k;#)(
zHYYJK9AXe)@MmCPr~qPhAQoa2VBiAM)j%wd#BV_3M+5n`Nb)g2HXjlnB(Dg>0NEpe
ATL1t6

delta 463
zcmZ4Jz0`Zc0p35Y4UG(rj9E$yRt$e8o)zDm!<fUw3gY!oW@HlOozRAmp8yt_h$J!*
zEHVj6WD-b(doonSied8P+syV#9U#6UyCZ`JQwx~M0b(|QnVcZzpUpNb51AQzHp_9W
z<5vFDbfAGjpsS&wfq{XWgTe7nGmsBr+<`IvOnxtHBlrfy{macPpuptF@Rxz%&SV=A
zEyh2S(?u*8r)*vzlFTC915yGrN`Xy*({avbG07Ze#wnAVWs<R&@Lfh7Xo9?KAkc(D
zSuqyzGhh?CA&zluXaJh$DD1dq@;pU7&cz^y0xjRO`KsazM($_Kj0_+Z4BU4npHM!+
zR+OJ#qOUi(M`d%uAqD}4PzDBu3LsVoVhKh81}-374aD+D{020BG>~tLBp(B0^C9s;
I@`^wV0Iex|C;$Ke


From cefad25b1d04b9d3522f94f4e7c8a149bb11d7d3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sun, 18 Oct 2026 13:42:16 +0000
Subject: [PATCH 66/87] fix(lsjson): a path to a folder with no / at the end
 lists the folder

rclone lsjson remote:tree lists the folder tree. rfetch lsjson read a
path with no / at the end as a file: it listed the parent folder and
gave only the entry of tree. Now, when no file has the name and a folder
has it, lsjson lists that folder, as rclone. A file of the name is still
a file. The comparison with rclone found the difference.
---
 cmd/lsjson/main.js      | 39 ++++++++++++++++++++++++---------------
 cmd/lsjson/main_test.js | 15 +++++++++++++++
 2 files changed, 39 insertions(+), 15 deletions(-)

diff --git a/cmd/lsjson/main.js b/cmd/lsjson/main.js
index 90d2b56..918ef11 100644
--- a/cmd/lsjson/main.js
+++ b/cmd/lsjson/main.js
@@ -82,18 +82,28 @@ export async function lsjson(location, flags = {}, init = {}) {
     return response;
   }
 
+  /** @type {import("@rfetch/lib/listing").Entry[] | undefined} */
+  let entries;
+  if (!isDirectory) {
+    // A path with no "/" at the end is a folder when no file has the name,
+    // as in rclone: then the list is the list of the folder.
+    entries = await readListing(response, FOLDER);
+    const named = entries.filter(({ Name }) => Name === filename);
+    if (named.length > 0 && named.every(({ IsDir }) => IsDir)) {
+      return lsjson(`${location}/`, flags, init);
+    }
+  }
+
   let maxDepth = Number(flags.max_depth || (flags.recursive ? Infinity : 1));
   if (!isDirectory || !flags.recursive) {
     maxDepth = 1;
   }
 
-  const listed = read(response, {
-    location,
-    depth: maxDepth,
-    flags,
-    init,
-    filename,
-  });
+  /** @type {Walk} */
+  const options = { location, depth: maxDepth, flags, init, filename };
+  const listed = entries
+    ? Promise.resolve(folderOf(entries, options))
+    : readListing(response, FOLDER).then((list) => folderOf(list, options));
   // The error comes when the stream gets to the folder.
   listed.catch(() => {});
   const items = walk(listed, "");
@@ -175,15 +185,14 @@ export async function lsjson(location, flags = {}, init = {}) {
  */
 
 /**
- * Reads the list of a folder. When `depth` is more than 1, it starts to read
- * the lists of the folders in it at once, thus the requests go at the same
- * time.
- * @param {Response} response The list of the folder.
+ * Gives the folder of the entries of its list. When `depth` is more than 1,
+ * it starts to read the lists of the folders in it at once, thus the
+ * requests go at the same time.
+ * @param {import("@rfetch/lib/listing").Entry[]} entries
  * @param {Walk} options
- * @returns {Promise<Folder>}
+ * @returns {Folder}
  */
-async function read(response, { location, depth, flags, init, filename }) {
-  const entries = await readListing(response, FOLDER);
+function folderOf(entries, { location, depth, flags, init, filename }) {
   /** @type {Folder} */
   const result = { items: [], folders: [] };
   for (const { Name, IsDir, Size, MimeType, ModTime } of entries) {
@@ -228,7 +237,7 @@ async function list(name, options) {
     await response.body?.cancel();
     throw new Error(`Cannot list ${name}: ${response.status}`);
   }
-  return read(response, options);
+  return folderOf(await readListing(response, FOLDER), options);
 }
 
 /**
diff --git a/cmd/lsjson/main_test.js b/cmd/lsjson/main_test.js
index a932ec6..0a2db77 100644
--- a/cmd/lsjson/main_test.js
+++ b/cmd/lsjson/main_test.js
@@ -233,3 +233,18 @@ test("lsjson --recursive gives an error for a folder it cannot list", async () =
     await server.close();
   }
 });
+
+test("lsjson lists a folder with no / at the end, as rclone", async () => {
+  await putAll(":memory:/no-slash/", ["tree/a.txt", "tree/b/c.txt", "file"]);
+  assert.deepEqual(await walk(":memory:/no-slash/tree"), [
+    { Path: "a.txt", IsDir: false, Size: 10 },
+    { Path: "b", IsDir: true, Size: -1 },
+    { Path: "b/c.txt", IsDir: false, Size: 12 },
+  ]);
+  // A file of the name is a file, as for rclone.
+  const result = await lsjson(":memory:/no-slash/file")
+    .then((response) => response.json());
+  assert.deepEqual(result.map(({ Path, IsDir }) => ({ Path, IsDir })), [
+    { Path: "file", IsDir: false },
+  ]);
+});

From 455e1042ba5183423b556514a91e30c14ef4c1e2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sun, 18 Oct 2026 13:42:16 +0000
Subject: [PATCH 67/87] perf(local): reads of 1 MiB, and the stats of a list at
 the same time

A GET read the file in parts of 64 KiB, with one call to the system for
each part. Now a part is 1 MiB. The list of a folder made the stat of
each file one after the other. Now the stats go at the same time, and a
file that goes away before its stat is not in the list.

rfetch cat of 64 MiB of a local file, the whole command: before 257 ms,
after 217 ms; cat of a chunker file of 64 MiB in chunks of 8 MiB: before
324 ms, after 253 ms. In one process: the list of a folder of 100 files,
before 11.5 ms, after 8.9 ms; lsjson --recursive of 1000 files, before
156 ms, after 102 ms.
---
 backend/local/main.js | 19 +++++++++++++++----
 1 file changed, 15 insertions(+), 4 deletions(-)

diff --git a/backend/local/main.js b/backend/local/main.js
index da39409..37d3552 100644
--- a/backend/local/main.js
+++ b/backend/local/main.js
@@ -45,12 +45,20 @@ async function local(request) {
        */
       const files = await readdir(absolutePath, { withFileTypes: true });
       files.sort((a, b) => a.name.localeCompare(b.name));
+      // The stat of each file, at the same time: one after the other takes
+      // much more time. A file that goes away before its stat is not in
+      // the list.
+      const fileStats = await Promise.all(
+        files.map((file) =>
+          stat(join(absolutePath, file.name)).catch(() => null)
+        ),
+      );
 
       if (method === "GET") {
         const query = escapeHTML(`${searchParams}`);
 
         body = new ReadableStream({
-          async start(controller) {
+          start(controller) {
             controller.enqueue(`
               <search>
                 <form>
@@ -80,14 +88,15 @@ async function local(request) {
                 </tr>
               `);
 
-            for (const file of files) {
+            for (const [index, file] of files.entries()) {
+              if (!fileStats[index]) continue;
               const name = file.name;
               const isDirectory = file.isDirectory();
               const href = `${encodeURIComponent(name)}${
                 isDirectory ? "/" : ""
               }`;
 
-              const { size, mtimeMs } = await stat(join(absolutePath, name));
+              const { size, mtimeMs } = fileStats[index];
               const mtime = timeOf(mtimeMs);
 
               controller.enqueue(`<tr>
@@ -151,7 +160,9 @@ async function local(request) {
 
         body = new ReadableStream({
           async pull(controller) {
-            const chunk = new Uint8Array(Math.min(64 * 1024, remaining));
+            // A read of 1 MiB: each read is a call to the system, and parts
+            // of 64 KiB make a read of a large file much slower.
+            const chunk = new Uint8Array(Math.min(1024 * 1024, remaining));
             const { bytesRead } = remaining > 0
               ? await file.read(chunk, 0, chunk.length, position)
               : { bytesRead: 0 };

From 9ab42af675aba57646ef88612029bfdab674a133 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sun, 18 Oct 2026 13:43:18 +0000
Subject: [PATCH 68/87] test(bench): the commands of rfetch against the
 commands of rclone

bench/rclone.js runs the same commands with the two tools, with the same
remotes in the variables RCLONE_CONFIG_*, on the same files: cat, rcat
and lsjson --recursive on local files, crypt and chunker. rclone writes
the files of crypt and chunker. First the script makes sure that the two
tools give the same data and the same lists, and that rclone reads the
files that rfetch writes. The time is the time of the whole process.

The tools run in a temporary folder, with relative paths: the local
backend of rfetch reads only the files in its current folder.
---
 CONTRIBUTING.md |   6 ++
 README.md       |   3 +-
 bench/rclone.js | 187 ++++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 195 insertions(+), 1 deletion(-)
 create mode 100644 bench/rclone.js

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 7894562..b9fde6c 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -303,6 +303,12 @@ in Node.js and in workerd, the runtime of Cloudflare Workers:
   times of workerd change much from one run to the next: run it three times, and
   use the median.
 
+- `node bench/rclone.js` runs the same commands with rfetch and with rclone,
+  which must be in the PATH or in the variable `RCLONE`: cat, rcat and
+  `lsjson --recursive` on local files, crypt and chunker. First it makes sure
+  that the two tools give the same data and the same lists. The time is the time
+  of the whole process, with the start of Node.js or of rclone.
+
 Measure before and after a change for speed, and write the two times in the
 message of the commit.
 
diff --git a/README.md b/README.md
index 39c499b..32d203c 100644
--- a/README.md
+++ b/README.md
@@ -70,5 +70,6 @@ bytes, with ranges. The prefix `RCLONE_` of rclone also works.
 - `npm test` to run the tests, with the test runner of Node.js.
 - `npm run bench` to compare some commands with `rclone`, which must be in the
   PATH.
-- `node bench/node.js` to measure the time of the backends. See
+- `node bench/node.js` to measure the time of the backends, and
+  `node bench/rclone.js` to compare the commands with rclone. See
   [CONTRIBUTING.md](CONTRIBUTING.md#benchmarks) for the benchmark in a Worker.
diff --git a/bench/rclone.js b/bench/rclone.js
new file mode 100644
index 0000000..7142f9a
--- /dev/null
+++ b/bench/rclone.js
@@ -0,0 +1,187 @@
+/**
+ * Compares the commands of rfetch with the commands of rclone:
+ * `node bench/rclone.js`. rclone must be in the PATH, or in the variable
+ * RCLONE.
+ *
+ * Each case runs the same command of each tool as a new process, with the
+ * same remotes in the variables RCLONE_CONFIG_*, on the same files in a
+ * temporary folder, which is the current folder of each process: the local
+ * backend of rfetch reads only the files in its current folder. The time is
+ * the time of the whole process, as a user
+ * sees it: the start of Node.js or of rclone is in it. The first case, a
+ * list of an empty folder, shows the time of the start.
+ */
+import { execFileSync, spawnSync } from "node:child_process";
+import { createHash, randomBytes } from "node:crypto";
+import {
+  closeSync,
+  mkdirSync,
+  mkdtempSync,
+  openSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const RCLONE = process.env.RCLONE || "rclone";
+const RFETCH = fileURLToPath(new URL("../main.js", import.meta.url));
+const RUNS = 5;
+/** The size of a large file. */
+const SIZE = 64 * 1024 * 1024;
+
+const root = mkdtempSync(join(tmpdir(), "rfetch-bench-"));
+const home = join(root, "home");
+mkdirSync(home);
+
+/** The environment of each tool: the remotes, and no config file. */
+const env = {
+  PATH: process.env.PATH,
+  HOME: home,
+  RCLONE_CONFIG_SECRET_TYPE: "crypt",
+  RCLONE_CONFIG_SECRET_REMOTE: "crypt",
+  RCLONE_CONFIG_SECRET_PASSWORD: execFileSync(RCLONE, ["obscure", "bench"], {
+    encoding: "utf8",
+  }).trim(),
+  RCLONE_CONFIG_CHUNKS_TYPE: "chunker",
+  RCLONE_CONFIG_CHUNKS_REMOTE: "chunks",
+  RCLONE_CONFIG_CHUNKS_CHUNK_SIZE: "8M",
+};
+
+/** The command of a tool, as a program and its arguments. */
+const tools = {
+  rfetch: (args) => [process.execPath, [RFETCH, ...args]],
+  rclone: (args) => [RCLONE, args],
+};
+
+/**
+ * Runs a command of a tool, and gives its time and the hash of its output.
+ * @param {string} tool
+ * @param {string[]} args
+ * @param {string} [input] A file for the standard input.
+ */
+function run(tool, args, input) {
+  const [program, argv] = tools[tool](args);
+  const output = join(root, "output");
+  const stdin = input ? openSync(input, "r") : "ignore";
+  const stdout = openSync(output, "w");
+  const start = performance.now();
+  const result = spawnSync(program, argv, {
+    cwd: root,
+    env,
+    stdio: [stdin, stdout, "pipe"],
+  });
+  const time = performance.now() - start;
+  if (typeof stdin === "number") closeSync(stdin);
+  closeSync(stdout);
+  if (result.status !== 0) {
+    throw new Error(`${tool} ${args.join(" ")}: ${result.stderr}`);
+  }
+  const hash = createHash("sha256").update(readFileSync(output)).digest("hex");
+  return { time, hash };
+}
+
+/**
+ * The lines of `lsjson` with no times, in order, for a compare. The size of
+ * a folder is not in a line: rclone gives the size of a local folder, and
+ * rfetch gives -1.
+ */
+function paths(tool, args) {
+  run(tool, args);
+  return JSON.parse(readFileSync(join(root, "output"), "utf8"))
+    .map(({ Path, Size, IsDir }) => `${Path} ${IsDir ? "folder" : Size}`)
+    .sort();
+}
+
+// The files of the cases.
+const big = join(root, "big.bin");
+writeFileSync(big, randomBytes(SIZE));
+mkdirSync(join(root, "empty"));
+for (let folder = 0; folder < 10; folder++) {
+  mkdirSync(join(root, "tree", `folder ${folder}`), { recursive: true });
+  for (let file = 0; file < 100; file++) {
+    writeFileSync(
+      join(root, "tree", `folder ${folder}`, `file ${file}.txt`),
+      `${folder} ${file}`,
+    );
+  }
+}
+// rclone writes the files that both tools read from crypt and chunker.
+const setup = { cwd: root, env, stdio: "ignore" };
+execFileSync(RCLONE, ["copy", "tree", "secret:tree"], setup);
+execFileSync(RCLONE, ["copyto", "big.bin", "secret:big.bin"], setup);
+execFileSync(RCLONE, ["copyto", "big.bin", "chunks:big.bin"], setup);
+
+/** @type {Record<string, (tool: string) => string[] | [string[], string]>} */
+const cases = {
+  "lsjson of an empty folder (start)": () => ["lsjson", "empty"],
+  "local: cat 64 MiB": () => ["cat", "big.bin"],
+  "local: lsjson --recursive, 1000 files": () => [
+    "lsjson",
+    "--recursive",
+    "tree",
+  ],
+  "crypt: cat 64 MiB": () => ["cat", "secret:big.bin"],
+  "crypt: rcat 64 MiB": (tool) => [["rcat", `secret:${tool}/put.bin`], big],
+  "crypt: lsjson --recursive, 1000 files": () => [
+    "lsjson",
+    "--recursive",
+    "secret:tree",
+  ],
+  "chunker: cat 64 MiB in chunks of 8 MiB": () => ["cat", "chunks:big.bin"],
+  "chunker: rcat 64 MiB in chunks of 8 MiB": (tool) => [
+    ["rcat", `chunks:${tool}/put.bin`],
+    big,
+  ],
+};
+
+try {
+  // The two tools give the same data and the same lists.
+  const hash = createHash("sha256").update(readFileSync(big)).digest("hex");
+  for (const tool of Object.keys(tools)) {
+    for (const location of ["secret:big.bin", "chunks:big.bin"]) {
+      if (run(tool, ["cat", location]).hash !== hash) {
+        throw new Error(`${tool} cat ${location}: not the same data`);
+      }
+    }
+    for (const location of ["secret", "chunks"]) {
+      run(tool, ["rcat", `${location}:${tool}/check.bin`], big);
+      if (
+        run("rclone", ["cat", `${location}:${tool}/check.bin`]).hash !== hash
+      ) {
+        throw new Error(`${tool} rcat ${location}: rclone reads other data`);
+      }
+    }
+  }
+  for (const location of ["tree", "secret:tree"]) {
+    const args = ["lsjson", "--recursive", location];
+    if (`${paths("rfetch", args)}` !== `${paths("rclone", args)}`) {
+      throw new Error(`lsjson ${location}: not the same list`);
+    }
+  }
+
+  console.log(
+    `rfetch (Node.js ${process.versions.node}) and rclone, median of ${RUNS} runs`,
+  );
+  for (const [name, make] of Object.entries(cases)) {
+    const times = {};
+    for (const tool of Object.keys(tools)) {
+      const made = make(tool);
+      const [args, input] = Array.isArray(made[0]) ? made : [made];
+      run(tool, args, input);
+      const list = [];
+      for (let i = 0; i < RUNS; i++) list.push(run(tool, args, input).time);
+      times[tool] = list.sort((a, b) => a - b)[Math.floor(RUNS / 2)];
+    }
+    const ratio = (times.rfetch / times.rclone).toFixed(1);
+    console.log(
+      `  ${name}: rfetch ${times.rfetch.toFixed(0)} ms, rclone ${
+        times.rclone.toFixed(0)
+      } ms (${ratio}x)`,
+    );
+  }
+} finally {
+  rmSync(root, { recursive: true, force: true });
+}

From 4703d36edd6efb1cb9d97f345c083318ffbaa5dc Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sun, 18 Oct 2026 15:06:05 +0000
Subject: [PATCH 69/87] perf(cli): load only the module of the command

The command line loaded all the commands through mod.js, and with them
HTMLRewriter. Now main.js loads only the module of its command, from
the list cmd/folders.js. The fetch of rfetch is in fetch.js: mod.js,
the commands and _worker.js import it. An unknown command gives an
error and the help, with the exit code 1.

The median time of 21 runs, in Node.js 22, before and after:
- obscure: 135 ms, 109 ms.
- help: 123 ms, 103 ms.
- cat of a small file: 127 ms, 114 ms.

The test cmd/folders_test.js makes sure that cmd/folders.js has each
command of cmd/main.js.
---
 CONTRIBUTING.md     |  20 ++-
 _worker.js          |   3 +-
 backend/main.js     |   2 +-
 cmd/backend/main.js |   2 +-
 cmd/cat/main.js     |   2 +-
 cmd/copy/main.js    |   2 +-
 cmd/copyurl/main.js |   2 +-
 cmd/folders.js      |  21 +++
 cmd/folders_test.js |  16 +++
 cmd/help/main.js    |   4 +-
 cmd/ls/main.js      |   2 +-
 cmd/lsd/main.js     |   2 +-
 cmd/lsf/main.js     |   2 +-
 cmd/lsjson/main.js  |   2 +-
 cmd/lsl/main.js     |   2 +-
 cmd/rcat/main.js    |   2 +-
 cmd/serve/main.js   |   2 +-
 fetch.js            | 316 ++++++++++++++++++++++++++++++++++++++++++++
 main.js             |  16 ++-
 mod.js              | 308 +-----------------------------------------
 20 files changed, 399 insertions(+), 329 deletions(-)
 create mode 100644 cmd/folders.js
 create mode 100644 cmd/folders_test.js
 create mode 100644 fetch.js

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index b9fde6c..e355ddf 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -70,8 +70,8 @@ Cloudflare: it gets all from the request and from `env`, the second argument of
 `fetch`. A backend on top of another remote, for example `crypt` or `chunker`,
 sends its requests to that remote with the global `fetch`, for example
 `fetch(":memory:/crypt/file.bin")`. The host sets the global `fetch` that reads
-such a path: the import of `mod.js` sets it, and `_worker.js` imports `mod.js`.
-The tests of such a backend import `mod.js` too:
+such a path: the import of `fetch.js` sets it. `mod.js`, the commands and
+`_worker.js` import `fetch.js`. The tests of such a backend import `mod.js`:
 
 ```js
 // Sets the global `fetch` that reads the paths of remotes.
@@ -109,9 +109,9 @@ options of the request go on, for example a remote `RFETCH_CONFIG_NAME_TYPE`
 that only the headers tell. The options of the backend itself do not go. When
 the remote is a URL, no option goes: a secret must not go out to a server.
 
-The `fetch` of `mod.js` reads the headers `RFETCH_*` and `RCLONE_*` of a request
-as the variables, in the place of the variables of the process. A remote can
-come only from variables: `RFETCH_CONFIG_NAME_TYPE` and its options, as in
+The `fetch` of `fetch.js` reads the headers `RFETCH_*` and `RCLONE_*` of a
+request as the variables, in the place of the variables of the process. A remote
+can come only from variables: `RFETCH_CONFIG_NAME_TYPE` and its options, as in
 rclone. The backend gets the options of the path, the connection string and the
 flags, in its query, and all the other options in `env`, as
 `RFETCH_REMOTE_NAME`. The headers `RFETCH_*` and `RCLONE_*` never go out to a
@@ -197,6 +197,16 @@ modification time.
 `renderListing` of `@rfetch/lib/listing` writes such a list from the entries of
 a folder, and `readListing` reads it.
 
+## Commands
+
+Each command is a function of a module in `cmd`, for example `cat` of
+`cmd/cat/main.js` and `reveal` of `cmd/obscure/main.js`. A new command goes in
+`cmd/main.js`, for `mod.js`, and in `cmd/folders.js`, for the command line:
+`main.js` loads only the module of its command, because the load of all the
+commands takes much time. A command imports `fetch.js` and the modules of the
+other commands that it uses, not `mod.js`. The test `cmd/folders_test.js` makes
+sure that the two lists are the same.
+
 ## Tests of a backend
 
 Each backend must pass the shared tests of `@rfetch/lib/testing/suite`. These
diff --git a/_worker.js b/_worker.js
index a998216..6a10a2f 100644
--- a/_worker.js
+++ b/_worker.js
@@ -17,7 +17,8 @@
  * A path with no remote is a static file of the site.
  */
 // The import also sets the global `fetch`, which reads the paths of remotes.
-import { fetch, lsjson } from "./mod.js";
+import { fetch } from "./fetch.js";
+import { lsjson } from "./cmd/lsjson/main.js";
 import { parse } from "@rfetch/lib/fspath";
 
 /**
diff --git a/backend/main.js b/backend/main.js
index e6dc410..b096851 100644
--- a/backend/main.js
+++ b/backend/main.js
@@ -8,7 +8,7 @@
  * A backend on top of another remote, for example crypt, sends its requests
  * to that remote with the global `fetch`, for example
  * `fetch(":memory:/path")`. The host sets the global `fetch` that reads
- * such a path: `mod.js` in Node.js, and `_worker.js` in a Worker.
+ * such a path: the import of `fetch.js` sets it, in Node.js and in a Worker.
  *
  * @typedef {Object} Backend
  * @property {(request: Request, env?: Object) => Response | Promise<Response>} fetch
diff --git a/cmd/backend/main.js b/cmd/backend/main.js
index 7140603..cd07f29 100644
--- a/cmd/backend/main.js
+++ b/cmd/backend/main.js
@@ -1,4 +1,4 @@
-import { fetch } from "../../mod.js";
+import { fetch } from "../../fetch.js";
 
 /**
  * Run a backend-specific command.
diff --git a/cmd/cat/main.js b/cmd/cat/main.js
index a49f756..29df04b 100644
--- a/cmd/cat/main.js
+++ b/cmd/cat/main.js
@@ -1,4 +1,4 @@
-import { fetch } from "../../mod.js";
+import { fetch } from "../../fetch.js";
 
 /**
  * @param {string} location
diff --git a/cmd/copy/main.js b/cmd/copy/main.js
index 755d4b6..834e261 100644
--- a/cmd/copy/main.js
+++ b/cmd/copy/main.js
@@ -1,4 +1,4 @@
-import { fetch } from "../../mod.js";
+import { fetch } from "../../fetch.js";
 /**
  * Copy files from source to dest, skipping identical files.
  *
diff --git a/cmd/copyurl/main.js b/cmd/copyurl/main.js
index bd4f7e9..a59b611 100644
--- a/cmd/copyurl/main.js
+++ b/cmd/copyurl/main.js
@@ -1,6 +1,6 @@
 import { basename, resolve } from "node:path";
 
-import { fetch } from "../../mod.js";
+import { fetch } from "../../fetch.js";
 
 /**
  * @typedef {Object} Options
diff --git a/cmd/folders.js b/cmd/folders.js
new file mode 100644
index 0000000..5f093a7
--- /dev/null
+++ b/cmd/folders.js
@@ -0,0 +1,21 @@
+/**
+ * The folder in `cmd` of each command. The command line loads only the
+ * module of its command: the load of all the commands takes much time.
+ */
+export const FOLDERS = {
+  backend: "backend",
+  cat: "cat",
+  config: "config",
+  copy: "copy",
+  copyurl: "copyurl",
+  help: "help",
+  ls: "ls",
+  lsd: "lsd",
+  lsf: "lsf",
+  lsjson: "lsjson",
+  lsl: "lsl",
+  obscure: "obscure",
+  rcat: "rcat",
+  reveal: "obscure",
+  serve: "serve",
+};
diff --git a/cmd/folders_test.js b/cmd/folders_test.js
new file mode 100644
index 0000000..ae30846
--- /dev/null
+++ b/cmd/folders_test.js
@@ -0,0 +1,16 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+
+import * as commands from "./main.js";
+import { FOLDERS } from "./folders.js";
+
+test("FOLDERS has each command, and the folder of its module", async () => {
+  assert.deepEqual(
+    Object.keys(FOLDERS).toSorted(),
+    Object.keys(commands).toSorted(),
+  );
+  for (const [name, folder] of Object.entries(FOLDERS)) {
+    const module = await import(`./${folder}/main.js`);
+    assert.equal(module[name], commands[name], name);
+  }
+});
diff --git a/cmd/help/main.js b/cmd/help/main.js
index 2c67c84..acad915 100644
--- a/cmd/help/main.js
+++ b/cmd/help/main.js
@@ -1,5 +1,5 @@
 import { backends } from "../../backend/main.js";
-import * as commands from "../main.js";
+import { FOLDERS } from "../folders.js";
 
 /**
  * @type {Object<string, () => string>}
@@ -12,7 +12,7 @@ usage["commands"] = () =>
   rfetch [command]
 
 Available Commands:
-  ${Object.keys(commands).join("\n  ")}
+  ${Object.keys(FOLDERS).join("\n  ")}
 
 Use "rfetch [command] --help" for more information about a command.
 Use "rfetch help flags" for to see the global flags.
diff --git a/cmd/ls/main.js b/cmd/ls/main.js
index 62ff879..8ee5269 100644
--- a/cmd/ls/main.js
+++ b/cmd/ls/main.js
@@ -1,4 +1,4 @@
-import { lsf } from "../../mod.js";
+import { lsf } from "../lsf/main.js";
 /**
  * List the objects in the path with size and path.
  *
diff --git a/cmd/lsd/main.js b/cmd/lsd/main.js
index 10ddde6..de0b51e 100644
--- a/cmd/lsd/main.js
+++ b/cmd/lsd/main.js
@@ -1,4 +1,4 @@
-import { lsf } from "../../mod.js";
+import { lsf } from "../lsf/main.js";
 /**
  * List all directories/containers/buckets in the path.
  *
diff --git a/cmd/lsf/main.js b/cmd/lsf/main.js
index 7458549..2e1516c 100644
--- a/cmd/lsf/main.js
+++ b/cmd/lsf/main.js
@@ -1,4 +1,4 @@
-import { lsjson } from "../../mod.js";
+import { lsjson } from "../lsjson/main.js";
 
 const FORMATS = {
   "p": "Path",
diff --git a/cmd/lsjson/main.js b/cmd/lsjson/main.js
index 918ef11..84eadbf 100644
--- a/cmd/lsjson/main.js
+++ b/cmd/lsjson/main.js
@@ -2,7 +2,7 @@ import { parse } from "@rfetch/lib/fspath";
 import { readListing } from "@rfetch/lib/listing";
 import { toLocaleISOString } from "@rfetch/lib/time";
 
-import { fetch } from "../../mod.js";
+import { fetch } from "../../fetch.js";
 
 const encoder = new TextEncoder();
 
diff --git a/cmd/lsl/main.js b/cmd/lsl/main.js
index d1d7368..3c82937 100644
--- a/cmd/lsl/main.js
+++ b/cmd/lsl/main.js
@@ -1,4 +1,4 @@
-import { lsf } from "../../mod.js";
+import { lsf } from "../lsf/main.js";
 
 /**
  * List the objects in path with modification time, size and path.
diff --git a/cmd/rcat/main.js b/cmd/rcat/main.js
index bbeef0e..720ceab 100644
--- a/cmd/rcat/main.js
+++ b/cmd/rcat/main.js
@@ -1,5 +1,5 @@
 import process from "node:process";
-import { fetch } from "../../mod.js";
+import { fetch } from "../../fetch.js";
 
 /**
  * Copies standard input to file on remote.
diff --git a/cmd/serve/main.js b/cmd/serve/main.js
index aa82171..cee2670 100644
--- a/cmd/serve/main.js
+++ b/cmd/serve/main.js
@@ -1,4 +1,4 @@
-import { fetch } from "../../mod.js";
+import { fetch } from "../../fetch.js";
 import { load } from "../../backend/main.js";
 
 /**
diff --git a/fetch.js b/fetch.js
new file mode 100644
index 0000000..f5dd9a1
--- /dev/null
+++ b/fetch.js
@@ -0,0 +1,316 @@
+/**
+ * The `fetch` of rfetch, which reads the paths of remotes. The import of this
+ * module sets it as the global `fetch`. A command imports this module and
+ * not mod.js: mod.js exports all the commands, which take much time to load.
+ */
+import { env } from "node:process";
+import { backends, load } from "./backend/main.js";
+import { parse } from "@rfetch/lib/fspath";
+import { isOption, PREFIXES } from "@rfetch/lib/options";
+
+/**
+ * @typedef {Object<string, string> & { type: string }} Remote
+ */
+
+const globalFetch = globalThis.fetch;
+
+/**
+ * A `fetch` with support for remote URL. The import of this module sets it
+ * as the global `fetch`. Thus a backend on top of other remotes, for example
+ * crypt, calls `fetch(":memory:/path")` and does not import rfetch.
+ *
+ * The syntax of the paths passed to the rfetch command are as follows.
+ *
+ * `/path/to/dir``
+ *
+ * This refers to the local file system.
+ *
+ * On Windows `\` may be used instead of `/` in local paths only, non local
+ * paths must use `/`.
+ *
+ * These paths needn't start with a leading `/` - if they don't then they
+ * will be relative to the current directory.
+ *
+ * `remote:path/to/dir`
+ *
+ * This refers to a directory `path/to/dir` on `remote:` as defined in the
+ * config.
+ *
+ * `remote:/path/to/dir`
+ *
+ * On most backends this refers to the same directory as `remote:path/to/dir`
+ * and that format should be preferred. On a very small number of remotes
+ * (FTP, SFTP, ..) this will refer to a different directory. On these, paths
+ * without a leading `/` will refer to your "home" directory and paths with a
+ * leading `/` will refer to the root.
+ *
+ * `:backend:path/to/dir`
+ *
+ * This is an advanced form for creating remotes on the fly. `backend` should
+ * be the name or prefix of a backend (the `type` in the config file) and all
+ * the configuration for the backend should be provided on the command line
+ * (or in environment variables).
+ *
+ * ## Precedence
+ *
+ * The various different methods of backend configuration are read in this
+ * order and the first one with a value is used.
+ *
+ * - Parameters in connection strings, e.g. `myRemote,skip_links:`
+ * - Flag values as supplied on the command line, e.g. `--skip-links`
+ * - Remote specific environment vars, e.g. `RFETCH_CONFIG_MYREMOTE_SKIP_LINKS`
+ * - Backend-specific environment vars, e.g. `RFETCH_LOCAL_SKIP_LINKS`
+ * - Backend generic environment vars, e.g. `RFETCH_SKIP_LINKS`
+ * - Config file, e.g. `skip_links = true`.
+ * - Default values, e.g. `false` - these can't be changed.
+ *
+ * So if both `--skip-links` is supplied on the command line and an environment
+ * variable `RFETCH_LOCAL_SKIP_LINKS` is set, the command line flag will take
+ * preference.
+ *
+ * Each variable can also have the prefix `RCLONE_` of rclone, for
+ * compatibility, for example `RCLONE_LOCAL_SKIP_LINKS`. In each place,
+ * `RFETCH_` takes the place of `RCLONE_`.
+ *
+ * A header of the request with the name of a variable, for example
+ * `RFETCH_CONFIG_MYREMOTE_SKIP_LINKS`, takes the place of the variable of the
+ * environment. A remote can come only from variables, as in rclone:
+ * `RFETCH_CONFIG_MYREMOTE_TYPE` and its options. Thus a request can give
+ * all its configuration, with no config file.
+ *
+ * The backend gets the options of the path, the connection string and the
+ * flags, in the query of its request. It gets the other options in `env`,
+ * the second argument of its `fetch`, with the names of the variables of
+ * rfetch, for example `RFETCH_LOCAL_SKIP_LINKS`. A backend makes the links of
+ * a list from the query only, thus an option of `env` is never in a link.
+ *
+ * The headers `RFETCH_*` and `RCLONE_*` are only for the backends of rfetch:
+ * they never go
+ * out to a URL.
+ *
+ * For non backend configuration the order is as follows:
+ *
+ * - Flag values as supplied on the command line, e.g. `--stats 5s`.
+ * - Environment vars, e.g. `RFETCH_STATS=5s`.
+ * - Default values, e.g. `1m` - these can't be changed.
+ *
+ * ## Other environment variables
+ *
+ * @param {string | Request | URL} input
+ * @param { RequestInit} [init={}]
+ * @returns {Promise<Response>}
+ */
+export async function fetch(input, init = {}) {
+  if (
+    typeof input !== "string" || input.startsWith("https://") ||
+    input.startsWith("http://") || input.startsWith("file://")
+  ) {
+    return globalFetch(...withoutOptions(input, init));
+  }
+
+  // The parts of the path, as rclone reads them. It throws a SyntaxError
+  // for a path that is not correct.
+  const parsed = parse(input);
+
+  const headers = new Headers(init.headers);
+  // The variables, by their names with no prefix, for example
+  // `CONFIG_R2_TYPE`: the environment of the process, then the headers of
+  // the request, which take their place. In each place, `RFETCH_` takes the
+  // place of `RCLONE_`.
+  /** @type {Record<string, string>} */
+  const variables = {};
+  const places = [
+    variablesOf(env),
+    [...headers].map(([key, value]) => [key.toUpperCase(), value]),
+  ];
+  for (const entries of places) {
+    for (const prefix of ["RCLONE_", "RFETCH_"]) {
+      for (const [key, value] of entries) {
+        if (key.startsWith(prefix) && typeof value === "string") {
+          variables[key.slice(prefix.length)] = value;
+        }
+      }
+    }
+  }
+
+  let { name } = parsed;
+
+  /**
+   * @type {Remote}
+   */
+  let config;
+
+  if (name === "") { // A local path.
+    config = { type: "local" };
+  } else if (name.startsWith(":")) { // `:type:path/to/file`
+    config = { type: name.slice(1) };
+    name = "";
+  } else {
+    // A remote of the config file, or of the variables, as rclone.
+    const type = variables[`CONFIG_${name.toUpperCase()}_TYPE`];
+    // The command config reads the config file. It loads only for a remote
+    // with a name.
+    const { config: command } = await import("./cmd/config/main.js");
+    const response = await command("show", name, undefined, {
+      headers: { "Accept": "application/json" },
+    }).catch(() => null);
+    if (response?.ok) {
+      config = await response.json();
+    } else if (type) {
+      config = {};
+    } else {
+      throw new Error(`Remote ${name} not found in config.`);
+    }
+    if (type) config.type = type;
+  }
+
+  const type = config.type;
+  delete config.type;
+
+  // The options that are not in the path, from the lowest precedence: the
+  // config file, then the variables.
+  const options = new Map(Object.entries(config));
+
+  // Backend generic variables, for example `RFETCH_SKIP_LINKS`. A variable
+  // of a remote or of a backend is not generic: it is not an option of each
+  // backend.
+  const specific = ["CONFIG", ...Object.keys(backends)]
+    .map((prefix) => `${prefix.toUpperCase()}_`);
+  for (const [key, value] of Object.entries(variables)) {
+    if (specific.some((prefix) => key.startsWith(prefix))) continue;
+    options.set(key.toLowerCase(), value);
+  }
+
+  // Backend-specific variables, for example `RFETCH_LOCAL_SKIP_LINKS`.
+  let prefix = `${type.toUpperCase()}_`;
+  for (const [key, value] of Object.entries(variables)) {
+    if (key.startsWith(prefix)) {
+      options.set(key.slice(prefix.length).toLowerCase(), value);
+    }
+  }
+
+  // Remote specific variables, for example `RFETCH_CONFIG_MYREMOTE_SKIP_LINKS`.
+  if (name) {
+    prefix = `CONFIG_${name.toUpperCase()}_`;
+    for (const [key, value] of Object.entries(variables)) {
+      if (key.startsWith(prefix) && key !== `${prefix}TYPE`) {
+        options.set(key.slice(prefix.length).toLowerCase(), value);
+      }
+    }
+  }
+
+  // `searchParams` may contain other flags not for the current backend.
+  const { pathname, searchParams } = new URL(parsed.path, "file:");
+
+  // The query of the backend: the flags prefixed with the backend type, then
+  // the parameters in the connection string, which take their place.
+  const params = new URLSearchParams();
+  searchParams.forEach((value, key) => {
+    if (key.startsWith(`${type}_`)) {
+      params.set(key.replace(`${type}_`, ""), value);
+    }
+  });
+  for (const [key, value] of Object.entries(parsed.config)) {
+    params.set(key, value);
+  }
+
+  // The other options go in `env`. The backend reads its query first, as a
+  // flag takes the place of a variable.
+  /** @type {Record<string, string>} */
+  const optionsEnv = {};
+  for (const [key, value] of options) {
+    optionsEnv[`RFETCH_${type.toUpperCase()}_${key.toUpperCase()}`] = value;
+  }
+  // The headers of this backend are in its options now.
+  const own = PREFIXES.map((start) => `${start}${type.toLowerCase()}_`);
+  for (const key of [...headers.keys()]) {
+    if (own.some((start) => key.startsWith(start))) headers.delete(key);
+  }
+
+  if (init.method === "TRACE") {
+    let body = `TRACE ${pathname}?${params} HTTP/1.1\r`;
+    // Reflects the request as response body, then the options in `env`.
+    for (const [name, value] of headers) {
+      body += `${name}: ${value}\r`;
+    }
+    for (const [name, value] of Object.entries(optionsEnv)) {
+      body += `${name}: ${value}\r`;
+    }
+    return new Response(body, {
+      status: 200,
+      headers: {
+        "Content-Type": "message/http",
+        "Via": `${type}/1.1 ${name}`.trim(),
+      },
+    });
+  }
+
+  if (init.body instanceof ReadableStream) {
+    // @ts-ignore: Must have `duplex` for streaming body
+    init.duplex = "half"; // Must set this for stream body.
+  }
+
+  const backend = await load(type);
+  if (!backend) {
+    throw new Error(`Backend ${type} not found.`);
+  }
+
+  const url = new URL(`${pathname}?${params}`, import.meta.url || `file:`);
+  // Creates a new request with the initial init.
+  const request = new Request(url, init);
+  // Clones that request and updates the headers.
+  return backend.fetch(
+    new Request(request, {
+      headers,
+    }),
+    optionsEnv,
+  );
+}
+
+/**
+ * Gives the variables `RFETCH_*` and `RCLONE_*` of the environment of the
+ * process. It reads only the names, then the values of these variables:
+ * Node.js reads each value of `process.env` from the system, which takes
+ * much time.
+ * @param {Record<string, string | undefined>} variables
+ * @returns {[string, string][]}
+ */
+function variablesOf(variables) {
+  /** @type {[string, string][]} */
+  const entries = [];
+  for (const key of Object.keys(variables)) {
+    if (key.startsWith("RFETCH_") || key.startsWith("RCLONE_")) {
+      const value = variables[key];
+      if (typeof value === "string") entries.push([key, value]);
+    }
+  }
+  return entries;
+}
+
+/**
+ * Removes the options of rclone from a request to a URL: they are only for
+ * the backends of rfetch.
+ * @param {string | Request | URL} input
+ * @param {RequestInit} init
+ * @returns {[string | Request | URL, RequestInit]}
+ */
+function withoutOptions(input, init) {
+  /** @param {HeadersInit} [from] */
+  const clean = (from) => {
+    const headers = new Headers(from);
+    for (const key of [...headers.keys()]) {
+      if (isOption(key)) headers.delete(key);
+    }
+    return headers;
+  };
+  if (input instanceof Request) {
+    input = new Request(input, { headers: clean(input.headers) });
+  }
+  if (init.headers !== undefined) {
+    init = { ...init, headers: clean(init.headers) };
+  }
+  return [input, init];
+}
+
+// The other URLs go to the original `fetch`.
+globalThis.fetch = fetch;
diff --git a/main.js b/main.js
index d1014c4..3e71a4f 100755
--- a/main.js
+++ b/main.js
@@ -10,10 +10,13 @@
  * ./main.js copy source:/path/to/file destination:/path/to/file
  * ```
  */
-import { argv, env, stdout } from "node:process";
+import process, { argv, env, stderr, stdout } from "node:process";
 import { parseArgs } from "node:util";
 
-import * as commands from "./mod.js";
+// The import sets the global `fetch`, which reads the paths of remotes.
+import "./fetch.js";
+
+import { FOLDERS } from "./cmd/folders.js";
 
 /** Optional params for the subcommand. */
 const options = {
@@ -68,8 +71,15 @@ for (const name of Object.keys(flags)) {
 }
 
 (async () => {
+  let name = subcommand;
+  if (!Object.hasOwn(FOLDERS, name)) {
+    stderr.write(`Error: unknown command "${name}" for "rfetch"\n`);
+    process.exitCode = 1;
+    name = "help";
+  }
+  const module = await import(`./cmd/${FOLDERS[name]}/main.js`);
   /** TODO merge global flags into config */
-  const response = await commands[subcommand](...args, flags);
+  const response = await module[name](...args, flags);
   if (response.body) {
     for await (const chunk of response.body) {
       stdout.write(chunk);
diff --git a/mod.js b/mod.js
index 94fc003..bbdaf64 100644
--- a/mod.js
+++ b/mod.js
@@ -1,9 +1,5 @@
-import { env } from "node:process";
-import { backends, load } from "./backend/main.js";
-import * as commands from "./cmd/main.js";
-import { parse } from "@rfetch/lib/fspath";
-import { isOption, PREFIXES } from "@rfetch/lib/options";
-
+// The import of fetch.js also sets the global `fetch`.
+export { fetch } from "./fetch.js";
 export * from "./cmd/main.js";
 
 export { Progress } from "@rfetch/lib/progress";
@@ -36,303 +32,3 @@ export { Progress } from "@rfetch/lib/progress";
  * @property {string} Tier
  * @property {Object} Metadata
  */
-
-const globalFetch = globalThis.fetch;
-
-/**
- * A `fetch` with support for remote URL. The import of this module sets it
- * as the global `fetch`. Thus a backend on top of other remotes, for example
- * crypt, calls `fetch(":memory:/path")` and does not import rfetch.
- *
- * The syntax of the paths passed to the rfetch command are as follows.
- *
- * `/path/to/dir``
- *
- * This refers to the local file system.
- *
- * On Windows `\` may be used instead of `/` in local paths only, non local
- * paths must use `/`.
- *
- * These paths needn't start with a leading `/` - if they don't then they
- * will be relative to the current directory.
- *
- * `remote:path/to/dir`
- *
- * This refers to a directory `path/to/dir` on `remote:` as defined in the
- * config.
- *
- * `remote:/path/to/dir`
- *
- * On most backends this refers to the same directory as `remote:path/to/dir`
- * and that format should be preferred. On a very small number of remotes
- * (FTP, SFTP, ..) this will refer to a different directory. On these, paths
- * without a leading `/` will refer to your "home" directory and paths with a
- * leading `/` will refer to the root.
- *
- * `:backend:path/to/dir`
- *
- * This is an advanced form for creating remotes on the fly. `backend` should
- * be the name or prefix of a backend (the `type` in the config file) and all
- * the configuration for the backend should be provided on the command line
- * (or in environment variables).
- *
- * ## Precedence
- *
- * The various different methods of backend configuration are read in this
- * order and the first one with a value is used.
- *
- * - Parameters in connection strings, e.g. `myRemote,skip_links:`
- * - Flag values as supplied on the command line, e.g. `--skip-links`
- * - Remote specific environment vars, e.g. `RFETCH_CONFIG_MYREMOTE_SKIP_LINKS`
- * - Backend-specific environment vars, e.g. `RFETCH_LOCAL_SKIP_LINKS`
- * - Backend generic environment vars, e.g. `RFETCH_SKIP_LINKS`
- * - Config file, e.g. `skip_links = true`.
- * - Default values, e.g. `false` - these can't be changed.
- *
- * So if both `--skip-links` is supplied on the command line and an environment
- * variable `RFETCH_LOCAL_SKIP_LINKS` is set, the command line flag will take
- * preference.
- *
- * Each variable can also have the prefix `RCLONE_` of rclone, for
- * compatibility, for example `RCLONE_LOCAL_SKIP_LINKS`. In each place,
- * `RFETCH_` takes the place of `RCLONE_`.
- *
- * A header of the request with the name of a variable, for example
- * `RFETCH_CONFIG_MYREMOTE_SKIP_LINKS`, takes the place of the variable of the
- * environment. A remote can come only from variables, as in rclone:
- * `RFETCH_CONFIG_MYREMOTE_TYPE` and its options. Thus a request can give
- * all its configuration, with no config file.
- *
- * The backend gets the options of the path, the connection string and the
- * flags, in the query of its request. It gets the other options in `env`,
- * the second argument of its `fetch`, with the names of the variables of
- * rfetch, for example `RFETCH_LOCAL_SKIP_LINKS`. A backend makes the links of
- * a list from the query only, thus an option of `env` is never in a link.
- *
- * The headers `RFETCH_*` and `RCLONE_*` are only for the backends of rfetch:
- * they never go
- * out to a URL.
- *
- * For non backend configuration the order is as follows:
- *
- * - Flag values as supplied on the command line, e.g. `--stats 5s`.
- * - Environment vars, e.g. `RFETCH_STATS=5s`.
- * - Default values, e.g. `1m` - these can't be changed.
- *
- * ## Other environment variables
- *
- * @param {string | Request | URL} input
- * @param { RequestInit} [init={}]
- * @returns {Promise<Response>}
- */
-export async function fetch(input, init = {}) {
-  if (
-    typeof input !== "string" || input.startsWith("https://") ||
-    input.startsWith("http://") || input.startsWith("file://")
-  ) {
-    return globalFetch(...withoutOptions(input, init));
-  }
-
-  // The parts of the path, as rclone reads them. It throws a SyntaxError
-  // for a path that is not correct.
-  const parsed = parse(input);
-
-  const headers = new Headers(init.headers);
-  // The variables, by their names with no prefix, for example
-  // `CONFIG_R2_TYPE`: the environment of the process, then the headers of
-  // the request, which take their place. In each place, `RFETCH_` takes the
-  // place of `RCLONE_`.
-  /** @type {Record<string, string>} */
-  const variables = {};
-  const places = [
-    variablesOf(env),
-    [...headers].map(([key, value]) => [key.toUpperCase(), value]),
-  ];
-  for (const entries of places) {
-    for (const prefix of ["RCLONE_", "RFETCH_"]) {
-      for (const [key, value] of entries) {
-        if (key.startsWith(prefix) && typeof value === "string") {
-          variables[key.slice(prefix.length)] = value;
-        }
-      }
-    }
-  }
-
-  let { name } = parsed;
-
-  /**
-   * @type {Remote}
-   */
-  let config;
-
-  if (name === "") { // A local path.
-    config = { type: "local" };
-  } else if (name.startsWith(":")) { // `:type:path/to/file`
-    config = { type: name.slice(1) };
-    name = "";
-  } else {
-    // A remote of the config file, or of the variables, as rclone.
-    const type = variables[`CONFIG_${name.toUpperCase()}_TYPE`];
-    const response = await commands.config("show", name, undefined, {
-      headers: { "Accept": "application/json" },
-    }).catch(() => null);
-    if (response?.ok) {
-      config = await response.json();
-    } else if (type) {
-      config = {};
-    } else {
-      throw new Error(`Remote ${name} not found in config.`);
-    }
-    if (type) config.type = type;
-  }
-
-  const type = config.type;
-  delete config.type;
-
-  // The options that are not in the path, from the lowest precedence: the
-  // config file, then the variables.
-  const options = new Map(Object.entries(config));
-
-  // Backend generic variables, for example `RFETCH_SKIP_LINKS`. A variable
-  // of a remote or of a backend is not generic: it is not an option of each
-  // backend.
-  const specific = ["CONFIG", ...Object.keys(backends)]
-    .map((prefix) => `${prefix.toUpperCase()}_`);
-  for (const [key, value] of Object.entries(variables)) {
-    if (specific.some((prefix) => key.startsWith(prefix))) continue;
-    options.set(key.toLowerCase(), value);
-  }
-
-  // Backend-specific variables, for example `RFETCH_LOCAL_SKIP_LINKS`.
-  let prefix = `${type.toUpperCase()}_`;
-  for (const [key, value] of Object.entries(variables)) {
-    if (key.startsWith(prefix)) {
-      options.set(key.slice(prefix.length).toLowerCase(), value);
-    }
-  }
-
-  // Remote specific variables, for example `RFETCH_CONFIG_MYREMOTE_SKIP_LINKS`.
-  if (name) {
-    prefix = `CONFIG_${name.toUpperCase()}_`;
-    for (const [key, value] of Object.entries(variables)) {
-      if (key.startsWith(prefix) && key !== `${prefix}TYPE`) {
-        options.set(key.slice(prefix.length).toLowerCase(), value);
-      }
-    }
-  }
-
-  // `searchParams` may contain other flags not for the current backend.
-  const { pathname, searchParams } = new URL(parsed.path, "file:");
-
-  // The query of the backend: the flags prefixed with the backend type, then
-  // the parameters in the connection string, which take their place.
-  const params = new URLSearchParams();
-  searchParams.forEach((value, key) => {
-    if (key.startsWith(`${type}_`)) {
-      params.set(key.replace(`${type}_`, ""), value);
-    }
-  });
-  for (const [key, value] of Object.entries(parsed.config)) {
-    params.set(key, value);
-  }
-
-  // The other options go in `env`. The backend reads its query first, as a
-  // flag takes the place of a variable.
-  /** @type {Record<string, string>} */
-  const optionsEnv = {};
-  for (const [key, value] of options) {
-    optionsEnv[`RFETCH_${type.toUpperCase()}_${key.toUpperCase()}`] = value;
-  }
-  // The headers of this backend are in its options now.
-  const own = PREFIXES.map((start) => `${start}${type.toLowerCase()}_`);
-  for (const key of [...headers.keys()]) {
-    if (own.some((start) => key.startsWith(start))) headers.delete(key);
-  }
-
-  if (init.method === "TRACE") {
-    let body = `TRACE ${pathname}?${params} HTTP/1.1\r`;
-    // Reflects the request as response body, then the options in `env`.
-    for (const [name, value] of headers) {
-      body += `${name}: ${value}\r`;
-    }
-    for (const [name, value] of Object.entries(optionsEnv)) {
-      body += `${name}: ${value}\r`;
-    }
-    return new Response(body, {
-      status: 200,
-      headers: {
-        "Content-Type": "message/http",
-        "Via": `${type}/1.1 ${name}`.trim(),
-      },
-    });
-  }
-
-  if (init.body instanceof ReadableStream) {
-    // @ts-ignore: Must have `duplex` for streaming body
-    init.duplex = "half"; // Must set this for stream body.
-  }
-
-  const backend = await load(type);
-  if (!backend) {
-    throw new Error(`Backend ${type} not found.`);
-  }
-
-  const url = new URL(`${pathname}?${params}`, import.meta.url || `file:`);
-  // Creates a new request with the initial init.
-  const request = new Request(url, init);
-  // Clones that request and updates the headers.
-  return backend.fetch(
-    new Request(request, {
-      headers,
-    }),
-    optionsEnv,
-  );
-}
-
-/**
- * Gives the variables `RFETCH_*` and `RCLONE_*` of the environment of the
- * process. It reads only the names, then the values of these variables:
- * Node.js reads each value of `process.env` from the system, which takes
- * much time.
- * @param {Record<string, string | undefined>} variables
- * @returns {[string, string][]}
- */
-function variablesOf(variables) {
-  /** @type {[string, string][]} */
-  const entries = [];
-  for (const key of Object.keys(variables)) {
-    if (key.startsWith("RFETCH_") || key.startsWith("RCLONE_")) {
-      const value = variables[key];
-      if (typeof value === "string") entries.push([key, value]);
-    }
-  }
-  return entries;
-}
-
-/**
- * Removes the options of rclone from a request to a URL: they are only for
- * the backends of rfetch.
- * @param {string | Request | URL} input
- * @param {RequestInit} init
- * @returns {[string | Request | URL, RequestInit]}
- */
-function withoutOptions(input, init) {
-  /** @param {HeadersInit} [from] */
-  const clean = (from) => {
-    const headers = new Headers(from);
-    for (const key of [...headers.keys()]) {
-      if (isOption(key)) headers.delete(key);
-    }
-    return headers;
-  };
-  if (input instanceof Request) {
-    input = new Request(input, { headers: clean(input.headers) });
-  }
-  if (init.headers !== undefined) {
-    init = { ...init, headers: clean(init.headers) };
-  }
-  return [input, init];
-}
-
-// The other URLs go to the original `fetch`.
-globalThis.fetch = fetch;

From 0f6a61d18d61966db8ef4f7d1815b07ffcdee99a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sun, 18 Oct 2026 15:06:14 +0000
Subject: [PATCH 70/87] perf(lib): HTMLRewriter at its first use, in chunks of
 8 KiB in Node.js

The new module @rfetch/lib/rewriter gives htmlRewriter(). It loads
HTMLRewriter at its first use, thus a command that reads no list does
not load it. readListing, relink, the list of crypt and the index of
http use it; relink and the list of crypt are now async.

In Node.js, the HTMLRewriter of WebAssembly puts each chunk of its
output in the queue of a stream. A list in one large chunk gave a queue
of more than 16000 chunks, and a read from such a queue copies it: the
time was quadratic. Now HTMLRewriter gets the HTML in chunks of at most
8 KiB, and the small chunks become one write. The HTMLRewriter of
workerd and of Bun gets the chunks as they come: a stream of JavaScript
between two of them costs more time.

bench/node.js, before and after:
- crypt: list 1000 files: 1022 ms, 85 ms.
- crypt: lsjson of 1000 files: 627 ms, 150 ms.
- lib: readListing of 10000 entries: 2990 ms, 349 ms.

In workerd, the times do not change: crypt lsjson of 1000 files is 88
to 98 ms before, and 96 to 102 ms after.
---
 CONTRIBUTING.md            |   6 ++
 backend/crypt/main.js      |  10 +--
 backend/crypt/package.json |   1 -
 backend/http/main.js       |   5 +-
 backend/http/package.json  |   3 +-
 lib/listing.js             |  12 ++--
 lib/package.json           |   1 +
 lib/rewriter.js            | 139 +++++++++++++++++++++++++++++++++++++
 lib/rewriter_test.js       | 109 +++++++++++++++++++++++++++++
 package-lock.json          |   4 +-
 10 files changed, 272 insertions(+), 18 deletions(-)
 create mode 100644 lib/rewriter.js
 create mode 100644 lib/rewriter_test.js

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index e355ddf..0f3badd 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -197,6 +197,12 @@ modification time.
 `renderListing` of `@rfetch/lib/listing` writes such a list from the entries of
 a folder, and `readListing` reads it.
 
+To read or change a list with HTMLRewriter, use `htmlRewriter` of
+`@rfetch/lib/rewriter`, not `@sntran/html-rewriter`. It loads HTMLRewriter at
+its first use, because a command that reads no list does not need it. In
+Node.js, it gives the HTML to HTMLRewriter in chunks of at most 8 KiB: else a
+list in one large chunk takes a quadratic time. `lib/rewriter.js` tells why.
+
 ## Commands
 
 Each command is a function of a module in `cmd`, for example `cat` of
diff --git a/backend/crypt/main.js b/backend/crypt/main.js
index 17dccb8..e471624 100644
--- a/backend/crypt/main.js
+++ b/backend/crypt/main.js
@@ -94,7 +94,6 @@
  */
 
 import { scrypt } from "node:crypto";
-import { HTMLRewriter } from "@sntran/html-rewriter";
 import { formatBytes } from "@rfetch/lib/format";
 import { mimeType } from "@rfetch/lib/mime";
 import { optionsOf, remoteHeaders } from "@rfetch/lib/options";
@@ -107,6 +106,7 @@ import {
 } from "@rfetch/lib/range";
 import { sized } from "@rfetch/lib/sized";
 import { reveal } from "@rfetch/lib/obscure";
+import { htmlRewriter } from "@rfetch/lib/rewriter";
 import PathCipher from "./PathCipher.js";
 import {
   decryptedSize,
@@ -211,7 +211,7 @@ async function crypt(request, env = {}) {
       return response;
     }
     if (isDirectory) {
-      return listing(response, cipher, searchParams);
+      return await listing(response, cipher, searchParams);
     }
 
     const result = new Headers({
@@ -419,9 +419,9 @@ async function getRange(target, headers, cipher, path, header) {
  * @param {Response} response The list of the encrypted folder.
  * @param {{ names: import("./PathCipher.js").PathCipher }} cipher
  * @param {URLSearchParams} searchParams
- * @returns {Response}
+ * @returns {Promise<Response>}
  */
-function listing(response, { names }, searchParams) {
+async function listing(response, { names }, searchParams) {
   const query = new URLSearchParams(searchParams);
   for (const name of SECRETS) query.delete(name);
   const suffix = query.size ? `?${query}` : "";
@@ -432,7 +432,7 @@ function listing(response, { names }, searchParams) {
   /** True when the link of the current row is a file that decrypts. */
   let isFile = false;
 
-  const rewriter = new HTMLRewriter()
+  const rewriter = (await htmlRewriter())
     .on("tr", {
       element() {
         isFile = false;
diff --git a/backend/crypt/package.json b/backend/crypt/package.json
index cb3a738..dba2889 100644
--- a/backend/crypt/package.json
+++ b/backend/crypt/package.json
@@ -27,7 +27,6 @@
   "license": "ISC",
   "dependencies": {
     "@rfetch/lib": "^0.1.0",
-    "@sntran/html-rewriter": "^0.2.0",
     "base32-decode": "^1.0.0",
     "base32-encode": "^2.0.0"
   },
diff --git a/backend/http/main.js b/backend/http/main.js
index 531125d..1795a69 100644
--- a/backend/http/main.js
+++ b/backend/http/main.js
@@ -24,11 +24,11 @@
  * To get only one file, use [copyurl](../../cmd/copyurl/main.js).
  */
 
-import { HTMLRewriter } from "@sntran/html-rewriter";
 import { parseList } from "./list.js";
 import { childOf, renderListing } from "@rfetch/lib/listing";
 import { mimeType } from "@rfetch/lib/mime";
 import { optionsOf } from "@rfetch/lib/options";
+import { htmlRewriter } from "@rfetch/lib/rewriter";
 import { decodePath, encodePath } from "@rfetch/lib/path";
 
 export const options = {
@@ -257,7 +257,8 @@ async function readIndex(response, base) {
   /** @type {import("@rfetch/lib/listing").Entry | null} */
   let current = null;
 
-  await new HTMLRewriter()
+  const rewriter = await htmlRewriter();
+  await rewriter
     .on("tr", {
       element(element) {
         inRow = true;
diff --git a/backend/http/package.json b/backend/http/package.json
index ac6ebd4..c9643c8 100644
--- a/backend/http/package.json
+++ b/backend/http/package.json
@@ -20,8 +20,7 @@
   "author": "Trần Nguyễn Sơn",
   "license": "ISC",
   "dependencies": {
-    "@rfetch/lib": "^0.1.0",
-    "@sntran/html-rewriter": "^0.2.0"
+    "@rfetch/lib": "^0.1.0"
   },
   "devDependencies": {
     "@rfetch/chunker": "^0.1.0",
diff --git a/lib/listing.js b/lib/listing.js
index 35fe5ba..9a3cd3f 100644
--- a/lib/listing.js
+++ b/lib/listing.js
@@ -5,9 +5,9 @@
  * value>` is the size in bytes, and `<time datetime>` is the time of the last
  * change.
  */
-import { HTMLRewriter } from "@sntran/html-rewriter";
 import { formatBytes } from "./format.js";
 import { escapeHTML } from "./html.js";
+import { htmlRewriter } from "./rewriter.js";
 
 /**
  * An entry of the list of a folder, with the names of `rclone lsjson`.
@@ -39,7 +39,8 @@ export async function readListing(response, base) {
    */
   let entry = null;
 
-  await new HTMLRewriter()
+  const rewriter = await htmlRewriter();
+  await rewriter
     .on("tr", {
       element() {
         entry = null;
@@ -152,13 +153,14 @@ export function renderListing(entries, { query = "" } = {}) {
  * options, which are not the options of a request to this backend.
  * @param {Response} response The list of the other backend.
  * @param {string} query The query, with no secret option.
- * @returns {Response}
+ * @returns {Promise<Response>}
  */
-export function relink(response, query) {
+export async function relink(response, query) {
   const suffix = query ? `?${query}` : "";
   const headers = new Headers(response.headers);
   headers.delete("Content-Length");
-  const rewritten = new HTMLRewriter()
+  const rewriter = await htmlRewriter();
+  const rewritten = rewriter
     .on("tr a[href]", {
       element(element) {
         const href = element.getAttribute("href");
diff --git a/lib/package.json b/lib/package.json
index c6d5bad..baa6929 100644
--- a/lib/package.json
+++ b/lib/package.json
@@ -15,6 +15,7 @@
     "./path": "./path.js",
     "./progress": "./progress.js",
     "./range": "./range.js",
+    "./rewriter": "./rewriter.js",
     "./size": "./size.js",
     "./sized": "./sized.js",
     "./time": "./time.js",
diff --git a/lib/rewriter.js b/lib/rewriter.js
new file mode 100644
index 0000000..bd683a3
--- /dev/null
+++ b/lib/rewriter.js
@@ -0,0 +1,139 @@
+/**
+ * HTMLRewriter for the lists of folders:
+ *
+ * ```js
+ * const rewriter = await htmlRewriter();
+ * rewriter.on("tr a[href]", { element(element) {} }).transform(response);
+ * ```
+ */
+
+/**
+ * The largest chunk of HTML for one write to HTMLRewriter.
+ *
+ * In Node.js, the HTMLRewriter of WebAssembly puts each chunk of its output in
+ * the queue of a stream, and the output of one write can be thousands of
+ * chunks. A read
+ * from a queue of more than about 16000 chunks copies the queue, thus a list
+ * in one large chunk takes a quadratic time. A write of at most 8 KiB gives
+ * at most about 8192 chunks of output, which is less than that limit:
+ * HTMLRewriter starts the next write when the reader has read the queue.
+ *
+ * Each chunk also costs much time in the streams of Node.js, thus the small
+ * chunks, for example the output of another HTMLRewriter, become one write.
+ *
+ * The HTMLRewriter of workerd and of Bun is a part of the runtime, with no
+ * such queue: it gets the chunks as they come, because a stream of
+ * JavaScript between two of them costs more time.
+ */
+export const CHUNK = 8 * 1024;
+
+/**
+ * Gives the bytes of a stream in chunks of at most `CHUNK` bytes. It cuts a
+ * large chunk, and joins the small chunks that come one after the other.
+ * @param {ReadableStream<Uint8Array>} stream
+ * @returns {ReadableStream<Uint8Array>}
+ */
+export function inChunks(stream) {
+  /** The small chunks that are not written yet. @type {Uint8Array[]} */
+  let held = [];
+  let size = 0;
+  /** @param {TransformStreamDefaultController<Uint8Array>} controller */
+  const write = (controller) => {
+    if (size > 0) {
+      let joined = held[0];
+      if (held.length > 1) {
+        joined = new Uint8Array(size);
+        let offset = 0;
+        for (const chunk of held) {
+          joined.set(chunk, offset);
+          offset += chunk.length;
+        }
+      }
+      controller.enqueue(joined);
+    }
+    held = [];
+    size = 0;
+  };
+  return stream.pipeThrough(
+    new TransformStream({
+      transform(chunk, controller) {
+        if (chunk.length === 0) return;
+        if (size + chunk.length <= CHUNK) {
+          held.push(chunk);
+          size += chunk.length;
+          return;
+        }
+        write(controller);
+        let start = 0;
+        for (; chunk.length - start > CHUNK; start += CHUNK) {
+          controller.enqueue(chunk.subarray(start, start + CHUNK));
+        }
+        held.push(chunk.subarray(start));
+        size = chunk.length - start;
+      },
+      flush: write,
+    }),
+  );
+}
+
+/**
+ * The class HTMLRewriter, at its first use: in Node.js, its load takes much
+ * time, and a command that reads no list does not need it.
+ * @type {Promise<typeof import("@sntran/html-rewriter").HTMLRewriter> | undefined}
+ */
+let loaded;
+
+/** True when HTMLRewriter is the HTMLRewriter of the runtime. */
+let native = false;
+
+/**
+ * An HTMLRewriter. The HTMLRewriter of WebAssembly gets the HTML in chunks of
+ * at most `CHUNK` bytes.
+ */
+class Rewriter {
+  /** @type {import("@sntran/html-rewriter").HTMLRewriter} */
+  #rewriter;
+
+  /** @param {import("@sntran/html-rewriter").HTMLRewriter} rewriter */
+  constructor(rewriter) {
+    this.#rewriter = rewriter;
+  }
+
+  /**
+   * @param {string} selector
+   * @param {import("@sntran/html-rewriter").ElementHandlers} handlers
+   * @returns {this}
+   */
+  on(selector, handlers) {
+    this.#rewriter.on(selector, handlers);
+    return this;
+  }
+
+  /**
+   * @param {Response} response
+   * @returns {Response}
+   */
+  transform(response) {
+    if (native || !response.body) return this.#rewriter.transform(response);
+    return this.#rewriter.transform(
+      new Response(inChunks(response.body), {
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers,
+      }),
+    );
+  }
+}
+
+/**
+ * Makes a new HTMLRewriter.
+ * @returns {Promise<Rewriter>}
+ */
+export async function htmlRewriter() {
+  loaded ??= import("@sntran/html-rewriter").then((module) => {
+    native = module.HTMLRewriter === globalThis.HTMLRewriter;
+    return module.HTMLRewriter;
+  });
+  const HTMLRewriter = await loaded;
+  return new Rewriter(new HTMLRewriter());
+}
diff --git a/lib/rewriter_test.js b/lib/rewriter_test.js
new file mode 100644
index 0000000..e09d6db
--- /dev/null
+++ b/lib/rewriter_test.js
@@ -0,0 +1,109 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import fc from "fast-check";
+
+import { CHUNK, htmlRewriter, inChunks } from "./rewriter.js";
+import { readListing, renderListing } from "./listing.js";
+
+/** @param {Uint8Array[]} chunks */
+function streamOf(chunks) {
+  return new ReadableStream({
+    start(controller) {
+      for (const chunk of chunks) controller.enqueue(chunk);
+      controller.close();
+    },
+  });
+}
+
+/** @param {ReadableStream<Uint8Array>} stream */
+async function chunksOf(stream) {
+  const chunks = [];
+  for await (const chunk of stream) chunks.push(chunk);
+  return chunks;
+}
+
+/** @param {Uint8Array[]} chunks */
+function join(chunks) {
+  return Buffer.concat(chunks.map((chunk) => Buffer.from(chunk)));
+}
+
+test("inChunks gives the same bytes in chunks of at most CHUNK bytes", async () => {
+  const sizes = fc.oneof(
+    fc.integer({ min: 0, max: 100 }),
+    fc.integer({ min: CHUNK - 100, max: CHUNK + 100 }),
+    fc.integer({ min: 0, max: 4 * CHUNK }),
+  );
+  await fc.assert(
+    fc.asyncProperty(fc.array(sizes, { maxLength: 30 }), async (lengths) => {
+      let byte = 0;
+      const input = lengths.map((length) =>
+        Uint8Array.from({ length }, () => byte++ % 251)
+      );
+      const output = await chunksOf(inChunks(streamOf(input)));
+      assert.deepEqual(join(output), join(input));
+      for (const [index, chunk] of output.entries()) {
+        assert.ok(chunk.length > 0, "an empty chunk");
+        assert.ok(chunk.length <= CHUNK, `a chunk of ${chunk.length} bytes`);
+        // Two chunks one after the other that fit in one chunk are one.
+        const next = output[index + 1];
+        if (next) assert.ok(chunk.length + next.length > CHUNK);
+      }
+    }),
+  );
+});
+
+test("htmlRewriter gives the output of each cut of the HTML", async () => {
+  const html = new TextEncoder().encode(
+    `<table>${"<tr><td><a href='a é.txt'>a é</a></td></tr>".repeat(500)}`,
+  );
+  /** @param {Uint8Array[]} chunks */
+  const transform = async (chunks) => {
+    const rewriter = await htmlRewriter();
+    const response = rewriter
+      .on("a[href]", {
+        element(element) {
+          element.setAttribute("href", "b.txt");
+        },
+      })
+      .transform(new Response(streamOf(chunks)));
+    return await response.text();
+  };
+  const expected = (await transform([html])).replaceAll("a é.txt", "b.txt");
+  assert.ok(!expected.includes("a é.txt"));
+  await fc.assert(
+    fc.asyncProperty(
+      fc.uniqueArray(fc.integer({ min: 1, max: html.length - 1 }), {
+        maxLength: 40,
+      }),
+      async (cuts) => {
+        const points = [0, ...cuts.toSorted((a, b) => a - b), html.length];
+        const chunks = points.slice(1).map((end, index) =>
+          html.subarray(points[index], end)
+        );
+        assert.equal(await transform(chunks), expected);
+      },
+    ),
+    { numRuns: 20 },
+  );
+});
+
+test("readListing reads a list of many chunks of CHUNK bytes, in one chunk", async () => {
+  const entries = Array.from({ length: 2000 }, (_, index) => ({
+    Name: `file ${index}.txt`,
+    IsDir: false,
+    Size: index,
+    MimeType: "text/plain",
+    ModTime: "2026-10-18T12:00:00.000Z",
+  }));
+  const html = await new Response(renderListing(entries)).arrayBuffer();
+  assert.ok(html.byteLength > 10 * CHUNK);
+  const list = await readListing(
+    new Response(new Uint8Array(html)),
+    new URL("http://remote/folder/"),
+  );
+  assert.equal(list.length, entries.length);
+  assert.deepEqual(
+    list.toSorted((a, b) => a.Size - b.Size),
+    entries,
+  );
+});
diff --git a/package-lock.json b/package-lock.json
index 3978cde..c7aa548 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -63,7 +63,6 @@
       "license": "ISC",
       "dependencies": {
         "@rfetch/lib": "^0.1.0",
-        "@sntran/html-rewriter": "^0.2.0",
         "base32-decode": "^1.0.0",
         "base32-encode": "^2.0.0"
       },
@@ -91,8 +90,7 @@
       "version": "0.1.0",
       "license": "ISC",
       "dependencies": {
-        "@rfetch/lib": "^0.1.0",
-        "@sntran/html-rewriter": "^0.2.0"
+        "@rfetch/lib": "^0.1.0"
       },
       "devDependencies": {
         "@rfetch/chunker": "^0.1.0",

From d5be83ecba4ea7ce4ee95dff1df781e1e09c4ac5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sun, 18 Oct 2026 17:47:15 +0000
Subject: [PATCH 71/87] test(bench): the commands of rfetch on each runtime
 against rclone

node bench/rclone.js [RUNTIME...] runs rfetch on each runtime that the
arguments name, for example node, deno and bun, and rclone. Each
runtime must give the same data and the same lists as rclone. The output
is a table in Markdown: one row for each case, and one column for each
runtime and for rclone.

The median of 5 runs, in ms, on this code (rclone 1.75.1):
- start: node 22 164, node 24 140, node 26 124, deno 110, bun 43,
  rclone 47.
- local lsjson --recursive, 1000 files: node 22 286, node 24 270,
  node 26 252, deno 281, bun 68, rclone 52.
- crypt cat 64 MiB: node 22 449, node 24 474, node 26 488, deno 510,
  bun 448, rclone 216.
---
 CONTRIBUTING.md |  12 ++---
 bench/rclone.js | 114 +++++++++++++++++++++++++++++++-----------------
 2 files changed, 82 insertions(+), 44 deletions(-)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 0f3badd..ff8d95e 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -319,11 +319,13 @@ in Node.js and in workerd, the runtime of Cloudflare Workers:
   times of workerd change much from one run to the next: run it three times, and
   use the median.
 
-- `node bench/rclone.js` runs the same commands with rfetch and with rclone,
-  which must be in the PATH or in the variable `RCLONE`: cat, rcat and
-  `lsjson --recursive` on local files, crypt and chunker. First it makes sure
-  that the two tools give the same data and the same lists. The time is the time
-  of the whole process, with the start of Node.js or of rclone.
+- `node bench/rclone.js [RUNTIME...]` runs the same commands with rfetch and
+  with rclone, which must be in the PATH or in the variable `RCLONE`: cat, rcat
+  and `lsjson --recursive` on local files, crypt and chunker. Each RUNTIME is a
+  program of Node.js, Deno or Bun that runs rfetch, for example
+  `node bench/rclone.js node deno bun`. First it makes sure that each runtime
+  gives the same data and the same lists as rclone. The time is the time of the
+  whole process, with the start of the runtime or of rclone.
 
 Measure before and after a change for speed, and write the two times in the
 message of the commit.
diff --git a/bench/rclone.js b/bench/rclone.js
index 7142f9a..e5ace63 100644
--- a/bench/rclone.js
+++ b/bench/rclone.js
@@ -1,15 +1,18 @@
 /**
  * Compares the commands of rfetch with the commands of rclone:
- * `node bench/rclone.js`. rclone must be in the PATH, or in the variable
- * RCLONE.
+ * `node bench/rclone.js [RUNTIME...]`. rclone must be in the PATH, or in the
+ * variable RCLONE.
+ *
+ * Each RUNTIME runs rfetch: a program of Node.js, Deno or Bun, for example
+ * `node bench/rclone.js node deno bun /opt/node26/bin/node`. With no
+ * RUNTIME, the Node.js of this script runs rfetch.
  *
  * Each case runs the same command of each tool as a new process, with the
  * same remotes in the variables RCLONE_CONFIG_*, on the same files in a
- * temporary folder, which is the current folder of each process: the local
- * backend of rfetch reads only the files in its current folder. The time is
- * the time of the whole process, as a user
- * sees it: the start of Node.js or of rclone is in it. The first case, a
- * list of an empty folder, shows the time of the start.
+ * temporary folder, which is the current folder of each process. The time is
+ * the time of the whole process, as a user sees it: the start of the runtime
+ * or of rclone is in it. The first case, a list of an empty folder, shows the
+ * time of the start.
  */
 import { execFileSync, spawnSync } from "node:child_process";
 import { createHash, randomBytes } from "node:crypto";
@@ -23,7 +26,7 @@ import {
   writeFileSync,
 } from "node:fs";
 import { tmpdir } from "node:os";
-import { join } from "node:path";
+import { basename, join } from "node:path";
 import { fileURLToPath } from "node:url";
 
 const RCLONE = process.env.RCLONE || "rclone";
@@ -50,11 +53,41 @@ const env = {
   RCLONE_CONFIG_CHUNKS_CHUNK_SIZE: "8M",
 };
 
-/** The command of a tool, as a program and its arguments. */
-const tools = {
-  rfetch: (args) => [process.execPath, [RFETCH, ...args]],
-  rclone: (args) => [RCLONE, args],
-};
+/**
+ * The command of a runtime that runs rfetch, as a program and its arguments.
+ * @param {string} program
+ * @returns {(args: string[]) => [string, string[]]}
+ */
+function runtime(program) {
+  if (basename(program).startsWith("deno")) {
+    return (args) => [program, ["run", "-A", RFETCH, ...args]];
+  }
+  return (args) => [program, [RFETCH, ...args]];
+}
+
+/** The name of a runtime, with its version, for example `node 22.22.0`. */
+function nameOf(program) {
+  const version = execFileSync(program, ["--version"], { encoding: "utf8" })
+    .match(/\d+\.\d+\.\d+/)?.[0];
+  const kind = basename(program).startsWith("deno")
+    ? "deno"
+    : basename(program).startsWith("bun")
+    ? "bun"
+    : "node";
+  return `${kind} ${version}`;
+}
+
+/**
+ * The command of each tool, as a program and its arguments: the runtimes of
+ * rfetch, then rclone.
+ * @type {Record<string, (args: string[]) => [string, string[]]>}
+ */
+const tools = {};
+const runtimes = process.argv.slice(2);
+for (const program of runtimes.length ? runtimes : [process.execPath]) {
+  tools[`rfetch on ${nameOf(program)}`] = runtime(program);
+}
+tools.rclone = (args) => [RCLONE, args];
 
 /**
  * Runs a command of a tool, and gives its time and the hash of its output.
@@ -84,11 +117,10 @@ function run(tool, args, input) {
 }
 
 /**
- * The lines of `lsjson` with no times, in order, for a compare. The size of
- * a folder is not in a line: rclone gives the size of a local folder, and
- * rfetch gives -1.
+ * The lines of `lsjson`, in order, for a compare. The size of a folder is not
+ * in a line: rclone gives the size of a local folder, and rfetch gives -1.
  */
-function paths(tool, args) {
+function lines(tool, args) {
   run(tool, args);
   return JSON.parse(readFileSync(join(root, "output"), "utf8"))
     .map(({ Path, Size, IsDir }) => `${Path} ${IsDir ? "folder" : Size}`)
@@ -124,7 +156,10 @@ const cases = {
     "tree",
   ],
   "crypt: cat 64 MiB": () => ["cat", "secret:big.bin"],
-  "crypt: rcat 64 MiB": (tool) => [["rcat", `secret:${tool}/put.bin`], big],
+  "crypt: rcat 64 MiB": (tool) => [
+    ["rcat", `secret:${tool.replaceAll(" ", "-")}/put.bin`],
+    big,
+  ],
   "crypt: lsjson --recursive, 1000 files": () => [
     "lsjson",
     "--recursive",
@@ -132,13 +167,13 @@ const cases = {
   ],
   "chunker: cat 64 MiB in chunks of 8 MiB": () => ["cat", "chunks:big.bin"],
   "chunker: rcat 64 MiB in chunks of 8 MiB": (tool) => [
-    ["rcat", `chunks:${tool}/put.bin`],
+    ["rcat", `chunks:${tool.replaceAll(" ", "-")}/put.bin`],
     big,
   ],
 };
 
 try {
-  // The two tools give the same data and the same lists.
+  // Each tool gives the same data and the same lists as rclone.
   const hash = createHash("sha256").update(readFileSync(big)).digest("hex");
   for (const tool of Object.keys(tools)) {
     for (const location of ["secret:big.bin", "chunks:big.bin"]) {
@@ -146,41 +181,42 @@ try {
         throw new Error(`${tool} cat ${location}: not the same data`);
       }
     }
+    const folder = tool.replaceAll(" ", "-");
     for (const location of ["secret", "chunks"]) {
-      run(tool, ["rcat", `${location}:${tool}/check.bin`], big);
+      run(tool, ["rcat", `${location}:${folder}/check.bin`], big);
       if (
-        run("rclone", ["cat", `${location}:${tool}/check.bin`]).hash !== hash
+        run("rclone", ["cat", `${location}:${folder}/check.bin`]).hash !== hash
       ) {
         throw new Error(`${tool} rcat ${location}: rclone reads other data`);
       }
     }
-  }
-  for (const location of ["tree", "secret:tree"]) {
-    const args = ["lsjson", "--recursive", location];
-    if (`${paths("rfetch", args)}` !== `${paths("rclone", args)}`) {
-      throw new Error(`lsjson ${location}: not the same list`);
+    for (const location of ["tree", "secret:tree"]) {
+      const args = ["lsjson", "--recursive", location];
+      const [ours, theirs] = [lines(tool, args), lines("rclone", args)];
+      if (`${ours}` !== `${theirs}`) {
+        const line = ours.find((line, index) => line !== theirs[index]);
+        throw new Error(
+          `${tool} lsjson ${location}: not the same list, at "${line}"`,
+        );
+      }
     }
   }
 
-  console.log(
-    `rfetch (Node.js ${process.versions.node}) and rclone, median of ${RUNS} runs`,
-  );
+  console.log(`The median of ${RUNS} runs, in ms:\n`);
+  const names = Object.keys(tools);
+  console.log(`| Case | ${names.join(" | ")} |`);
+  console.log(`|---|${names.map(() => "---:").join("|")}|`);
   for (const [name, make] of Object.entries(cases)) {
-    const times = {};
-    for (const tool of Object.keys(tools)) {
+    const times = [];
+    for (const tool of names) {
       const made = make(tool);
       const [args, input] = Array.isArray(made[0]) ? made : [made];
       run(tool, args, input);
       const list = [];
       for (let i = 0; i < RUNS; i++) list.push(run(tool, args, input).time);
-      times[tool] = list.sort((a, b) => a - b)[Math.floor(RUNS / 2)];
+      times.push(list.sort((a, b) => a - b)[Math.floor(RUNS / 2)]);
     }
-    const ratio = (times.rfetch / times.rclone).toFixed(1);
-    console.log(
-      `  ${name}: rfetch ${times.rfetch.toFixed(0)} ms, rclone ${
-        times.rclone.toFixed(0)
-      } ms (${ratio}x)`,
-    );
+    console.log(`| ${name} | ${times.map((t) => t.toFixed(0)).join(" | ")} |`);
   }
 } finally {
   rmSync(root, { recursive: true, force: true });

From d1133f0c3811147a1f62758a5ad2b82bfb82a0bc Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sun, 18 Oct 2026 17:47:26 +0000
Subject: [PATCH 72/87] perf(lib): read and write the lists with no
 HTMLRewriter

The new scanTags of @rfetch/lib/html reads the tags of an HTML document
in JavaScript, as the tokenizer of the HTML standard: the attributes,
the comments, and the text of script, style, textarea and title, which
is not markup. readListing, and the index of the http backend, read the
lists with it. The crypt list and relink of alias read the list of the
other backend with readListing, change the entries, and write the list
with renderListing. Thus rfetch does not use HTMLRewriter, and
lib/rewriter.js goes away. @sntran/html-rewriter stays only as a
devDependency of lib: a property test makes sure that readListing gives
the entries of HTMLRewriter for each list of renderListing.

An attribute value now gets the decode of the basic and the numeric
character references, as the standard tells. HTMLRewriter gives the raw
value. A list of rfetch has no reference in its links.

bench/node.js, before and after:
- lib: readListing of 10000 entries: 349 ms, 62 ms.
- crypt: list 1000 files: 85 ms, 31 ms.
- crypt: lsjson of 1000 files: 150 ms, 36 ms.

workerd (wrangler dev, 3 runs), before and after:
- lib: readListing of 10000 entries: 297 to 379 ms, 49 to 64 ms.
- crypt: list 1000 files: 41 to 60 ms, 24 to 29 ms.
- crypt: lsjson of 1000 files: 88 to 102 ms, 34 to 39 ms.

The command line in Node.js 22, median of 21 runs, before and after:
- lsjson of an empty folder: 140 ms, 116 ms.
- lsjson --recursive of 1000 local files: 333 ms, 256 ms.
---
 CONTRIBUTING.md       |  11 +-
 backend/crypt/main.js |  96 ++++++----------
 backend/http/main.js  |  70 ++++++-----
 lib/html.js           | 261 ++++++++++++++++++++++++++++++++++++++++++
 lib/html_test.js      | 105 ++++++++++++++++-
 lib/listing.js        |  95 ++++++++-------
 lib/listing_test.js   |  94 +++++++++++++++
 lib/package.json      |   5 +-
 lib/rewriter.js       | 139 ----------------------
 lib/rewriter_test.js  | 109 ------------------
 package-lock.json     |   9 +-
 package.json          |   1 -
 12 files changed, 581 insertions(+), 414 deletions(-)
 delete mode 100644 lib/rewriter.js
 delete mode 100644 lib/rewriter_test.js

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index ff8d95e..94d38ba 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -197,11 +197,12 @@ modification time.
 `renderListing` of `@rfetch/lib/listing` writes such a list from the entries of
 a folder, and `readListing` reads it.
 
-To read or change a list with HTMLRewriter, use `htmlRewriter` of
-`@rfetch/lib/rewriter`, not `@sntran/html-rewriter`. It loads HTMLRewriter at
-its first use, because a command that reads no list does not need it. In
-Node.js, it gives the HTML to HTMLRewriter in chunks of at most 8 KiB: else a
-list in one large chunk takes a quadratic time. `lib/rewriter.js` tells why.
+A backend on top of another backend reads the list of the other backend with
+`readListing`, changes the entries, and writes the list with `renderListing`,
+for example the names of `crypt`. `lsjson` reads each list with `readListing`.
+The read is `scanTags` of `@rfetch/lib/html`, in JavaScript: do not use
+HTMLRewriter. In Node.js and in Deno, HTMLRewriter is WebAssembly, and its load
+and each element in it cost much time.
 
 ## Commands
 
diff --git a/backend/crypt/main.js b/backend/crypt/main.js
index e471624..1baaca4 100644
--- a/backend/crypt/main.js
+++ b/backend/crypt/main.js
@@ -94,7 +94,7 @@
  */
 
 import { scrypt } from "node:crypto";
-import { formatBytes } from "@rfetch/lib/format";
+import { readListing, renderListing } from "@rfetch/lib/listing";
 import { mimeType } from "@rfetch/lib/mime";
 import { optionsOf, remoteHeaders } from "@rfetch/lib/options";
 import { decodePath } from "@rfetch/lib/path";
@@ -106,7 +106,6 @@ import {
 } from "@rfetch/lib/range";
 import { sized } from "@rfetch/lib/sized";
 import { reveal } from "@rfetch/lib/obscure";
-import { htmlRewriter } from "@rfetch/lib/rewriter";
 import PathCipher from "./PathCipher.js";
 import {
   decryptedSize,
@@ -414,7 +413,7 @@ async function getRange(target, headers, cipher, path, header) {
  * files, from the list of the encrypted folder on the remote.
  *
  * Each link gets the query of the request with no secret option, and no
- * option of the remote. A name that does not decrypt is not a link, as
+ * option of the remote. A name that does not decrypt is not in the list, as
  * rclone skips such a name.
  * @param {Response} response The list of the encrypted folder.
  * @param {{ names: import("./PathCipher.js").PathCipher }} cipher
@@ -422,73 +421,42 @@ async function getRange(target, headers, cipher, path, header) {
  * @returns {Promise<Response>}
  */
 async function listing(response, { names }, searchParams) {
+  const headers = new Headers(response.headers);
+  headers.delete("Content-Length");
+  headers.set("Content-Type", "text/html;charset=utf-8");
+  // The answer to HEAD has no body.
+  if (response.body === null) {
+    return new Response(null, { status: response.status, headers });
+  }
+
   const query = new URLSearchParams(searchParams);
   for (const name of SECRETS) query.delete(name);
-  const suffix = query.size ? `?${query}` : "";
 
   // The links of the list are relative to the encrypted folder.
-  const base = new URL("http://remote/folder/");
-
-  /** True when the link of the current row is a file that decrypts. */
-  let isFile = false;
-
-  const rewriter = (await htmlRewriter())
-    .on("tr", {
-      element() {
-        isFile = false;
-      },
-    })
-    .on("tr a[href]", {
-      element(element) {
-        const href = new URL(element.getAttribute("href"), base);
-        if (href.origin !== base.origin) {
-          element.removeAttribute("href");
-          return;
-        }
-        if (!href.pathname.startsWith(base.pathname)) {
-          // The parent folder.
-          element.setAttribute("href", `../${suffix}`);
-          return;
-        }
-
-        const rest = href.pathname.slice(base.pathname.length);
-        const isDirectory = rest.endsWith("/");
-        let name;
-        try {
-          const encrypted = decodeURIComponent(
-            isDirectory ? rest.slice(0, -1) : rest,
-          );
-          if (encrypted === "" || encrypted.includes("/")) throw encrypted;
-          name = names.decryptName(encrypted);
-        } catch {
-          element.removeAttribute("href");
-          element.removeAttribute("type");
-          return;
-        }
-
-        isFile = !isDirectory;
-        element.setAttribute(
-          "href",
-          `${encodeURIComponent(name)}${isDirectory ? "/" : ""}${suffix}`,
-        );
-        element.setAttribute("type", isDirectory ? "" : mimeType(name));
-        // The text of an element is HTML-escaped.
-        element.setInnerContent(isDirectory ? `${name}/` : name);
-      },
-    })
-    .on("tr data[value]", {
-      element(element) {
-        const size = isFile ? sizeOf(element.getAttribute("value")) : -1;
-        element.setAttribute("value", `${size}`);
-        element.setInnerContent(
-          size >= 0 ? formatBytes(size, { locale: true }) : "—",
-        );
-      },
+  const encrypted = await readListing(
+    response,
+    new URL("http://remote/folder/"),
+  );
+  /** @type {import("@rfetch/lib/listing").Entry[]} */
+  const entries = [];
+  for (const { Name, IsDir, Size, ModTime } of encrypted) {
+    let name;
+    try {
+      if (Name.includes("/")) continue;
+      name = names.decryptName(Name);
+    } catch {
+      continue;
+    }
+    entries.push({
+      Name: name,
+      IsDir,
+      Size: IsDir ? -1 : sizeOf(Size < 0 ? null : String(Size)),
+      MimeType: IsDir ? "" : mimeType(name),
+      ModTime,
     });
+  }
 
-  const headers = new Headers(response.headers);
-  headers.delete("Content-Length");
-  return new Response(rewriter.transform(response).body, {
+  return new Response(renderListing(entries, { query: `${query}` }), {
     status: response.status,
     headers,
   });
diff --git a/backend/http/main.js b/backend/http/main.js
index 1795a69..9b6b664 100644
--- a/backend/http/main.js
+++ b/backend/http/main.js
@@ -28,7 +28,7 @@ import { parseList } from "./list.js";
 import { childOf, renderListing } from "@rfetch/lib/listing";
 import { mimeType } from "@rfetch/lib/mime";
 import { optionsOf } from "@rfetch/lib/options";
-import { htmlRewriter } from "@rfetch/lib/rewriter";
+import { scanTags } from "@rfetch/lib/html";
 import { decodePath, encodePath } from "@rfetch/lib/path";
 
 export const options = {
@@ -253,55 +253,51 @@ async function readIndex(response, base) {
   /** @type {import("@rfetch/lib/listing").Entry[]} */
   const entries = [];
   const seen = new Set();
-  let inRow = false;
+  /** The number of open `tr` elements. */
+  let rows = 0;
   /** @type {import("@rfetch/lib/listing").Entry | null} */
   let current = null;
 
-  const rewriter = await htmlRewriter();
-  await rewriter
-    .on("tr", {
-      element(element) {
-        inRow = true;
+  scanTags(await response.text(), {
+    start(name, attributes) {
+      if (name === "tr") {
+        rows++;
         current = null;
-        element.onEndTag(() => {
-          inRow = false;
-          current = null;
-        });
-      },
-    })
-    .on("a[href]", {
-      element(element) {
-        const name = childOf(element.getAttribute("href"), base);
-        if (name === null || seen.has(name)) return;
-        seen.add(name);
-        const isDir = name.endsWith("/");
+      } else if (name === "a") {
+        const href = attributes.get("href");
+        if (href === undefined) return;
+        const child = childOf(href, base);
+        if (child === null || seen.has(child)) return;
+        seen.add(child);
+        const isDir = child.endsWith("/");
         const entry = {
-          Name: isDir ? name.slice(0, -1) : name,
+          Name: isDir ? child.slice(0, -1) : child,
           IsDir: isDir,
           Size: -1,
-          MimeType: isDir ? "" : element.getAttribute("type") || "",
+          MimeType: isDir ? "" : attributes.get("type") || "",
           ModTime: "",
         };
         entries.push(entry);
-        if (inRow) current = entry;
-      },
-    })
-    .on("tr data[value]", {
-      element(element) {
-        const value = element.getAttribute("value");
-        if (current && /^\d+$/.test(value)) current.Size = Number(value);
-      },
-    })
-    .on("tr time[datetime]", {
-      element(element) {
-        const time = Date.parse(element.getAttribute("datetime"));
+        if (rows > 0) current = entry;
+      } else if (name === "data" && rows > 0) {
+        const value = attributes.get("value");
+        if (current && value !== undefined && /^\d+$/.test(value)) {
+          current.Size = Number(value);
+        }
+      } else if (name === "time" && rows > 0) {
+        const time = Date.parse(attributes.get("datetime") ?? "");
         if (current && !isNaN(time)) {
           current.ModTime = new Date(time).toISOString();
         }
-      },
-    })
-    .transform(response)
-    .arrayBuffer();
+      }
+    },
+    end(name) {
+      if (name === "tr") {
+        rows--;
+        current = null;
+      }
+    },
+  });
 
   return entries;
 }
diff --git a/lib/html.js b/lib/html.js
index 0eb6bd4..ce77600 100644
--- a/lib/html.js
+++ b/lib/html.js
@@ -17,3 +17,264 @@ const REFERENCES = {
 export function escapeHTML(text) {
   return String(text).replace(/[&<>"']/g, (character) => REFERENCES[character]);
 }
+
+/** The elements with no end tag, as the HTML standard tells. */
+const VOID = new Set([
+  "area",
+  "base",
+  "basefont",
+  "bgsound",
+  "br",
+  "col",
+  "embed",
+  "frame",
+  "hr",
+  "img",
+  "input",
+  "keygen",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr",
+]);
+
+/**
+ * The elements with text that is not markup: only their end tag ends them.
+ * The text of `plaintext` goes to the end of the document.
+ */
+const RAW = new Set([
+  "iframe",
+  "noembed",
+  "noframes",
+  "plaintext",
+  "script",
+  "style",
+  "textarea",
+  "title",
+  "xmp",
+]);
+
+/** The basic character references, with no `;` at the end. */
+const BASIC = { amp: "&", lt: "<", gt: ">", quot: '"', apos: "'" };
+
+/**
+ * Puts the characters in place of the basic character references of an
+ * attribute value: `&amp;`, `&lt;`, `&gt;`, `&quot;`, `&apos;`, and the
+ * numeric references, for example `&#39;` and `&#x27;`. Other named
+ * references stay as they are. As the HTML standard tells, a reference with
+ * no `;` and a letter, a digit or `=` after it is text.
+ * @param {string} value
+ * @returns {string}
+ */
+export function decodeAttribute(value) {
+  if (!value.includes("&")) return value;
+  return value.replace(
+    /&(?:#([0-9]+)|#[xX]([0-9a-fA-F]+)|(amp|lt|gt|quot)|(apos);)(;?)(?=([=A-Za-z0-9]?))/g,
+    (reference, decimal, hex, name, apos, semicolon, after) => {
+      if (name !== undefined) {
+        if (!semicolon && after) return reference;
+        return BASIC[name];
+      }
+      if (apos !== undefined) return `'${semicolon}`;
+      const code = decimal !== undefined
+        ? Number.parseInt(decimal, 10)
+        : Number.parseInt(hex, 16);
+      const valid = code > 0 && code <= 0x10ffff &&
+        (code < 0xd800 || code > 0xdfff);
+      return String.fromCodePoint(valid ? code : 0xfffd);
+    },
+  );
+}
+
+/**
+ * The start and the end of each element of an HTML document. The scan
+ * follows the tokenizer of the HTML standard for tags, attributes, comments
+ * and the text of elements such as `script`, but it does not make a tree:
+ * an end tag ends the last open element with its name, and an end tag with
+ * no such element does nothing.
+ * @typedef {Object} TagHandlers
+ * @property {(name: string, attributes: Map<string, string>) => void} start
+ *   The name in lower case, and the attributes: the name of each in lower
+ *   case, and its value after `decodeAttribute`. As in the standard, the
+ *   first attribute with a name wins.
+ * @property {(name: string) => void} [end] The element ends: its end tag, or
+ *   the end tag of an element that has it in it.
+ */
+
+/**
+ * Scans the tags of an HTML document.
+ * @param {string} html
+ * @param {TagHandlers} handlers
+ */
+export function scanTags(html, { start, end }) {
+  /** The names of the open elements, from the first. */
+  const open = [];
+  const length = html.length;
+  let position = 0;
+  for (;;) {
+    const lt = html.indexOf("<", position);
+    if (lt === -1 || lt + 1 >= length) return;
+    const next = html.charCodeAt(lt + 1);
+
+    if (next === 0x21) { // `<!`: a comment, a doctype or a bogus comment.
+      if (html.startsWith("<!--", lt)) {
+        if (html.startsWith("<!-->", lt)) position = lt + 5;
+        else if (html.startsWith("<!--->", lt)) position = lt + 6;
+        else {
+          const close = html.indexOf("-->", lt + 4);
+          if (close === -1) return;
+          position = close + 3;
+        }
+      } else {
+        const close = html.indexOf(">", lt + 2);
+        if (close === -1) return;
+        position = close + 1;
+      }
+      continue;
+    }
+    if (next === 0x3f) { // `<?`: a bogus comment.
+      const close = html.indexOf(">", lt + 2);
+      if (close === -1) return;
+      position = close + 1;
+      continue;
+    }
+
+    const isEnd = next === 0x2f; // `</`
+    const first = isEnd ? lt + 2 : lt + 1;
+    if (!isLetter(html.charCodeAt(first))) {
+      if (!isEnd) { // Text, for example `a < b`.
+        position = lt + 1;
+        continue;
+      }
+      // `</>` is nothing, and `</` with no letter is a bogus comment.
+      const close = html.indexOf(">", first);
+      if (close === -1) return;
+      position = close + 1;
+      continue;
+    }
+
+    let index = first;
+    while (index < length && !isNameEnd(html.charCodeAt(index))) index++;
+    const name = html.slice(first, index).toLowerCase();
+    const attributes = new Map();
+    index = readAttributes(html, index, attributes);
+    // A tag that the document does not end is not a tag.
+    if (index === -1) return;
+    position = index;
+
+    if (isEnd) {
+      const at = open.lastIndexOf(name);
+      if (at !== -1) {
+        while (open.length > at) {
+          const element = open.pop();
+          end?.(element);
+        }
+      }
+      continue;
+    }
+
+    start(name, attributes);
+    if (VOID.has(name)) continue;
+    open.push(name);
+    if (RAW.has(name)) {
+      if (name === "plaintext") return;
+      const close = findEndTag(html, name, position);
+      if (close === -1) return;
+      position = close;
+    }
+  }
+}
+
+/** @param {number} code */
+function isLetter(code) {
+  return (code >= 0x41 && code <= 0x5a) || (code >= 0x61 && code <= 0x7a);
+}
+
+/** Tab, line feed, form feed, carriage return and space. */
+function isSpace(code) {
+  return code === 0x20 || code === 0x0a || code === 0x09 || code === 0x0c ||
+    code === 0x0d;
+}
+
+/** The end of a tag name: a space, `/` or `>`. */
+function isNameEnd(code) {
+  return isSpace(code) || code === 0x2f || code === 0x3e;
+}
+
+/**
+ * Reads the attributes of a tag, after its name.
+ * @param {string} html
+ * @param {number} index After the name of the tag.
+ * @param {Map<string, string>} attributes
+ * @returns {number} After the `>` of the tag, or -1 when the document ends
+ *   in the tag.
+ */
+function readAttributes(html, index, attributes) {
+  const length = html.length;
+  for (;;) {
+    while (index < length) {
+      const code = html.charCodeAt(index);
+      if (!isSpace(code) && code !== 0x2f) break;
+      index++;
+    }
+    if (index >= length) return -1;
+    if (html.charCodeAt(index) === 0x3e) return index + 1;
+
+    // The name. Its first character can be `=`.
+    const start = index++;
+    while (index < length) {
+      const code = html.charCodeAt(index);
+      if (isNameEnd(code) || code === 0x3d) break;
+      index++;
+    }
+    const name = html.slice(start, index).toLowerCase();
+    while (index < length && isSpace(html.charCodeAt(index))) index++;
+
+    let value = "";
+    if (index < length && html.charCodeAt(index) === 0x3d) {
+      index++;
+      while (index < length && isSpace(html.charCodeAt(index))) index++;
+      if (index >= length) return -1;
+      const quote = html.charCodeAt(index);
+      if (quote === 0x22 || quote === 0x27) {
+        const close = html.indexOf(quote === 0x22 ? '"' : "'", index + 1);
+        if (close === -1) return -1;
+        value = html.slice(index + 1, close);
+        index = close + 1;
+      } else {
+        const begin = index;
+        while (index < length) {
+          const code = html.charCodeAt(index);
+          if (isSpace(code) || code === 0x3e) break;
+          index++;
+        }
+        value = html.slice(begin, index);
+      }
+    }
+    if (!attributes.has(name)) attributes.set(name, decodeAttribute(value));
+  }
+}
+
+/**
+ * Finds the end tag of an element whose text is not markup, for example
+ * `</script>`, with no regard to case.
+ * @param {string} html
+ * @param {string} name In lower case.
+ * @param {number} from
+ * @returns {number} The index of the `<` of the end tag, or -1.
+ */
+function findEndTag(html, name, from) {
+  for (let index = from;; index++) {
+    index = html.indexOf("</", index);
+    if (index === -1) return -1;
+    const after = index + 2 + name.length;
+    if (
+      html.slice(index + 2, after).toLowerCase() === name &&
+      (after >= html.length || isNameEnd(html.charCodeAt(after)))
+    ) {
+      return index;
+    }
+  }
+}
diff --git a/lib/html_test.js b/lib/html_test.js
index cc1cb19..7ef4c0a 100644
--- a/lib/html_test.js
+++ b/lib/html_test.js
@@ -1,7 +1,8 @@
 import { test } from "node:test";
 import assert from "node:assert/strict";
+import fc from "fast-check";
 
-import { escapeHTML } from "./html.js";
+import { decodeAttribute, escapeHTML, scanTags } from "./html.js";
 
 test("escapeHTML", async (t) => {
   await t.test("puts a reference for each character of HTML", () => {
@@ -15,3 +16,105 @@ test("escapeHTML", async (t) => {
     assert.equal(escapeHTML("Hello, 世界 ≠ ?+#"), "Hello, 世界 ≠ ?+#");
   });
 });
+
+test("decodeAttribute", async (t) => {
+  await t.test("decodes the basic and the numeric references", () => {
+    assert.equal(
+      decodeAttribute("a&amp;b&lt;c&gt;d&quot;e&apos;f&#39;g&#x27;h&#X1F600;"),
+      "a&b<c>d\"e'f'g'h😀",
+    );
+  });
+
+  await t.test("keeps other references and the legacy cases as text", () => {
+    assert.equal(decodeAttribute("&eacute;&nbsp;"), "&eacute;&nbsp;");
+    assert.equal(decodeAttribute("?a=1&ampb=2"), "?a=1&ampb=2");
+    assert.equal(decodeAttribute("&amp=x"), "&amp=x");
+    assert.equal(decodeAttribute("&amp &lt"), "& <");
+    assert.equal(decodeAttribute("&apos"), "&apos");
+    assert.equal(decodeAttribute("&#0;&#xD800;&#x110000;"), "�".repeat(3));
+  });
+
+  await t.test("is the inverse of escapeHTML", () => {
+    fc.assert(
+      fc.property(fc.fullUnicodeString(), (text) => {
+        assert.equal(decodeAttribute(escapeHTML(text)), text);
+      }),
+    );
+  });
+});
+
+/** The tags of a document, as lines: `+name attributes` and `-name`. */
+function tagsOf(html) {
+  const lines = [];
+  scanTags(html, {
+    start(name, attributes) {
+      lines.push(`+${name}${JSON.stringify([...attributes])}`);
+    },
+    end(name) {
+      lines.push(`-${name}`);
+    },
+  });
+  return lines;
+}
+
+test("scanTags", async (t) => {
+  await t.test("reads the names and the attributes of tags", () => {
+    assert.deepEqual(
+      tagsOf(`<A HREF='a > b' Type=text/plain data-x="1" data-x="2" checked
+        title="&quot;x&quot;"/>t</A>`),
+      [
+        `+a[["href","a > b"],["type","text/plain"],["data-x","1"],["checked",""],["title","\\"x\\""]]`,
+        "-a",
+      ],
+    );
+  });
+
+  await t.test("does not read the tags in comments and in the text of script", () => {
+    assert.deepEqual(
+      tagsOf(`<!-- <a href="1"> --><!--><!---><!DOCTYPE html><?x <b>?>
+        <script>"<a href='2'></script >"</script><style><a></STYLE>
+        <title><a></title><textarea></textarea x><a href="3">`),
+      [
+        "+script[]",
+        "-script",
+        "+style[]",
+        "-style",
+        "+title[]",
+        "-title",
+        "+textarea[]",
+        "-textarea",
+        `+a[["href","3"]]`,
+      ],
+    );
+  });
+
+  await t.test("ends the open elements in an element at its end tag", () => {
+    assert.deepEqual(
+      tagsOf("<table><tr><td><br><img src=x></table></tr></p><p a<b>"),
+      [
+        "+table[]",
+        "+tr[]",
+        "+td[]",
+        "+br[]",
+        `+img[["src","x"]]`,
+        "-td",
+        "-tr",
+        "-table",
+        `+p[["a<b",""]]`,
+      ],
+    );
+  });
+
+  await t.test("is not a tag: text with <, and a tag at the end of the document", () => {
+    assert.deepEqual(tagsOf("a < b <3 </ > </1> <a href='x"), []);
+    assert.deepEqual(tagsOf("<plaintext><a href=x>"), ["+plaintext[]"]);
+  });
+
+  await t.test("reads any document with no error", () => {
+    fc.assert(
+      fc.property(fc.fullUnicodeString({ maxLength: 200 }), (html) => {
+        tagsOf(html);
+      }),
+    );
+  });
+});
diff --git a/lib/listing.js b/lib/listing.js
index 9a3cd3f..ce0dbca 100644
--- a/lib/listing.js
+++ b/lib/listing.js
@@ -6,8 +6,7 @@
  * change.
  */
 import { formatBytes } from "./format.js";
-import { escapeHTML } from "./html.js";
-import { htmlRewriter } from "./rewriter.js";
+import { escapeHTML, scanTags } from "./html.js";
 
 /**
  * An entry of the list of a folder, with the names of `rclone lsjson`.
@@ -24,6 +23,11 @@ import { htmlRewriter } from "./rewriter.js";
  * folder directly in the folder makes an entry. Thus the row of the parent
  * folder (`../`) is not an entry, and a name that has no percent-encoding
  * for `?`, `#` or `/` gives a wrong entry.
+ *
+ * The read is `scanTags` of `html.js`, not HTMLRewriter: in Node.js and in
+ * Deno, HTMLRewriter is WebAssembly, and its load and each element in it
+ * cost much time. The rules are the rules of the selectors `tr a[href]`,
+ * `tr data[value]` and `tr time[datetime]` of HTMLRewriter.
  * @param {Response} response
  * @param {URL} base The URL of the folder.
  * @returns {Promise<Entry[]>}
@@ -32,50 +36,50 @@ export async function readListing(response, base) {
   /** @type {Entry[]} */
   const entries = [];
   /**
-   * The entry of the current row, at the end of `entries`. A handler of an
-   * end tag costs much time in a Worker, thus the entry goes in the list at
-   * its link.
+   * The entry of the current row, at the end of `entries`.
    * @type {Entry | null}
    */
   let entry = null;
+  /** The number of open `tr` elements. */
+  let rows = 0;
 
-  const rewriter = await htmlRewriter();
-  await rewriter
-    .on("tr", {
-      element() {
+  scanTags(await response.text(), {
+    start(name, attributes) {
+      if (name === "tr") {
+        rows++;
         entry = null;
-      },
-    })
-    .on("tr a[href]", {
-      element(element) {
-        const name = childOf(element.getAttribute("href"), base);
-        if (name === null) return;
-        const isDir = name.endsWith("/");
+        return;
+      }
+      if (rows === 0) return;
+      if (name === "a") {
+        const href = attributes.get("href");
+        if (href === undefined) return;
+        const child = childOf(href, base);
+        if (child === null) return;
+        const isDir = child.endsWith("/");
         const link = {
-          Name: isDir ? name.slice(0, -1) : name,
+          Name: isDir ? child.slice(0, -1) : child,
           IsDir: isDir,
           Size: -1,
-          MimeType: element.getAttribute("type") || "",
+          MimeType: attributes.get("type") || "",
           ModTime: "",
         };
         // The last link of a row gives the entry of the row.
         if (entry) entries[entries.length - 1] = link;
         else entries.push(link);
         entry = link;
-      },
-    })
-    .on("tr data[value]", {
-      element(element) {
-        if (entry) entry.Size = Number(element.getAttribute("value"));
-      },
-    })
-    .on("tr time[datetime]", {
-      element(element) {
-        if (entry) entry.ModTime = element.getAttribute("datetime");
-      },
-    })
-    .transform(response)
-    .arrayBuffer();
+      } else if (name === "data") {
+        const value = attributes.get("value");
+        if (entry && value !== undefined) entry.Size = Number(value);
+      } else if (name === "time") {
+        const datetime = attributes.get("datetime");
+        if (entry && datetime !== undefined) entry.ModTime = datetime;
+      }
+    },
+    end(name) {
+      if (name === "tr") rows--;
+    },
+  });
 
   return entries;
 }
@@ -148,33 +152,26 @@ export function renderListing(entries, { query = "" } = {}) {
 }
 
 /**
- * Puts a query in place of the query of each link of a list, for a backend
- * on top of another backend. The links of the other backend have its own
- * options, which are not the options of a request to this backend.
+ * Writes the list of another backend again, with a query in each link, for
+ * a backend on top of another backend. The links of the other backend have
+ * its own options, which are not the options of a request to this backend.
  * @param {Response} response The list of the other backend.
  * @param {string} query The query, with no secret option.
  * @returns {Promise<Response>}
  */
 export async function relink(response, query) {
-  const suffix = query ? `?${query}` : "";
   const headers = new Headers(response.headers);
   headers.delete("Content-Length");
-  const rewriter = await htmlRewriter();
-  const rewritten = rewriter
-    .on("tr a[href]", {
-      element(element) {
-        const href = element.getAttribute("href");
-        // Only a relative link, which stays in the backend.
-        if (/^[a-z][a-z0-9+.-]*:|^\/\//i.test(href)) return;
-        element.setAttribute("href", href.replace(/[?#].*$/s, "") + suffix);
-      },
-    })
-    .transform(response);
-  return new Response(rewritten.body, {
+  headers.set("Content-Type", "text/html;charset=utf-8");
+  const init = {
     status: response.status,
     statusText: response.statusText,
     headers,
-  });
+  };
+  // The answer to HEAD has no body.
+  if (response.body === null) return new Response(null, init);
+  const entries = await readListing(response, new URL("http://remote/folder/"));
+  return new Response(renderListing(entries, { query }), init);
 }
 
 /**
diff --git a/lib/listing_test.js b/lib/listing_test.js
index 1f08d48..32d8a73 100644
--- a/lib/listing_test.js
+++ b/lib/listing_test.js
@@ -1,7 +1,9 @@
 import { test } from "node:test";
 import assert from "node:assert/strict";
+import fc from "fast-check";
 
 import { childOf, readListing, renderListing } from "./listing.js";
+import { HTMLRewriter } from "@sntran/html-rewriter";
 
 const base = new URL("http://remote/folder/");
 
@@ -74,3 +76,95 @@ test("childOf gives the name of a child, or null", () => {
   assert.equal(childOf("%E0", base), null);
   assert.equal(childOf("//example.com/folder/a", base), null);
 });
+
+/**
+ * The entries of a list, with HTMLRewriter and the selectors that
+ * readListing follows: the reference for the tests.
+ * @param {string} html
+ */
+async function readWithRewriter(html) {
+  const entries = [];
+  let entry = null;
+  await new HTMLRewriter()
+    .on("tr", {
+      element() {
+        entry = null;
+      },
+    })
+    .on("tr a[href]", {
+      element(element) {
+        const name = childOf(element.getAttribute("href"), base);
+        if (name === null) return;
+        const isDir = name.endsWith("/");
+        const link = {
+          Name: isDir ? name.slice(0, -1) : name,
+          IsDir: isDir,
+          Size: -1,
+          MimeType: element.getAttribute("type") || "",
+          ModTime: "",
+        };
+        if (entry) entries[entries.length - 1] = link;
+        else entries.push(link);
+        entry = link;
+      },
+    })
+    .on("tr data[value]", {
+      element(element) {
+        if (entry) entry.Size = Number(element.getAttribute("value"));
+      },
+    })
+    .on("tr time[datetime]", {
+      element(element) {
+        if (entry) entry.ModTime = element.getAttribute("datetime");
+      },
+    })
+    .transform(new Response(html))
+    .arrayBuffer();
+  return entries;
+}
+
+test("readListing gives the entries of HTMLRewriter", async (t) => {
+  await t.test("for each list of renderListing", async () => {
+    const entry = fc.record({
+      Name: fc.fullUnicodeString({ minLength: 1, maxLength: 12 }),
+      IsDir: fc.boolean(),
+      Size: fc.nat(),
+      MimeType: fc.constantFrom("", "text/plain; charset=utf-8", "image/png"),
+      ModTime: fc.constantFrom(
+        "",
+        "2026-10-18T12:00:00.000Z",
+        "2026-10-18T15:02:41.540476887Z",
+      ),
+    });
+    await fc.assert(
+      fc.asyncProperty(
+        fc.array(entry, { maxLength: 20 }),
+        fc.constantFrom("", "a=1&b=%3C"),
+        async (entries, query) => {
+          const html = await new Response(renderListing(entries, { query }))
+            .text();
+          assert.deepEqual(await read(html), await readWithRewriter(html));
+        },
+      ),
+      { numRuns: 50 },
+    );
+  });
+
+  await t.test("for HTML that is not of renderListing", async () => {
+    const html = `<TABLE><tr><td><A HREF='q.txt' type=text/plain TYPE="x">q</A>
+      <a href=r.txt>r</a></td><td><DATA value=" 12 ">12</DATA></td></tr>
+      <tr><script>"<tr><td><a href='s.txt'>"</script><td><a href="t.txt"/>t
+      <time datetime=2026-10-18T12:00:00Z>now</time></td></tr>
+      <!-- <tr><td><a href="c.txt">c</a></td></tr> -->
+      <tr><td><a>no link</a><a href="d/">d</a><data>no value</data></td>
+      </table><a href="out.txt">x</a><tr><td><a href="u.txt">u</a>`;
+    const entries = await read(html);
+    assert.deepEqual(entries.map(({ Name }) => Name), [
+      "r.txt",
+      "t.txt",
+      "d",
+      "u.txt",
+    ]);
+    assert.deepEqual(entries, await readWithRewriter(html));
+  });
+});
diff --git a/lib/package.json b/lib/package.json
index baa6929..38bacf5 100644
--- a/lib/package.json
+++ b/lib/package.json
@@ -15,7 +15,6 @@
     "./path": "./path.js",
     "./progress": "./progress.js",
     "./range": "./range.js",
-    "./rewriter": "./rewriter.js",
     "./size": "./size.js",
     "./sized": "./sized.js",
     "./time": "./time.js",
@@ -37,10 +36,8 @@
   },
   "author": "Trần Nguyễn Sơn",
   "license": "ISC",
-  "dependencies": {
-    "@sntran/html-rewriter": "^0.2.0"
-  },
   "devDependencies": {
+    "@sntran/html-rewriter": "^0.2.0",
     "fast-check": "^3.19.0"
   }
 }
diff --git a/lib/rewriter.js b/lib/rewriter.js
deleted file mode 100644
index bd683a3..0000000
--- a/lib/rewriter.js
+++ /dev/null
@@ -1,139 +0,0 @@
-/**
- * HTMLRewriter for the lists of folders:
- *
- * ```js
- * const rewriter = await htmlRewriter();
- * rewriter.on("tr a[href]", { element(element) {} }).transform(response);
- * ```
- */
-
-/**
- * The largest chunk of HTML for one write to HTMLRewriter.
- *
- * In Node.js, the HTMLRewriter of WebAssembly puts each chunk of its output in
- * the queue of a stream, and the output of one write can be thousands of
- * chunks. A read
- * from a queue of more than about 16000 chunks copies the queue, thus a list
- * in one large chunk takes a quadratic time. A write of at most 8 KiB gives
- * at most about 8192 chunks of output, which is less than that limit:
- * HTMLRewriter starts the next write when the reader has read the queue.
- *
- * Each chunk also costs much time in the streams of Node.js, thus the small
- * chunks, for example the output of another HTMLRewriter, become one write.
- *
- * The HTMLRewriter of workerd and of Bun is a part of the runtime, with no
- * such queue: it gets the chunks as they come, because a stream of
- * JavaScript between two of them costs more time.
- */
-export const CHUNK = 8 * 1024;
-
-/**
- * Gives the bytes of a stream in chunks of at most `CHUNK` bytes. It cuts a
- * large chunk, and joins the small chunks that come one after the other.
- * @param {ReadableStream<Uint8Array>} stream
- * @returns {ReadableStream<Uint8Array>}
- */
-export function inChunks(stream) {
-  /** The small chunks that are not written yet. @type {Uint8Array[]} */
-  let held = [];
-  let size = 0;
-  /** @param {TransformStreamDefaultController<Uint8Array>} controller */
-  const write = (controller) => {
-    if (size > 0) {
-      let joined = held[0];
-      if (held.length > 1) {
-        joined = new Uint8Array(size);
-        let offset = 0;
-        for (const chunk of held) {
-          joined.set(chunk, offset);
-          offset += chunk.length;
-        }
-      }
-      controller.enqueue(joined);
-    }
-    held = [];
-    size = 0;
-  };
-  return stream.pipeThrough(
-    new TransformStream({
-      transform(chunk, controller) {
-        if (chunk.length === 0) return;
-        if (size + chunk.length <= CHUNK) {
-          held.push(chunk);
-          size += chunk.length;
-          return;
-        }
-        write(controller);
-        let start = 0;
-        for (; chunk.length - start > CHUNK; start += CHUNK) {
-          controller.enqueue(chunk.subarray(start, start + CHUNK));
-        }
-        held.push(chunk.subarray(start));
-        size = chunk.length - start;
-      },
-      flush: write,
-    }),
-  );
-}
-
-/**
- * The class HTMLRewriter, at its first use: in Node.js, its load takes much
- * time, and a command that reads no list does not need it.
- * @type {Promise<typeof import("@sntran/html-rewriter").HTMLRewriter> | undefined}
- */
-let loaded;
-
-/** True when HTMLRewriter is the HTMLRewriter of the runtime. */
-let native = false;
-
-/**
- * An HTMLRewriter. The HTMLRewriter of WebAssembly gets the HTML in chunks of
- * at most `CHUNK` bytes.
- */
-class Rewriter {
-  /** @type {import("@sntran/html-rewriter").HTMLRewriter} */
-  #rewriter;
-
-  /** @param {import("@sntran/html-rewriter").HTMLRewriter} rewriter */
-  constructor(rewriter) {
-    this.#rewriter = rewriter;
-  }
-
-  /**
-   * @param {string} selector
-   * @param {import("@sntran/html-rewriter").ElementHandlers} handlers
-   * @returns {this}
-   */
-  on(selector, handlers) {
-    this.#rewriter.on(selector, handlers);
-    return this;
-  }
-
-  /**
-   * @param {Response} response
-   * @returns {Response}
-   */
-  transform(response) {
-    if (native || !response.body) return this.#rewriter.transform(response);
-    return this.#rewriter.transform(
-      new Response(inChunks(response.body), {
-        status: response.status,
-        statusText: response.statusText,
-        headers: response.headers,
-      }),
-    );
-  }
-}
-
-/**
- * Makes a new HTMLRewriter.
- * @returns {Promise<Rewriter>}
- */
-export async function htmlRewriter() {
-  loaded ??= import("@sntran/html-rewriter").then((module) => {
-    native = module.HTMLRewriter === globalThis.HTMLRewriter;
-    return module.HTMLRewriter;
-  });
-  const HTMLRewriter = await loaded;
-  return new Rewriter(new HTMLRewriter());
-}
diff --git a/lib/rewriter_test.js b/lib/rewriter_test.js
deleted file mode 100644
index e09d6db..0000000
--- a/lib/rewriter_test.js
+++ /dev/null
@@ -1,109 +0,0 @@
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import fc from "fast-check";
-
-import { CHUNK, htmlRewriter, inChunks } from "./rewriter.js";
-import { readListing, renderListing } from "./listing.js";
-
-/** @param {Uint8Array[]} chunks */
-function streamOf(chunks) {
-  return new ReadableStream({
-    start(controller) {
-      for (const chunk of chunks) controller.enqueue(chunk);
-      controller.close();
-    },
-  });
-}
-
-/** @param {ReadableStream<Uint8Array>} stream */
-async function chunksOf(stream) {
-  const chunks = [];
-  for await (const chunk of stream) chunks.push(chunk);
-  return chunks;
-}
-
-/** @param {Uint8Array[]} chunks */
-function join(chunks) {
-  return Buffer.concat(chunks.map((chunk) => Buffer.from(chunk)));
-}
-
-test("inChunks gives the same bytes in chunks of at most CHUNK bytes", async () => {
-  const sizes = fc.oneof(
-    fc.integer({ min: 0, max: 100 }),
-    fc.integer({ min: CHUNK - 100, max: CHUNK + 100 }),
-    fc.integer({ min: 0, max: 4 * CHUNK }),
-  );
-  await fc.assert(
-    fc.asyncProperty(fc.array(sizes, { maxLength: 30 }), async (lengths) => {
-      let byte = 0;
-      const input = lengths.map((length) =>
-        Uint8Array.from({ length }, () => byte++ % 251)
-      );
-      const output = await chunksOf(inChunks(streamOf(input)));
-      assert.deepEqual(join(output), join(input));
-      for (const [index, chunk] of output.entries()) {
-        assert.ok(chunk.length > 0, "an empty chunk");
-        assert.ok(chunk.length <= CHUNK, `a chunk of ${chunk.length} bytes`);
-        // Two chunks one after the other that fit in one chunk are one.
-        const next = output[index + 1];
-        if (next) assert.ok(chunk.length + next.length > CHUNK);
-      }
-    }),
-  );
-});
-
-test("htmlRewriter gives the output of each cut of the HTML", async () => {
-  const html = new TextEncoder().encode(
-    `<table>${"<tr><td><a href='a é.txt'>a é</a></td></tr>".repeat(500)}`,
-  );
-  /** @param {Uint8Array[]} chunks */
-  const transform = async (chunks) => {
-    const rewriter = await htmlRewriter();
-    const response = rewriter
-      .on("a[href]", {
-        element(element) {
-          element.setAttribute("href", "b.txt");
-        },
-      })
-      .transform(new Response(streamOf(chunks)));
-    return await response.text();
-  };
-  const expected = (await transform([html])).replaceAll("a é.txt", "b.txt");
-  assert.ok(!expected.includes("a é.txt"));
-  await fc.assert(
-    fc.asyncProperty(
-      fc.uniqueArray(fc.integer({ min: 1, max: html.length - 1 }), {
-        maxLength: 40,
-      }),
-      async (cuts) => {
-        const points = [0, ...cuts.toSorted((a, b) => a - b), html.length];
-        const chunks = points.slice(1).map((end, index) =>
-          html.subarray(points[index], end)
-        );
-        assert.equal(await transform(chunks), expected);
-      },
-    ),
-    { numRuns: 20 },
-  );
-});
-
-test("readListing reads a list of many chunks of CHUNK bytes, in one chunk", async () => {
-  const entries = Array.from({ length: 2000 }, (_, index) => ({
-    Name: `file ${index}.txt`,
-    IsDir: false,
-    Size: index,
-    MimeType: "text/plain",
-    ModTime: "2026-10-18T12:00:00.000Z",
-  }));
-  const html = await new Response(renderListing(entries)).arrayBuffer();
-  assert.ok(html.byteLength > 10 * CHUNK);
-  const list = await readListing(
-    new Response(new Uint8Array(html)),
-    new URL("http://remote/folder/"),
-  );
-  assert.equal(list.length, entries.length);
-  assert.deepEqual(
-    list.toSorted((a, b) => a.Size - b.Size),
-    entries,
-  );
-});
diff --git a/package-lock.json b/package-lock.json
index c7aa548..c80eb4d 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -22,7 +22,6 @@
         "@rfetch/local": "^0.1.0",
         "@rfetch/memory": "^0.1.0",
         "@rfetch/s3": "^0.1.0",
-        "@sntran/html-rewriter": "^0.2.0",
         "@sntran/serve": "^0.0.1"
       },
       "bin": {
@@ -142,10 +141,8 @@
       "name": "@rfetch/lib",
       "version": "0.1.0",
       "license": "ISC",
-      "dependencies": {
-        "@sntran/html-rewriter": "^0.2.0"
-      },
       "devDependencies": {
+        "@sntran/html-rewriter": "^0.2.0",
         "fast-check": "^3.19.0"
       },
       "engines": {
@@ -192,6 +189,7 @@
       "version": "0.2.0",
       "resolved": "https://registry.npmjs.org/@sntran/html-rewriter/-/html-rewriter-0.2.0.tgz",
       "integrity": "sha512-jK3XgNC9snm630DhVcaiyzziUV+RWJEaB0gxl+eqLw740NRnTTp0/ywmCbYeFMGc3BDUdy8Tn8Txj1gmIi6fBg==",
+      "dev": true,
       "dependencies": {
         "html-rewriter-wasm": "^0.4.1"
       }
@@ -242,7 +240,8 @@
     "node_modules/html-rewriter-wasm": {
       "version": "0.4.1",
       "resolved": "https://registry.npmjs.org/html-rewriter-wasm/-/html-rewriter-wasm-0.4.1.tgz",
-      "integrity": "sha512-lNovG8CMCCmcVB1Q7xggMSf7tqPCijZXaH4gL6iE8BFghdQCbaY5Met9i1x2Ex8m/cZHDUtXK9H6/znKamRP8Q=="
+      "integrity": "sha512-lNovG8CMCCmcVB1Q7xggMSf7tqPCijZXaH4gL6iE8BFghdQCbaY5Met9i1x2Ex8m/cZHDUtXK9H6/znKamRP8Q==",
+      "dev": true
     },
     "node_modules/pure-rand": {
       "version": "6.1.0",
diff --git a/package.json b/package.json
index b9378f9..09acd96 100644
--- a/package.json
+++ b/package.json
@@ -40,7 +40,6 @@
     "@rfetch/local": "^0.1.0",
     "@rfetch/memory": "^0.1.0",
     "@rfetch/s3": "^0.1.0",
-    "@sntran/html-rewriter": "^0.2.0",
     "@sntran/serve": "^0.0.1"
   },
   "devDependencies": {

From d7f306342d66470eb7d535fb62be26c4b0cb9afe Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sun, 18 Oct 2026 17:52:48 +0000
Subject: [PATCH 73/87] feat(local): absolute local paths and ../, as rclone

A local path of the command line or of the code is now relative to the
current folder, as in rclone: file.txt, ../file.txt and /tmp/file.txt.
Before, the local backend joined each path to the current folder, thus
/tmp/x was the folder tmp/x in it, and ../x was x.

fetch.js resolves the path as a URL on the file URL of the current
folder, and gives the local backend the absolute path, with
RFETCH_LOCAL_ROOT: / in env. RFETCH_LOCAL_ROOT is not an option: fetch.js
removes it from the options, thus a config file, a variable, a header or
the query cannot set it. :local:path, a named remote of type local, and a
client of rfetch serve, which gives no env, stay in the current folder.
The Worker gives no local path: a path with no remote is a file of its
site.

The local backend refuses to delete its root and the current folder.

Tests: an absolute path and ../ read a file out of the current folder; a
header, a variable and a remote cannot set the root; a delete of the
current folder gives 403.
---
 CONTRIBUTING.md           |  7 +++++
 backend/local/main.js     | 22 ++++++++++----
 cmd/lsjson/rclone_test.js |  2 +-
 fetch.js                  | 23 +++++++++++++--
 main_test.js              | 60 ++++++++++++++++++++++++++++++++++++++-
 5 files changed, 104 insertions(+), 10 deletions(-)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 94d38ba..934969e 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -117,6 +117,13 @@ flags, in its query, and all the other options in `env`, as
 `RFETCH_REMOTE_NAME`. The headers `RFETCH_*` and `RCLONE_*` never go out to a
 URL.
 
+A local path, for example `file.txt`, `../file.txt` or `/tmp/file.txt`, is
+relative to the current folder, as in rclone. The `fetch` of `fetch.js` gives
+the absolute path to the local backend, with `RFETCH_LOCAL_ROOT: /` in `env`.
+`RFETCH_LOCAL_ROOT` is not an option: a config file, a variable, a header or the
+query cannot set it. Thus `:local:path` and a client of `rfetch serve` stay in
+the current folder.
+
 ## Workspaces
 
 Each backend is an npm workspace with the name `@rfetch/NAME`, and can be a
diff --git a/backend/local/main.js b/backend/local/main.js
index 37d3552..7658c42 100644
--- a/backend/local/main.js
+++ b/backend/local/main.js
@@ -1,5 +1,5 @@
 import process from "node:process";
-import { dirname, isAbsolute, join, relative, sep } from "node:path";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { formatBytes } from "@rfetch/lib/format";
 import { escapeHTML } from "@rfetch/lib/html";
 import { mimeType } from "@rfetch/lib/mime";
@@ -7,14 +7,24 @@ import { decodePath } from "@rfetch/lib/path";
 import { notSatisfiable, parseRange, partialHeaders } from "@rfetch/lib/range";
 
 /**
- * Serves a local remote: the files and the folders in the current folder.
+ * Serves a local remote: the files and the folders in its root. The root is
+ * the current folder, or `RFETCH_LOCAL_ROOT` of `env`.
+ *
+ * The fetch of rfetch sets the root `/` only for a local path of the command
+ * line or of the code, for example `/tmp/file.txt`: an option, a header or
+ * the query cannot set it. Thus a request from a client of `rfetch serve`,
+ * which has no `env`, stays in the current folder.
  * @param {Request} request
+ * @param {Record<string, unknown>} [env]
  * @returns {Promise<Response>}
  */
-async function local(request) {
+async function local(request, env = {}) {
   const { method, url } = request;
   const { pathname, searchParams } = new URL(url);
-  const root = process.cwd?.() || ".";
+  const cwd = process.cwd?.() || ".";
+  const root = typeof env.RFETCH_LOCAL_ROOT === "string"
+    ? env.RFETCH_LOCAL_ROOT
+    : cwd;
   const path = decodePath(pathname);
   const absolutePath = path === null ? null : join(root, path);
 
@@ -207,8 +217,8 @@ async function local(request) {
     if (!stats) {
       return new Response(null, { status: 404 });
     }
-    // The root is the current folder, which must stay.
-    if (path === "/") {
+    // The root and the current folder must stay.
+    if (path === "/" || resolve(absolutePath) === resolve(cwd)) {
       return new Response(null, { status: 403 });
     }
 
diff --git a/cmd/lsjson/rclone_test.js b/cmd/lsjson/rclone_test.js
index 8401015..c85189a 100644
--- a/cmd/lsjson/rclone_test.js
+++ b/cmd/lsjson/rclone_test.js
@@ -67,7 +67,7 @@ describe("lsjson and rclone lsjson", {
       { env: { PATH: process.env.PATH, HOME: folder } },
     );
     assert.equal(status, 0, `${stderr}`);
-    const actual = await lsjson("/tree/", { recursive: "true" })
+    const actual = await lsjson("tree/", { recursive: "true" })
       .then((response) => response.json());
     assert.deepEqual(normalize(actual), normalize(JSON.parse(stdout)));
   });
diff --git a/fetch.js b/fetch.js
index f5dd9a1..062cc4a 100644
--- a/fetch.js
+++ b/fetch.js
@@ -3,7 +3,7 @@
  * module sets it as the global `fetch`. A command imports this module and
  * not mod.js: mod.js exports all the commands, which take much time to load.
  */
-import { env } from "node:process";
+import process, { env } from "node:process";
 import { backends, load } from "./backend/main.js";
 import { parse } from "@rfetch/lib/fspath";
 import { isOption, PREFIXES } from "@rfetch/lib/options";
@@ -199,8 +199,23 @@ export async function fetch(input, init = {}) {
     }
   }
 
+  // A local path, of the command line or of the code, is relative to the
+  // current folder, as in rclone: for example `file.txt`, `../file.txt` or
+  // `/tmp/file.txt`. Only such a path gives the root `/` to the local
+  // backend. The Worker gives no such path: a path with no remote is a file
+  // of its site.
+  let location = new URL(parsed.path, "file:");
+  /** @type {string | undefined} */
+  let root;
+  if (parsed.name === "") {
+    const { pathToFileURL } = await import("node:url");
+    const folder = pathToFileURL(process.cwd());
+    if (!folder.pathname.endsWith("/")) folder.pathname += "/";
+    location = new URL(parsed.path, folder);
+    root = "/";
+  }
   // `searchParams` may contain other flags not for the current backend.
-  const { pathname, searchParams } = new URL(parsed.path, "file:");
+  const { pathname, searchParams } = location;
 
   // The query of the backend: the flags prefixed with the backend type, then
   // the parameters in the connection string, which take their place.
@@ -221,6 +236,10 @@ export async function fetch(input, init = {}) {
   for (const [key, value] of options) {
     optionsEnv[`RFETCH_${type.toUpperCase()}_${key.toUpperCase()}`] = value;
   }
+  // The root of the local backend is not an option: a config file, a
+  // variable, a header or the query cannot set it.
+  delete optionsEnv.RFETCH_LOCAL_ROOT;
+  if (root !== undefined) optionsEnv.RFETCH_LOCAL_ROOT = root;
   // The headers of this backend are in its options now.
   const own = PREFIXES.map((start) => `${start}${type.toLowerCase()}_`);
   for (const key of [...headers.keys()]) {
diff --git a/main_test.js b/main_test.js
index 6b248dd..ec0339b 100644
--- a/main_test.js
+++ b/main_test.js
@@ -1,6 +1,8 @@
 import { test } from "node:test";
 import process from "node:process";
-import { unlink, writeFile } from "node:fs/promises";
+import { mkdtemp, rm, stat, unlink, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { basename, join } from "node:path";
 import { serve } from "@sntran/serve";
 import assert from "node:assert/strict";
 
@@ -385,3 +387,59 @@ test("options in the headers of a request", async (t) => {
     assert.deepEqual(await Promise.all(folders.map(get)), folders);
   });
 });
+
+test("local paths", async (t) => {
+  const outside = await mkdtemp(join(tmpdir(), "rfetch-outside-"));
+  await writeFile(join(outside, "secret.txt"), "outside");
+  const inside = await mkdtemp(join(tmpdir(), "rfetch-inside-"));
+  await writeFile(join(inside, "a.txt"), "inside");
+  const cwd = process.cwd();
+  process.chdir(inside);
+  try {
+    await t.test("a path is relative to the current folder", async () => {
+      assert.equal(await (await fetch("a.txt")).text(), "inside");
+      assert.equal(await (await fetch("./a.txt")).text(), "inside");
+    });
+
+    await t.test("an absolute path and ../ go out of the current folder", async () => {
+      const file = join(outside, "secret.txt");
+      assert.equal(await (await fetch(file)).text(), "outside");
+      const up = `../${basename(outside)}/secret.txt`;
+      assert.equal(await (await fetch(up)).text(), "outside");
+    });
+
+    await t.test("a header, a variable or a remote cannot set the root", async () => {
+      const path = `${outside}/secret.txt`;
+      let response = await fetch(`:local:${path}`, {
+        headers: { RFETCH_LOCAL_ROOT: "/" },
+      });
+      assert.equal(response.status, 404);
+      process.env.RFETCH_LOCAL_ROOT = "/";
+      try {
+        response = await fetch(`:local:${path}`);
+        assert.equal(response.status, 404);
+      } finally {
+        delete process.env.RFETCH_LOCAL_ROOT;
+      }
+      response = await fetch(`disk:${path}`, {
+        headers: {
+          RFETCH_CONFIG_DISK_TYPE: "local",
+          RFETCH_CONFIG_DISK_ROOT: "/",
+        },
+      });
+      assert.equal(response.status, 404);
+    });
+
+    await t.test("the current folder stays", async () => {
+      for (const path of ["./", ".", `${inside}/`, `../${basename(inside)}/`]) {
+        const response = await fetch(path, { method: "DELETE" });
+        assert.equal(response.status, 403, JSON.stringify(path));
+      }
+      assert.ok((await stat(join(inside, "a.txt"))).isFile());
+    });
+  } finally {
+    process.chdir(cwd);
+    await rm(outside, { recursive: true, force: true });
+    await rm(inside, { recursive: true, force: true });
+  }
+});

From b6e28f627f3e44a6116ffb5381f7acd679641e07 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sun, 18 Oct 2026 17:53:45 +0000
Subject: [PATCH 74/87] fix(cli): the errors and the exit codes of rclone, and
 the pipe

The command line gave the exit code 0 and no message for an error. Now
an answer that is not ok writes the error to stderr, and gives the exit
code 3 for 404, as "directory not found" of rclone, else 1.

lsjson of a path that names no file and no folder gives 404, as rclone.
Before, it gave an empty list.

The output waits for drain when the pipe is full: before, a slow reader
kept all the output in memory. A reader that closes the pipe, for
example head, stops the command with no error. Before, Node.js wrote
the stack of an EPIPE error. Node.js, Deno and Bun give the same data,
and stop with no error.
---
 cmd/lsjson/main.js      |  6 +++-
 cmd/lsjson/main_test.js |  9 +++++
 main.js                 | 18 +++++++++-
 main_test.js            | 77 ++++++++++++++++++++++++++++++++++++++++-
 4 files changed, 107 insertions(+), 3 deletions(-)

diff --git a/cmd/lsjson/main.js b/cmd/lsjson/main.js
index 84eadbf..cac35c2 100644
--- a/cmd/lsjson/main.js
+++ b/cmd/lsjson/main.js
@@ -89,7 +89,11 @@ export async function lsjson(location, flags = {}, init = {}) {
     // as in rclone: then the list is the list of the folder.
     entries = await readListing(response, FOLDER);
     const named = entries.filter(({ Name }) => Name === filename);
-    if (named.length > 0 && named.every(({ IsDir }) => IsDir)) {
+    // As rclone, a path that names no file and no folder is not found.
+    if (named.length === 0) {
+      return new Response("directory not found", { status: 404 });
+    }
+    if (named.every(({ IsDir }) => IsDir)) {
       return lsjson(`${location}/`, flags, init);
     }
   }
diff --git a/cmd/lsjson/main_test.js b/cmd/lsjson/main_test.js
index 0a2db77..2a745a8 100644
--- a/cmd/lsjson/main_test.js
+++ b/cmd/lsjson/main_test.js
@@ -248,3 +248,12 @@ test("lsjson lists a folder with no / at the end, as rclone", async () => {
     { Path: "file", IsDir: false },
   ]);
 });
+
+test("lsjson gives 404 for a path that is not found, as rclone", async () => {
+  await putAll(":memory:/not-found/", ["a.txt"]);
+  for (const path of ["nosuch", "nosuch.txt", "nosuch/"]) {
+    const response = await lsjson(`:memory:/not-found/${path}`);
+    assert.equal(response.status, 404, path);
+    await response.body?.cancel();
+  }
+});
diff --git a/main.js b/main.js
index 3e71a4f..3bbd6d8 100755
--- a/main.js
+++ b/main.js
@@ -11,6 +11,7 @@
  * ```
  */
 import process, { argv, env, stderr, stdout } from "node:process";
+import { once } from "node:events";
 import { parseArgs } from "node:util";
 
 // The import sets the global `fetch`, which reads the paths of remotes.
@@ -80,9 +81,24 @@ for (const name of Object.keys(flags)) {
   const module = await import(`./cmd/${FOLDERS[name]}/main.js`);
   /** TODO merge global flags into config */
   const response = await module[name](...args, flags);
+  if (!response.ok) {
+    // As rclone: the exit code 3 is "directory not found", and 1 is an
+    // other error.
+    const text = (await response.text()).trim() || response.statusText ||
+      (response.status === 404 ? "not found" : `status ${response.status}`);
+    stderr.write(`Error: ${text}\n`);
+    process.exitCode = response.status === 404 ? 3 : 1;
+    return;
+  }
   if (response.body) {
+    // A reader that closes the pipe, for example `head`, stops the command.
+    stdout.on("error", (error) => {
+      if (error.code === "EPIPE") process.exit();
+      throw error;
+    });
     for await (const chunk of response.body) {
-      stdout.write(chunk);
+      // Waits when the pipe is full: else the output stays in memory.
+      if (!stdout.write(chunk)) await once(stdout, "drain");
     }
   }
 })();
diff --git a/main_test.js b/main_test.js
index ec0339b..7ee8467 100644
--- a/main_test.js
+++ b/main_test.js
@@ -1,8 +1,11 @@
 import { test } from "node:test";
 import process from "node:process";
-import { mkdtemp, rm, stat, unlink, writeFile } from "node:fs/promises";
+import { spawn } from "node:child_process";
+import { once } from "node:events";
+import { mkdir, mkdtemp, rm, stat, unlink, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { basename, join } from "node:path";
+import { fileURLToPath } from "node:url";
 import { serve } from "@sntran/serve";
 import assert from "node:assert/strict";
 
@@ -443,3 +446,75 @@ test("local paths", async (t) => {
     await rm(inside, { recursive: true, force: true });
   }
 });
+
+const MAIN = fileURLToPath(new URL("./main.js", import.meta.url));
+
+/**
+ * Runs the command line in a folder.
+ * @param {string} cwd
+ * @param {string[]} args
+ */
+async function run(cwd, args) {
+  const child = spawn(process.execPath, [MAIN, ...args], { cwd });
+  let stdout = "";
+  let stderr = "";
+  child.stdout.on("data", (chunk) => stdout += chunk);
+  child.stderr.on("data", (chunk) => stderr += chunk);
+  const [code] = await once(child, "close");
+  return { code, stdout, stderr };
+}
+
+test("the command line", async (t) => {
+  const folder = await mkdtemp(join(tmpdir(), "rfetch-cli-"));
+  await writeFile(join(folder, "a.txt"), "a");
+  await mkdir(join(folder, "empty"));
+  try {
+    await t.test("gives the exit code 3 of rclone for a path that is not found", async () => {
+      for (
+        const args of [
+          ["lsjson", "nosuch"],
+          ["lsjson", "nosuch/"],
+          ["lsjson", "empty/nosuch.txt"],
+          ["cat", "nosuch.txt"],
+        ]
+      ) {
+        const { code, stdout, stderr } = await run(folder, args);
+        assert.equal(code, 3, args.join(" "));
+        assert.equal(stdout, "");
+        assert.match(stderr, /^Error: .*not found/);
+      }
+    });
+
+    await t.test("gives the exit code 0 for a path that is found", async () => {
+      const { code, stdout } = await run(folder, ["lsjson", "a.txt"]);
+      assert.equal(code, 0);
+      assert.equal(JSON.parse(stdout)[0].Name, "a.txt");
+    });
+
+    await t.test("gives the exit code 1 and the help for an unknown command", async () => {
+      const { code, stdout, stderr } = await run(folder, ["nosuch"]);
+      assert.equal(code, 1);
+      assert.match(stderr, /unknown command "nosuch"/);
+      assert.match(stdout, /Available Commands:/);
+    });
+
+    await t.test("stops with no error when the reader closes the pipe", async () => {
+      await writeFile(
+        join(folder, "big.bin"),
+        new Uint8Array(16 * 1024 * 1024),
+      );
+      const child = spawn(process.execPath, [MAIN, "cat", "big.bin"], {
+        cwd: folder,
+      });
+      let stderr = "";
+      child.stderr.on("data", (chunk) => stderr += chunk);
+      await once(child.stdout, "data");
+      child.stdout.destroy();
+      const [code] = await once(child, "close");
+      assert.equal(code, 0);
+      assert.equal(stderr, "");
+    });
+  } finally {
+    await rm(folder, { recursive: true, force: true });
+  }
+});

From 29db3f9912cd103248b6fb36ffe7f17c71a5c35b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sun, 18 Oct 2026 17:55:58 +0000
Subject: [PATCH 75/87] feat(local): the ModTime of rclone, in nanoseconds

rclone lsjson gives the time of a local file with 9 digits after the
second, for example 2026-10-18T15:02:41.540476887Z: the format of Go for
a remote with a precision of 1 ns. rfetch gave milliseconds.

Now the local backend writes the time of each file and folder of a list
with 9 digits, from the stat in nanoseconds. renderListing and
toLocaleISOString keep the digits of a time, from 3 to 9, thus crypt and
chunker on a local remote give them too. A remote with milliseconds,
for example memory, keeps 3 digits. The size of a folder stays -1, as
for the other backends.

Node.js and Bun give the nanoseconds of a file. Deno gives
milliseconds, thus on Deno the last 6 digits are 0.

cmd/lsjson/rclone_test.js now compares the ModTime of each file and
folder with rclone, digit for digit. bench/rclone.js compares the times
to the millisecond, for Deno.
---
 backend/local/main.js     | 27 +++++++++++++++++++++++----
 bench/rclone.js           |  6 +++++-
 cmd/lsjson/rclone_test.js |  4 ++--
 lib/listing.js            |  8 ++++++--
 lib/listing_test.js       | 20 ++++++++++++++++++++
 lib/time.js               | 25 +++++++++++++++++++++----
 lib/time_test.js          | 23 +++++++++++++++++++++++
 7 files changed, 100 insertions(+), 13 deletions(-)

diff --git a/backend/local/main.js b/backend/local/main.js
index 7658c42..a3497a7 100644
--- a/backend/local/main.js
+++ b/backend/local/main.js
@@ -58,9 +58,12 @@ async function local(request, env = {}) {
       // The stat of each file, at the same time: one after the other takes
       // much more time. A file that goes away before its stat is not in
       // the list.
+      // The times in nanoseconds, as rclone gives them.
       const fileStats = await Promise.all(
         files.map((file) =>
-          stat(join(absolutePath, file.name)).catch(() => null)
+          stat(join(absolutePath, file.name), { bigint: true }).catch(() =>
+            null
+          )
         ),
       );
 
@@ -106,8 +109,8 @@ async function local(request, env = {}) {
                 isDirectory ? "/" : ""
               }`;
 
-              const { size, mtimeMs } = fileStats[index];
-              const mtime = timeOf(mtimeMs);
+              const { size, mtimeNs } = fileStats[index];
+              const mtime = timeOf(Number(mtimeNs / 1000000n));
 
               controller.enqueue(`<tr>
                 <td>${isDirectory ? "📁" : "📄"}</td>
@@ -126,7 +129,7 @@ async function local(request, env = {}) {
                 <td>${
                 mtime
                   ? `<time
-                    datetime="${mtime.toISOString()}"
+                    datetime="${isoStringOf(mtimeNs)}"
                   >${mtime.toLocaleString()}</time>`
                   : "-"
               }
@@ -246,6 +249,22 @@ function isOutside(root, path) {
   return rest === ".." || rest.startsWith(`..${sep}`) || isAbsolute(rest);
 }
 
+/**
+ * The time of a file in ISO 8601, with 9 digits after the second: the
+ * format of rclone for a remote with a precision of 1 ns.
+ * @param {bigint} mtimeNs The nanoseconds after 1970.
+ * @returns {string}
+ */
+function isoStringOf(mtimeNs) {
+  const second = 1000000000n;
+  // The floor, also for a time before 1970.
+  let nanoseconds = mtimeNs % second;
+  if (nanoseconds < 0n) nanoseconds += second;
+  const seconds = (mtimeNs - nanoseconds) / second;
+  const date = new Date(Number(seconds) * 1000).toISOString().slice(0, 19);
+  return `${date}.${String(nanoseconds).padStart(9, "0")}Z`;
+}
+
 /**
  * The time of a file to the millisecond. As in Go, the time is cut, not
  * rounded: the `mtime` of Node.js is rounded to the nearest millisecond.
diff --git a/bench/rclone.js b/bench/rclone.js
index e5ace63..3b76065 100644
--- a/bench/rclone.js
+++ b/bench/rclone.js
@@ -119,11 +119,15 @@ function run(tool, args, input) {
 /**
  * The lines of `lsjson`, in order, for a compare. The size of a folder is not
  * in a line: rclone gives the size of a local folder, and rfetch gives -1.
+ * The time is to the millisecond: Deno gives the time of a file in
+ * milliseconds. cmd/lsjson/rclone_test.js compares the nanoseconds.
  */
 function lines(tool, args) {
   run(tool, args);
   return JSON.parse(readFileSync(join(root, "output"), "utf8"))
-    .map(({ Path, Size, IsDir }) => `${Path} ${IsDir ? "folder" : Size}`)
+    .map(({ Path, Size, IsDir, ModTime }) =>
+      `${Path} ${IsDir ? "folder" : Size} ${Date.parse(ModTime)}`
+    )
     .sort();
 }
 
diff --git a/cmd/lsjson/rclone_test.js b/cmd/lsjson/rclone_test.js
index c85189a..094206d 100644
--- a/cmd/lsjson/rclone_test.js
+++ b/cmd/lsjson/rclone_test.js
@@ -54,8 +54,8 @@ describe("lsjson and rclone lsjson", {
         Size: IsDir ? -1 : Size,
         IsDir,
         MimeType,
-        // rclone has nanoseconds, and the lists of rfetch milliseconds.
-        ModTime: IsDir ? 0 : Math.floor(Date.parse(ModTime)),
+        // The same digits as rclone: 9 for the nanoseconds of local files.
+        ModTime,
       }))
       .sort((a, b) => a.Path < b.Path ? -1 : +(a.Path > b.Path));
   }
diff --git a/lib/listing.js b/lib/listing.js
index ce0dbca..2d54b85 100644
--- a/lib/listing.js
+++ b/lib/listing.js
@@ -7,6 +7,7 @@
  */
 import { formatBytes } from "./format.js";
 import { escapeHTML, scanTags } from "./html.js";
+import { toLocaleISOString } from "./time.js";
 
 /**
  * An entry of the list of a folder, with the names of `rclone lsjson`.
@@ -106,6 +107,9 @@ export function renderListing(entries, { query = "" } = {}) {
     ({ Name, IsDir, Size, MimeType, ModTime }) => {
       const href = `${encodeURIComponent(Name)}${IsDir ? "/" : ""}`;
       const time = ModTime ? new Date(ModTime) : null;
+      // The digits after the second of the time stay, as the precision of
+      // the remote.
+      const datetime = toLocaleISOString(ModTime, 0);
       return `
           <tr>
             <td>${IsDir ? "📁" : "📄"}</td>
@@ -120,8 +124,8 @@ export function renderListing(entries, { query = "" } = {}) {
           }</data>`
       }</td>
             <td>${
-        time && !isNaN(time)
-          ? `<time datetime="${time.toISOString()}">${time.toLocaleString()}</time>`
+        time && datetime
+          ? `<time datetime="${datetime}">${time.toLocaleString()}</time>`
           : "-"
       }</td>
           </tr>`;
diff --git a/lib/listing_test.js b/lib/listing_test.js
index 32d8a73..c2818a8 100644
--- a/lib/listing_test.js
+++ b/lib/listing_test.js
@@ -168,3 +168,23 @@ test("readListing gives the entries of HTMLRewriter", async (t) => {
     assert.deepEqual(entries, await readWithRewriter(html));
   });
 });
+
+test("renderListing keeps the digits of a time, as the precision of the remote", async () => {
+  const entries = [
+    "2026-10-18T15:02:41.540476887Z",
+    "2026-10-18T15:02:41.540Z",
+    "2026-10-18T22:02:41.540476+07:00",
+  ].map((ModTime, index) => ({
+    Name: `${index}.txt`,
+    IsDir: false,
+    Size: 1,
+    MimeType: "text/plain",
+    ModTime,
+  }));
+  const html = await new Response(renderListing(entries)).text();
+  assert.deepEqual((await read(html)).map(({ ModTime }) => ModTime), [
+    "2026-10-18T15:02:41.540476887Z",
+    "2026-10-18T15:02:41.540Z",
+    "2026-10-18T15:02:41.540476Z",
+  ]);
+});
diff --git a/lib/time.js b/lib/time.js
index a64c67b..d78f8a9 100644
--- a/lib/time.js
+++ b/lib/time.js
@@ -1,7 +1,12 @@
 /**
- * Writes a time as the ModTime of `rclone lsjson` for a remote with a
- * precision of 1 ms: the format `2006-01-02T15:04:05.000Z07:00` of Go, in the
- * local time zone. The time zone is `Z` for UTC, else `+hh:mm` or `-hh:mm`.
+ * Writes a time as the ModTime of `rclone lsjson`, in the local time zone:
+ * the format `2006-01-02T15:04:05.000000000Z07:00` of Go, with the digits
+ * after the second of the remote. The time zone is `Z` for UTC, else
+ * `+hh:mm` or `-hh:mm`.
+ *
+ * As rclone, the number of digits after the second tells the precision of
+ * the remote: 9 for 1 ns, for example a local file, and 3 for 1 ms. A time
+ * in a string keeps its digits, from 3 to 9. A Date or a number has 3.
  * @param {string | number | Date | null | undefined} value
  * @param {number} [offset] The minutes after UTC of the time zone. By
  *   default, the offset of the local time zone at that time.
@@ -10,12 +15,24 @@
  */
 export function toLocaleISOString(value, offset) {
   if (value === null || value === undefined || value === "") return undefined;
+  /** The digits after the second, when there are more than 3. */
+  let digits = "";
+  if (typeof value === "string") {
+    const match = /^(.*T\d\d:\d\d:\d\d)\.(\d{4,})(Z|[+-]\d\d:\d\d)$/i
+      .exec(value);
+    if (match) {
+      digits = match[2].slice(0, 9);
+      value = `${match[1]}.${digits.slice(0, 3)}${match[3]}`;
+    }
+  }
   const date = new Date(value);
   if (isNaN(date.getTime())) return undefined;
 
   offset ??= -date.getTimezoneOffset();
-  const local = new Date(date.getTime() + offset * 60000).toISOString()
+  let local = new Date(date.getTime() + offset * 60000).toISOString()
     .slice(0, -1);
+  // The time zone does not change the digits after the millisecond.
+  if (digits) local = `${local.slice(0, -3)}${digits}`;
   if (offset === 0) return `${local}Z`;
   const minutes = Math.abs(offset);
   const pad = (number) => String(number).padStart(2, "0");
diff --git a/lib/time_test.js b/lib/time_test.js
index b6ade4d..016811a 100644
--- a/lib/time_test.js
+++ b/lib/time_test.js
@@ -26,3 +26,26 @@ test("toLocaleISOString writes the times of rclone lsjson", () => {
     assert.equal(toLocaleISOString(value), undefined);
   }
 });
+
+test("toLocaleISOString keeps the digits of the time, from 3 to 9", () => {
+  for (
+    const [time, offset, expected] of [
+      ["2026-10-18T15:02:41.540476887Z", 0, "2026-10-18T15:02:41.540476887Z"],
+      [
+        "2026-10-18T15:02:41.540476887Z",
+        420,
+        "2026-10-18T22:02:41.540476887+07:00",
+      ],
+      [
+        "2026-10-18T00:02:41.000000001+00:00",
+        -300,
+        "2026-10-17T19:02:41.000000001-05:00",
+      ],
+      ["2026-10-18T15:02:41.540476Z", 0, "2026-10-18T15:02:41.540476Z"],
+      ["2026-10-18T15:02:41.1234567891Z", 0, "2026-10-18T15:02:41.123456789Z"],
+      ["2026-10-18T15:02:41.5Z", 0, "2026-10-18T15:02:41.500Z"],
+    ]
+  ) {
+    assert.equal(toLocaleISOString(time, offset), expected, time);
+  }
+});

From f64d297134d9220581f1bcd76ce53f5b7dec9930 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sun, 18 Oct 2026 18:11:20 +0000
Subject: [PATCH 76/87] perf(crypt): XSalsa20 with SIMD, 4 blocks at a time

The crate salsa20 has no SIMD for WebAssembly, and Salsa20 was 55% of
the time of the module. The new src/salsa.rs of the crate computes 4
blocks of Salsa20 at a time, one in each lane of the SIMD of
WebAssembly, and HSalsa20 for the key of each box. Poly1305 is the crate
poly1305, as before, and the compare of the tags takes the same time
for each tag (subtle). crypto_secretbox is now only a dev-dependency.

The boxes are the same bytes as before:
- cargo test compares each box with crypto_secretbox for 16 sizes,
  with a counter of blocks near a carry, and a bad box and a bad tag
  do not open. The code with no SIMD runs on the machine of the build.
- secretbox_test.js decrypts the box of the first test of NaCl, of 131
  bytes, over 3 blocks of Salsa20, with the module.
- The rclone tests of crypt compare the data with rclone.
The job wasm of CI runs cargo test.

The module only, 64 MiB in blocks of 64 KiB, in Node.js 22: seal
167 ms before, 110 ms after; open 183 ms before, 128 ms after.
bench/node.js: crypt PUT 8 MiB 33.7 ms before, 20.8 ms after; crypt
GET 8 MiB 35.7 ms before, 29.5 ms after. Bun gains less: its
WebAssembly makes less of the SIMD.
---
 .github/workflows/ci.yml          |   8 +-
 CONTRIBUTING.md                   |   4 +
 backend/crypt/native/Cargo.lock   |   2 +
 backend/crypt/native/Cargo.toml   |   6 +
 backend/crypt/native/src/lib.rs   | 129 +++++++++++++++--
 backend/crypt/native/src/salsa.rs | 228 ++++++++++++++++++++++++++++++
 backend/crypt/secretbox.wasm      | Bin 9633 -> 12346 bytes
 backend/crypt/secretbox_test.js   |  28 ++++
 8 files changed, 391 insertions(+), 14 deletions(-)
 create mode 100644 backend/crypt/native/src/salsa.rs

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index a155e6e..a908bbf 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -4,8 +4,8 @@
 #   newer versions. The job installs rclone and Go, thus the tests that
 #   compare rfetch with rclone and with Go run too.
 # - deno fmt --check: the format of the files.
-# - wasm: the build of backend/crypt/secretbox.wasm from its source gives the
-#   same bytes as the file in the repository.
+# - wasm: the tests of the crate of backend/crypt/secretbox.wasm, and its
+#   build from its source gives the same bytes as the file in the repository.
 #
 # This workflow deploys nothing: the Pages project deploys the branches.
 name: CI
@@ -104,6 +104,10 @@ jobs:
           rustup toolchain install "$channel" --profile minimal \
             --target wasm32-unknown-unknown
 
+      # The tests compare each box with the crate crypto_secretbox, on the
+      # machine of the job.
+      - run: cargo test --locked
+
       - run: ./build.sh
 
       - name: Compare with the file in the repository
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 934969e..199a1b5 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -304,6 +304,10 @@ rclone. Node.js, WebCrypto and Workers have no Salsa20, and the module is about
 - The source is the Rust crate in `backend/crypt/native`.
   `backend/crypt/native/build.sh` builds the module, with the compiler of
   `rust-toolchain.toml` and the versions of `Cargo.lock`.
+- XSalsa20 is in `src/salsa.rs`: it computes 4 blocks of Salsa20 at a time with
+  the SIMD of WebAssembly. Poly1305 is the crate `poly1305`. `cargo test`
+  compares each box with the crate `crypto_secretbox`, on the machine of the
+  build, with the same code with no SIMD.
 - Node.js, Deno and Bun read the file (`wasm.js`). A Worker cannot compile a
   module at run time, thus wrangler compiles it at the build
   (`wasm.workerd.js`). The field `imports` of `backend/crypt/package.json`
diff --git a/backend/crypt/native/Cargo.lock b/backend/crypt/native/Cargo.lock
index b76c9e1..5cb8e3b 100644
--- a/backend/crypt/native/Cargo.lock
+++ b/backend/crypt/native/Cargo.lock
@@ -114,6 +114,8 @@ name = "secretbox"
 version = "0.1.0"
 dependencies = [
  "crypto_secretbox",
+ "poly1305",
+ "subtle",
 ]
 
 [[package]]
diff --git a/backend/crypt/native/Cargo.toml b/backend/crypt/native/Cargo.toml
index 20e0974..bab2fd2 100644
--- a/backend/crypt/native/Cargo.toml
+++ b/backend/crypt/native/Cargo.toml
@@ -10,7 +10,13 @@ publish = false
 [lib]
 crate-type = ["cdylib"]
 
+# XSalsa20 is in src/salsa.rs.
 [dependencies]
+poly1305 = "=0.8.0"
+subtle = { version = "=2.6.1", default-features = false }
+
+# The tests compare each box with this crate.
+[dev-dependencies]
 crypto_secretbox = { version = "=0.1.1", default-features = false, features = ["salsa20"] }
 
 [profile.release]
diff --git a/backend/crypt/native/src/lib.rs b/backend/crypt/native/src/lib.rs
index c1963ce..d8ec79e 100644
--- a/backend/crypt/native/src/lib.rs
+++ b/backend/crypt/native/src/lib.rs
@@ -1,16 +1,24 @@
 //! The blocks of the data of rclone crypt: NaCl secretbox, that is
 //! XSalsa20 and Poly1305, for `../secretbox.js`.
 //!
+//! XSalsa20 is in `salsa.rs`: it computes 4 blocks of Salsa20 at a time
+//! with the SIMD of WebAssembly, because the crate `salsa20` has no SIMD
+//! for WebAssembly. Poly1305 is the crate `poly1305`. The tests compare each
+//! box with the crate `crypto_secretbox`.
+//!
 //! The module has no imports. JavaScript writes the key, the nonce and the
 //! input into the memory of the module, at the addresses that `key`,
 //! `nonce` and `input` give. Then `seal` or `open` writes the output at the
 //! address that `output` gives. The nonce goes up by 1 for each block, as a
 //! number in little-endian bytes, thus JavaScript reads it back for the
 //! next call.
-#![no_std]
+#![cfg_attr(not(test), no_std)]
+
+mod salsa;
 
-use crypto_secretbox::aead::{AeadInPlace, KeyInit};
-use crypto_secretbox::{Nonce, XSalsa20Poly1305};
+use poly1305::universal_hash::KeyInit;
+use poly1305::{Key, Poly1305};
+use subtle::ConstantTimeEq;
 
 /// The size of a Poly1305 tag.
 const TAG: usize = 16;
@@ -22,6 +30,7 @@ static mut NONCE: [u8; 24] = [0; 24];
 static mut INPUT: [u8; SIZE] = [0; SIZE];
 static mut OUTPUT: [u8; SIZE] = [0; SIZE];
 
+#[cfg(all(target_arch = "wasm32", not(test)))]
 #[panic_handler]
 fn panic(_: &core::panic::PanicInfo) -> ! {
     core::arch::wasm32::unreachable()
@@ -85,15 +94,11 @@ pub extern "C" fn seal(len: usize, block: usize) -> usize {
             &mut *core::ptr::addr_of_mut!(OUTPUT),
         )
     };
-    let cipher = XSalsa20Poly1305::new(key.into());
     let mut at = 0;
     for part in input[..len].chunks(block) {
         let (tag, data) = output[at..at + TAG + part.len()].split_at_mut(TAG);
         data.copy_from_slice(part);
-        match cipher.encrypt_in_place_detached(Nonce::from_slice(nonce), b"", data) {
-            Ok(mac) => tag.copy_from_slice(&mac),
-            Err(_) => return 0,
-        }
+        tag.copy_from_slice(&seal_box(key, nonce, data));
         at += TAG + part.len();
         increment(nonce);
     }
@@ -118,7 +123,6 @@ pub extern "C" fn open(len: usize, block: usize) -> isize {
             &mut *core::ptr::addr_of_mut!(OUTPUT),
         )
     };
-    let cipher = XSalsa20Poly1305::new(key.into());
     let mut at = 0;
     for chunk in input[..len].chunks(TAG + block) {
         if chunk.len() <= TAG {
@@ -127,9 +131,7 @@ pub extern "C" fn open(len: usize, block: usize) -> isize {
         let (tag, sealed) = chunk.split_at(TAG);
         let data = &mut output[at..at + sealed.len()];
         data.copy_from_slice(sealed);
-        let opened =
-            cipher.decrypt_in_place_detached(Nonce::from_slice(nonce), b"", data, tag.into());
-        if opened.is_err() {
+        if !open_box(key, nonce, data, tag) {
             return -1;
         }
         at += sealed.len();
@@ -137,3 +139,106 @@ pub extern "C" fn open(len: usize, block: usize) -> isize {
     }
     at as isize
 }
+
+/// The key stream of the box, after the key of its Poly1305 tag: the first
+/// 32 bytes of the key stream of XSalsa20, as NaCl secretbox.
+fn box_stream(key: &[u8; 32], nonce: &[u8; 24]) -> (salsa::KeyStream, Poly1305) {
+    let mut stream = salsa::KeyStream::xsalsa20(key, nonce);
+    let mut tag_key = [0u8; 32];
+    stream.take(&mut tag_key);
+    let mac = Poly1305::new(Key::from_slice(&tag_key));
+    // SAFETY: the pointer is to a local array, and the write clears it.
+    unsafe { core::ptr::write_volatile(&mut tag_key, [0u8; 32]) };
+    (stream, mac)
+}
+
+/// Encrypts the data in place, and gives its tag.
+fn seal_box(key: &[u8; 32], nonce: &[u8; 24], data: &mut [u8]) -> [u8; TAG] {
+    let (mut stream, mac) = box_stream(key, nonce);
+    stream.apply(data);
+    mac.compute_unpadded(data).into()
+}
+
+/// Decrypts the data in place when the tag is the tag of the data. The
+/// compare of the tags takes the same time for each tag.
+fn open_box(key: &[u8; 32], nonce: &[u8; 24], data: &mut [u8], tag: &[u8]) -> bool {
+    let (mut stream, mac) = box_stream(key, nonce);
+    let expected = mac.compute_unpadded(data);
+    if !bool::from(expected.as_slice().ct_eq(tag)) {
+        return false;
+    }
+    stream.apply(data);
+    true
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crypto_secretbox::aead::AeadInPlace;
+    use crypto_secretbox::{Nonce, XSalsa20Poly1305};
+
+    /// Bytes that are not all the same, with no random source.
+    fn bytes(size: usize, seed: u32) -> Vec<u8> {
+        let mut x = seed.wrapping_mul(0x9e37_79b9) | 1;
+        (0..size)
+            .map(|_| {
+                x ^= x << 13;
+                x ^= x >> 17;
+                x ^= x << 5;
+                x as u8
+            })
+            .collect()
+    }
+
+    #[test]
+    fn boxes_are_the_boxes_of_crypto_secretbox() {
+        let sizes = [
+            0, 1, 31, 32, 33, 63, 64, 65, 223, 224, 225, 255, 256, 257, 1000, 65536,
+        ];
+        for (index, &size) in sizes.iter().enumerate() {
+            let key: [u8; 32] = bytes(32, index as u32).try_into().unwrap();
+            let mut nonce: [u8; 24] = bytes(24, 100 + index as u32).try_into().unwrap();
+            // A nonce whose counter of blocks is near a carry.
+            if index % 2 == 1 {
+                nonce[16..].copy_from_slice(&[0xff; 8]);
+            }
+            let plain = bytes(size, 200 + index as u32);
+
+            let mut ours = plain.clone();
+            let tag = seal_box(&key, &nonce, &mut ours);
+            let mut theirs = plain.clone();
+            let mac = XSalsa20Poly1305::new(&key.into())
+                .encrypt_in_place_detached(Nonce::from_slice(&nonce), b"", &mut theirs)
+                .unwrap();
+            assert_eq!(ours, theirs, "the data of {size} bytes");
+            assert_eq!(&tag[..], &mac[..], "the tag of {size} bytes");
+
+            assert!(open_box(&key, &nonce, &mut ours, &tag));
+            assert_eq!(ours, plain);
+            if size > 0 {
+                let mut bad = theirs.clone();
+                bad[size / 2] ^= 1;
+                assert!(!open_box(&key, &nonce, &mut bad, &tag));
+            }
+            let mut bad_tag = tag;
+            bad_tag[0] ^= 0x80;
+            assert!(!open_box(&key, &nonce, &mut theirs, &bad_tag));
+        }
+    }
+
+    #[test]
+    fn the_key_stream_is_the_same_in_parts_of_each_size() {
+        let key = [7u8; 32];
+        let nonce = [9u8; 24];
+        let mut whole = vec![0u8; 1000];
+        salsa::KeyStream::xsalsa20(&key, &nonce).apply(&mut whole);
+        for part in [1, 3, 31, 64, 100, 255, 256, 257] {
+            let mut stream = salsa::KeyStream::xsalsa20(&key, &nonce);
+            let mut parts = vec![0u8; 1000];
+            for chunk in parts.chunks_mut(part) {
+                stream.apply(chunk);
+            }
+            assert_eq!(parts, whole, "parts of {part} bytes");
+        }
+    }
+}
diff --git a/backend/crypt/native/src/salsa.rs b/backend/crypt/native/src/salsa.rs
new file mode 100644
index 0000000..1c92107
--- /dev/null
+++ b/backend/crypt/native/src/salsa.rs
@@ -0,0 +1,228 @@
+//! XSalsa20, with 4 blocks of Salsa20 at a time in the SIMD of WebAssembly.
+
+/// The constant words of Salsa20: "expand 32-byte k".
+const SIGMA: [u32; 4] = [0x6170_7865, 0x3320_646e, 0x7962_2d32, 0x6b20_6574];
+
+/// The size of a block of Salsa20.
+pub const BLOCK: usize = 64;
+
+/// The key words of a 32-byte key, in little-endian.
+fn words(bytes: &[u8]) -> [u32; 8] {
+    let mut out = [0u32; 8];
+    for (index, word) in out.iter_mut().enumerate() {
+        let at = index * 4;
+        *word = u32::from_le_bytes([bytes[at], bytes[at + 1], bytes[at + 2], bytes[at + 3]]);
+    }
+    out
+}
+
+/// The 20 rounds of Salsa20 on one state.
+fn rounds(x: &mut [u32; 16]) {
+    macro_rules! qr {
+        ($a:expr, $b:expr, $c:expr, $d:expr) => {
+            x[$b] ^= x[$a].wrapping_add(x[$d]).rotate_left(7);
+            x[$c] ^= x[$b].wrapping_add(x[$a]).rotate_left(9);
+            x[$d] ^= x[$c].wrapping_add(x[$b]).rotate_left(13);
+            x[$a] ^= x[$d].wrapping_add(x[$c]).rotate_left(18);
+        };
+    }
+    for _ in 0..10 {
+        qr!(0, 4, 8, 12);
+        qr!(5, 9, 13, 1);
+        qr!(10, 14, 2, 6);
+        qr!(15, 3, 7, 11);
+        qr!(0, 1, 2, 3);
+        qr!(5, 6, 7, 4);
+        qr!(10, 11, 8, 9);
+        qr!(15, 12, 13, 14);
+    }
+}
+
+/// HSalsa20: the key of XSalsa20 from the key and the first 16 bytes of the
+/// nonce.
+pub fn hsalsa20(key: &[u8; 32], input: &[u8]) -> [u32; 8] {
+    let k = words(key);
+    let mut n = [0u32; 4];
+    for (index, word) in n.iter_mut().enumerate() {
+        let at = index * 4;
+        *word = u32::from_le_bytes([input[at], input[at + 1], input[at + 2], input[at + 3]]);
+    }
+    let mut x = [
+        SIGMA[0], k[0], k[1], k[2], k[3], SIGMA[1], n[0], n[1], n[2], n[3], SIGMA[2], k[4], k[5],
+        k[6], k[7], SIGMA[3],
+    ];
+    rounds(&mut x);
+    [x[0], x[5], x[10], x[15], x[6], x[7], x[8], x[9]]
+}
+
+/// The key stream of Salsa20 with a key, a nonce of 8 bytes, from a block.
+pub struct KeyStream {
+    state: [u32; 16],
+    buffer: [u8; 4 * BLOCK],
+    used: usize,
+}
+
+impl KeyStream {
+    /// The key stream of XSalsa20 for a key and a nonce of 24 bytes, from
+    /// its first byte.
+    pub fn xsalsa20(key: &[u8; 32], nonce: &[u8; 24]) -> Self {
+        let k = hsalsa20(key, &nonce[..16]);
+        let n0 = u32::from_le_bytes([nonce[16], nonce[17], nonce[18], nonce[19]]);
+        let n1 = u32::from_le_bytes([nonce[20], nonce[21], nonce[22], nonce[23]]);
+        let state = [
+            SIGMA[0], k[0], k[1], k[2], k[3], SIGMA[1], n0, n1, 0, 0, SIGMA[2], k[4], k[5], k[6],
+            k[7], SIGMA[3],
+        ];
+        KeyStream {
+            state,
+            buffer: [0; 4 * BLOCK],
+            used: 4 * BLOCK,
+        }
+    }
+
+    /// Fills the buffer with the next 4 blocks, and moves the counter.
+    fn refill(&mut self) {
+        blocks4(&self.state, &mut self.buffer);
+        let counter = (u64::from(self.state[9]) << 32 | u64::from(self.state[8])).wrapping_add(4);
+        self.state[8] = counter as u32;
+        self.state[9] = (counter >> 32) as u32;
+        self.used = 0;
+    }
+
+    /// Puts the next bytes of the key stream in `out`.
+    pub fn take(&mut self, out: &mut [u8]) {
+        for byte in out.iter_mut() {
+            if self.used == self.buffer.len() {
+                self.refill();
+            }
+            *byte = self.buffer[self.used];
+            self.used += 1;
+        }
+    }
+
+    /// XORs the next bytes of the key stream into `data`.
+    pub fn apply(&mut self, data: &mut [u8]) {
+        let mut data = data;
+        // The rest of the buffer.
+        let rest = (self.buffer.len() - self.used).min(data.len());
+        for (byte, key) in data[..rest].iter_mut().zip(&self.buffer[self.used..]) {
+            *byte ^= key;
+        }
+        self.used += rest;
+        data = &mut data[rest..];
+        // Whole groups of 4 blocks, then the end.
+        while !data.is_empty() {
+            self.refill();
+            let size = data.len().min(self.buffer.len());
+            for (byte, key) in data[..size].iter_mut().zip(&self.buffer[..size]) {
+                *byte ^= key;
+            }
+            self.used = size;
+            data = &mut data[size..];
+        }
+    }
+}
+
+/// Writes 4 blocks of Salsa20 from the state: the counter of block `i` is
+/// the counter of the state plus `i`.
+#[cfg(target_arch = "wasm32")]
+fn blocks4(state: &[u32; 16], out: &mut [u8; 4 * BLOCK]) {
+    use core::arch::wasm32::*;
+
+    let counter = u64::from(state[9]) << 32 | u64::from(state[8]);
+    let lanes: [u64; 4] = [
+        counter,
+        counter.wrapping_add(1),
+        counter.wrapping_add(2),
+        counter.wrapping_add(3),
+    ];
+    let mut input = [u32x4_splat(0); 16];
+    for (index, word) in input.iter_mut().enumerate() {
+        *word = u32x4_splat(state[index]);
+    }
+    input[8] = u32x4(
+        lanes[0] as u32,
+        lanes[1] as u32,
+        lanes[2] as u32,
+        lanes[3] as u32,
+    );
+    input[9] = u32x4(
+        (lanes[0] >> 32) as u32,
+        (lanes[1] >> 32) as u32,
+        (lanes[2] >> 32) as u32,
+        (lanes[3] >> 32) as u32,
+    );
+    let mut x = input;
+
+    macro_rules! rotl {
+        ($v:expr, $n:literal) => {
+            v128_or(u32x4_shl($v, $n), u32x4_shr($v, 32 - $n))
+        };
+    }
+    macro_rules! qr {
+        ($a:expr, $b:expr, $c:expr, $d:expr) => {
+            x[$b] = v128_xor(x[$b], rotl!(u32x4_add(x[$a], x[$d]), 7));
+            x[$c] = v128_xor(x[$c], rotl!(u32x4_add(x[$b], x[$a]), 9));
+            x[$d] = v128_xor(x[$d], rotl!(u32x4_add(x[$c], x[$b]), 13));
+            x[$a] = v128_xor(x[$a], rotl!(u32x4_add(x[$d], x[$c]), 18));
+        };
+    }
+    for _ in 0..10 {
+        qr!(0, 4, 8, 12);
+        qr!(5, 9, 13, 1);
+        qr!(10, 14, 2, 6);
+        qr!(15, 3, 7, 11);
+        qr!(0, 1, 2, 3);
+        qr!(5, 6, 7, 4);
+        qr!(10, 11, 8, 9);
+        qr!(15, 12, 13, 14);
+    }
+    for index in 0..16 {
+        x[index] = u32x4_add(x[index], input[index]);
+    }
+    // Lane `i` of word `j` is the word `j` of block `i`: each group of 4
+    // words turns, then goes to its place in each block.
+    for group in 0..4 {
+        let [a, b, c, d] = [
+            x[4 * group],
+            x[4 * group + 1],
+            x[4 * group + 2],
+            x[4 * group + 3],
+        ];
+        let t0 = i32x4_shuffle::<0, 4, 1, 5>(a, b);
+        let t1 = i32x4_shuffle::<0, 4, 1, 5>(c, d);
+        let t2 = i32x4_shuffle::<2, 6, 3, 7>(a, b);
+        let t3 = i32x4_shuffle::<2, 6, 3, 7>(c, d);
+        let rows = [
+            i64x2_shuffle::<0, 2>(t0, t1),
+            i64x2_shuffle::<1, 3>(t0, t1),
+            i64x2_shuffle::<0, 2>(t2, t3),
+            i64x2_shuffle::<1, 3>(t2, t3),
+        ];
+        for (block, row) in rows.iter().enumerate() {
+            let at = block * BLOCK + group * 16;
+            // SAFETY: `at + 16` is at most the size of `out`.
+            unsafe { v128_store(out.as_mut_ptr().add(at).cast(), *row) };
+        }
+    }
+}
+
+/// Writes 4 blocks of Salsa20 from the state, with no SIMD: for the tests
+/// on the machine of the build.
+#[cfg(not(target_arch = "wasm32"))]
+fn blocks4(state: &[u32; 16], out: &mut [u8; 4 * BLOCK]) {
+    let counter = u64::from(state[9]) << 32 | u64::from(state[8]);
+    for block in 0..4 {
+        let mut input = *state;
+        let value = counter.wrapping_add(block as u64);
+        input[8] = value as u32;
+        input[9] = (value >> 32) as u32;
+        let mut x = input;
+        rounds(&mut x);
+        for index in 0..16 {
+            let word = x[index].wrapping_add(input[index]);
+            let at = block * BLOCK + index * 4;
+            out[at..at + 4].copy_from_slice(&word.to_le_bytes());
+        }
+    }
+}
diff --git a/backend/crypt/secretbox.wasm b/backend/crypt/secretbox.wasm
index e64e3de89dde6526d2a33d725ba058f6e332ee6c..4b986b9b1c2c3b2b00e0b39b95a5bb83b6b69a20 100755
GIT binary patch
literal 12346
zcmeHNO>7<4b)LC1?~n6-hSV=bNj!H%$xr+fMN*FvMM@l@u^|{~oqd6bmgrcI5-IXg
zQXC87lOiW_<ECosg<GV60|c<qT7{CPZPKPK)4HwEZd9}=lA;SOTA=Bo(4vbhLa^UC
zcZM3ydvfeWffkUcnK^ULx##EJJ9o}^=UKCj%eG}%_Tl_Fd(~dW$vS7@KS;I83}<x}
zEEi{7z_J{_V%f@Z95<8AI&RL%WE|T%nk}Gx*ley@UhY&rdwK5i;__?C%3NHya&^UW
zocX!eEH|^TxNv^X%D9VH<`%4McJb;8OFP`g-0UUGa~l`GG-s7M-uUH8w{5Q;XyTt0
z`tyNJ)}&P-d&sJIKk3fwUbS!TcwOD>d_7XR=Rl{=s9RO_gEyMDEUiM2?|*r%X=#Va
zZwcu#`L2)|CchzMmdSU7%rW`4ka;HW30YwB10g$@d>}47Cci6Wk;(4~SqlIA?{57#
ztIOec{^jo9=X53fua9p1mZSaf-yi?*YgyeHcIYl=hB8#Hhq>#NYXmta3)iXG2)0qK
z9+s|CrV(tXZS}D0I+YtinLMh9c1I(~2;owvT(gZJ%OskY8o>_AN^`dn>}&*XWVb-R
z=&D9gWD>egBiPjl9CBlC9ppsbbQ!T_*dO%rjUX>7UL)8|AQ4cd5qMM-i`x+nd7`<a
z5tInAA$a7Ws3f{xLsw`Q{-6&@p%D~>?>7RUV?_t-W^*R0Z5$xXK~wTVBlz<h+NT`t
zq#bhG*$7PPY%EHh!z5TnL+MWwXlFxrQdhWI54uVgMoVM(534m9rf#xBD{QKtc@`)c
znwn}V&@x;#^)_hgo^ak_o(yG8y$||~HQ~I=S03iC(1iK{E2^6M9$!l}^<BOeYw7`C
zJ8S9=U;Uc8%hyUxy~WpZP2J<GS5qJ0x?Z$W|AIa1p8JSZn0UxKmis^jJ=C*aDwfKX
z<e~SH@biTZFL~&FhL49empt@-!{<jidFWp1es8@~6L~mmD&rhb1?L0g<J?D`I3HXu
zE?l6o<e?9(7e|L)el2<E=hlmJU%WD#JaiRZu03Z);g3Aryil_6KzN*<`bLyqG9;#h
z!@8di=mF}}gS1Z%(SAMrB;lm?lXSToV#)eGE9gFB-w2MJp}X&`@5Q*DQ8$7SbEk0U
z+<=0}oZzS)ePSjy!B;vWZAWlM8=ReBOpjBbk5N_kP_M4hAw59{^>KPmpCHncv{#=b
zt*7v~PtnQs-?xM5Ft`4DHcf}!>-X*TmuO)9bHP9?Dj3l&BkG4}8VYFDAC_3uA8s?E
zDTq$dG>fLfE*4FNWg|KX(Mg)56GkZBrebeH5Kb9`BIu6=HOwmUvz2`e`p06CMAsii
z(TziNnvR)PTcfK%G=rmN^6C$_wmeP~?R<@*MZXb^n-=4-uVIKn9K%%OmgA;3#*@7<
zM8ifTy)mBX4UE7P{-i(Bh6iDEklRfelT)$DNeCt>5^e3^6A+!Ce$#4e_nw02DV|P4
zG)~g@qsG^0?2E^Fl*ZZMDKnU-;_%@M6Dh=>_)AZN<7j!D+x44v{c*bq2qxme**c^q
zvuFgi4$L%K_0uF9oHj8|$1$3TAVEwUU(*R+nDjGr+O(6-+7$M{WRID{>6tIVo4GY@
z#(O#*Zy6Sn%+i6F=S2o49SD5kDfD=`_psb!<+KlDr9R`{Fbg&w>MF<BL&xbL6UWy}
zyh`lu-qXX2>E3<&d-1>xQXdNkX@CweG0;ZqwBd0pZp|&RNUy;oO`{`9yjt*j>vwi-
z+rDGxE(n_}gli*Y0V}XDI1Zoi!i~1@BhM)>Gq7_!)=xRXtBj6OAj#1L9b#glP5c8`
zAc%#N)K7<*IMzn1zipNeIgtTO$aY!YV<A7_t=UY#C%m*|8I3|J%a>qhBJQnJmOf<T
zG$zT>C>>>@-B@A~q~}<80?)r@VyaD+?R)tVCo=hzZhn`Ao6&6<vkCZwmrt1Gxul&`
zmIPUidO7SG4by%m+KuIL8lrtB%agR1iODuuo@_gokIisF*k;B)U}3H8Sk{mwytHH)
z#g`h(D@i-4EJv^c?6goU+uAGI{Lp&!AqxyV$aY<O;DirV9d#;|CoPLyaD%c&Wg8Mo
z2ahbSkJNuCvO=q-eu}G9N{<w{AIe=-{i_P|*TRjB(@Qn=Z?OiKR8{LARj96UMPOI$
ze^#LjTKGR!VHUKrUfkH&a2y;PYdB6ncGiCpmj4M#T)VCD6#+PpW1{JRgN5g(YQp&u
zGeJKF&F+}K>r6O^R_G>Zlz50Z{80U@1L@h}J*RG<jQ6`)pdi$!){rH5gEI#Z5?ak5
z-wk_-tmjcbiO#pVtc`SpZqfKoLPO{ljXy|e2;HI~a3}I2bc@CxCTs}ZqVY!w4WU~!
z{y3o_bc=>yttbwmTQt6(upxAd#-AiKgl^IJ(}af5EgAwgqd0_a(fG534WU~!{yd=}
zbc@DcBs7F>(GXA*#UXTy#t#!Vgl^IJ%Y=r|EgFB7&=9&s<HLl8&@CE&ozM`vMdNQ0
z8bY^d{B5K$X$j?dc`JOt@SF*O?80F!@0)wv^6K{2ohSPR&Fp-j%tIEgYDb=>=Iu4>
z#S$LC&y*~|CU)r80~dE>m4FnrQ&e8~t=sSsPK0ZG^}pI|HZ3ecD!c>i{GqDrjEO>L
z(ICfWQ24uqRg0{%JwZP7KU-38mk+Ph0bO(TzzJ``@h`zkF8qkYt?Ldb6xeSEWf21v
zcwvZ~__x?4sZE!%Xei1YRwENwav;e7M-dhztTE=s#|;)Db7SG=qo_HIe1w&?g9`p#
zV|K{8<4_jM@AEzw>}be(LpXNCSz^{#gr$<KuL{davhE7YO|sq;Rwl{%6=7wQtgi_x
zmt?&qtbCI7tHLTISzi}cN0Rkx!t#==d%`LvS-&o<Qj+x>!YU_OzbULr%nI!#(@VS#
zf2QP+s^WDJFs6M`M!5irJl?)4kd5IlVo)(JN*Lc_=%2+1LtMw3u0vzLAbh;BVJ!tE
zUBR5e+hN_ZEZ}dP*FU%Jf#wMb#WG*YRN*O9;TK?$O3#<@=EQX#do3m2K#Hc44G$&w
zKm%hGLrZ0x8vH7?v0R8jT-YG$W;V#L)cm}*6s92+=YyP?i$%;#Qf3dr$7Vq59z-Vz
zKe_+FwC*x|e(@&{z0L5sh)5oKJKPl1J4){m;%%jO3h{x`yM%aO>D@xyQ@UG-x0K!^
z#9ajlz|HR{y;q2)()*klY%!oS%oc-0ne@nXupfILdo)px*3_i~+QwTRoG0gy)P9mp
zQo>sdeZ0kRFy3P5<1L0m@fJfLZ!z@6TMW<X>Ju|tj31OOhC{N&&?j3Ay!X+q2e9wq
z({}8C?8N@ZUhIGD)<<ZE9-&Tsly>P+3~*EmkC`oou^8JEFc_ICdCUN<u^4FeLNsQO
zK(9f3y)oirI35+*qXzMf#)$7IL`P|aj&QL#YP^lc-U0|mS<q_)y|G{ro!N$M09_;!
zJlY#a$H4fQ0gvhE7$NdD!=TBl*W|U?a+rqN`KqEtuMwp;B@RHusQG{a{b{7ly%88Z
zn8w=Z4UE7j{-i(BhBaCW_DIA25eP;MEJ=6p5r~eM(m&n3yzTN7PmIy~N&3EO2D2Iu
zCXaK~>>-Ss!Q9*-fiFy?3H%AvNOv@Ey~xf=uW8pCPXgXb8j1%;wiq@?+GG}uz}6uh
zL#tjI;lUX*F^<JCnu#Dmj2T~J3167>HM60S7Wy#hn>n1G`4YUDcIlZf!$Oi-IuP@`
z$e6Y9g{RQwrP9VyiPgM_w<vJO8oyvwa=Ss{0T)>2)3AYM!);*M7-_Qwf|Un20^LGw
zv?6exf>mq0ypP40I)$s6EQISeAkBwQc;RJd3v`X*OL>_|+DSR#H`oAmbJ#vm=uRev
z+QdJM#bO5wN2u2T*>+jB2jUMok>RHR@p~pq_-x6>htGCdM)9Sxd`Ys5?4+{vA&YiN
ze5#V{D74S=2<_%9k6<m>CF!>5i&4W%`F~`xgpd<S1@P|2WqAZoQ)~9^vpn}PSrTM}
zw4KBD=>TnGVz5p8LljUK3y0|_z6Nl*ZL|;*za3LqKITM*;($|GJ}_CrXPdDc#^Tz_
zkK#*txguFcc2Z78P-i!loX+;>f|^k?xG}{TiXg5M3gKgCDJZ7vF!$%xVJMcQ4(q_D
zE;fVO3FVmLyH8bpDJsZ%g1Vebt{fFmgGpVM#rHRz^>0gQ?&usNlcI})Ek{n+1da$F
z-d+PPd6N}T8FDGg|KCn>8SyZhXlA2*268+H+COnr5g%5ce06mVLPA~Pz`W1L*&x#s
zWal+%U3|MU2!}E#WHEH1<$s<1@+OYU(u|rxD?qJ07m)bcN_l*1^U&d0X1Hv_K$}cx
zOFhb)JH`l7(uy1|Z(+Qu2KiJ4TH1519%OOm`;mH(iOBJKpg@M1ODyQC2RZEaZ1gSx
za%F(DSS!aT$FL!1=mkbL((AyUG2dsRd$cO@y^0%@LL_$%TTfx{HK~*%#Vk2XsL6Y;
z;#+ENX&H|9tf0g4OO&O;((*DsOCll*LDVb@$>gxD1d+D{r4G^GzOsCu>|@HkfjN^u
zd;dn@pRyP<=E5SY7Fjg|)ofUfRP#5;M=2?qd1z+Cu4{zSpEcFea+r_wijm$atBAh!
z<Bg^3TfVMG<IInOnt?H(7a7nOOE&IoAlC5BCZ-ie%!wgy`0W<XfBt+9u(<#e?{{{8
z93%(UHo=&HWM;?EoPjt;wSaHi9Fcu#KD1t_hwchl^-WESC)iU^Ip%W?^OaK+OkPL7
z@YtO#VZudd92Di|12?RE7P!u3sO3`rg_4UgG0+Ng3NVbJy3B4sb<FPn1)QFMlz5)7
zae&1OkP^|5`|*&{1*E(Z<4Kp?7CgxlLiSNV0iOJk*_z;I_6eSZ(JgqAw`RrQQ}JY;
z@ubItBa38-5gC8e{(p%l(HYP1<TE_^3{P(T;{FUzeri1FazWuf!;>yv+RyMLqZ#=r
z0x-`rJQ?-H|6M%EAWM)I@T7e5!ObR~ETJCCCGcdT4%@_&PpiXn5uPkDf`pkAp8Uks
z7tpTYN&YaPQN3|x>m~4{DU@+GAA|DI$Djh2H~1dJ-yXI=PX0omlJK#T0H96&2p0oT
zKqlOU+rmczK;zG4C|>=y7%DyuqV{jWC-IlM@84n&qQb{XV>$eU^Y)tM{ezRUZ`!L0
zhl?Y7lMDQ+<>2GK0cwQb=T__YQR#!&9=P{|%uUw7S9Au7%<Y3X%f#*=cR$GAyutD;
zeiHCRWe_R_vW_V~=rHmE<2ke$fdpW+stCX_bLoCif*iNw_&AST^Q3y}Y_Eu4B0#mw
zvb}*VsuidL4c-KZ$bc*mx5W>BaV}%}ur*&)O02?;3nIj?W<|wim76z$%9%ZP&mf(R
z%9jBRlQ*63nH*|B(iVK>*^qrd=n`A()Dyd9aow40TH0(nB2BxvX%X%a1ox3AF=Oil
zbSc@;*=#t@4Iz3DaZ)8>V+S>ksgDPX(Y7DUYO3mazwOxEcNpD!&gF|2=oDR=TiDsS
zbn*NgU0k>@_eE-~%r37qXm*9xO7!y86`EVPU~a9h<=KTV%o&YHdo3XR;+z&=AtQTb
zahZ%YuweQNE3eX;<r^U^eX3@S<?}}_U3__XxnVKcn7!1P<(ot27q7hb`B#<~FMnQq
zO;Tg=>M}Ago+G!_wSmKQVR5cO3yUjsd3NRet8`(mv2t-?cID#YLR#5AY~kMrmT&RT
zhA-jx1svyJy}B?@{3Ck0e6_JcFVDf+!qAuImKUvWLKpDVTE)?eBfh_rx<8Nm>4f|O
M=yKwo<r>HT06m{L;Q#;t

literal 9633
zcmeHNYj9oHRo>^Ed(M5Fdv%Xw`RzpOY)iIeTebqWoE%cyCqo@PB@|}*qtKLCmalDH
z$&z)?^(%2L`IS0Jn}&A_DTESmC^du@N(%wh@(OK%@-OfYriGM8F^?YsBE+}W-q$|P
z9T>_m!wiEo_kL^d^X=zZYp=Doq$aYHj#A1QDIIneoQ1<m9d;KM)M0Odza4xOYEgyn
z0_ql&*Vn5Y*DLtG9~3>$4_x2#JxARal+i=FxVWUk;=WRFvT<^*b>3C})a<F#ZRLB@
zjq@t-XXj=o8>(2CJJpy~rC{!Ko1az-Sz}^G)e70v;|*1>eC%NFddFGVyoeu_M$_6M
zm8d#7qpBW$Jiwz=rD{~Yac%LEN}Z<0Q<2>Rq|y~<p47n_7|i+S97p6X#=qnkB6l(V
zHOCOSi}7ZTA#xXEImZyWi}7zchR9uvl^jFlF2>@McXmYNF2<!CL*y>T<s3ugF2<D{
zL*y>T)f_|QF2=PSL*y>TlR1XSU5xkV7$SEuuICsccQKyIF+}cSJe^~R+{Jh%#}K)T
z@qrve<Sxbsa}1HY7|-SyB6l%9WEqJPDGdLt$E5}532R7ScBZvEC`Luju-X)R4C~?o
zLx1cuL~)R+VOQQ+Tx3zyC@!%mnjM!}6myF!+@u<Z45hfrP>5>`D(*=?`KQ;vSd5+Y
z>#tt=h!@w>uipCHGeI1s|MZ1Re-gyKX(jIS4p2b7&9r!ys+q2`SUyYTOs}G9Gp(Ja
zAk+P{s+snkrQS^U5=IoZm+3$RpCZ99(;<s!Udr@p3Z=Q9={1@5ZNEKK7j7}rWfs9L
zWO{9;3*>i3^Qd4)i+eG*fX4%`mg$;MDw$qK5HTSq(-kU9kNubqRfM@Z(<Q>(FnO$_
zNG0J`ve==u_yr$NdNSQ3_4Q2Gd9K)ib=;kq)heDKx&u?zg+>^!p2c;l(i&PV#VFHe
z>D-xJI!}|(GaAZ%nu$hP98q7o(A0f36_QI)qP7F-iP{Qq615r7o2UUmB~cpzQCd2q
z{X}gOIXa_*M2(2N?u_n9)G*{abE=8jA~HB(qJ~5Ur;w;Y$PROAiP9p2vno-s$l$C_
z6hZD~&e}xXD>67<qV5qHoW4YDf?Q!vf1);s49=QFt%qDr)LN+mbzP#?aTQb7Cu)tz
zpl(RiYLUU&n5cfpr9`b_VCtqs^@$AXJ&EcS8Pt0d6+tet>j5xzAW=OcgG!02i41C-
zs4BV3RXEeTezaZ=-5IbLFIfD5V}<7-r0`vzU=*tucTeCMdOHrl0LK6rvjM;~jsh^L
zNdV?~1c0ee0I-_F0IcmX0G9i`0PMhf0ob5N0oa@O0I+M{1HeXpHvsSY-56R7b=-Xy
zxeuwm?zi)#MqD{A_qyMTk{IwfoU2QC8~XuxLHhuBXKw>Qa~=fXZGH;?FE|0<oj(A8
za@`MrHtYpJLB;{lnLPmL-);c3>6-yiux|oD=k5bQMaM9-oEhWp4%A=^3rpB35nkpk
z+tI|=%P>%iu5hS;15u5;pK(aZe!s+myR6U(yMI+m!|p4rk?G3H{`qnD#SVkJ8&;ok
zQuoaACYGH~J81#3%k`gi(g3ozTwPgN@jQH1mhjns%Uk{q^!$U;3ucpEb>6HfjL9!m
zW(fR6o+<E?7C&Y2mn{CW#ZO!O6^mGgwEL{ZU$yva7GJUW>lS~*;%{19viLcRpSSp1
z7Ju8~?^yg@i@#^_Rg1rG@e3BeXz@!H|G?rOTKpr6IAD0$I6oM0bTHu5V8E%vfOCTZ
zM+O5<3kDoT3^*?sVgqCV=Mz`roM6Ba!GP0&0f!a?&Ibk@4GcIA7;r)`;6Px&S-^l}
zfC0w<15N-27(WB-o&k2x0F!5cwKKrb(=R(s<4D8TqjGh@x#&DmfTQJ4{~d>m$kns{
z7A}+EXc3SuI<fB_xbsVRG^m4g;o%xICoZ}N$bUPF>5?LUn!{OLe53|Nq~dg33~><c
zZ$clbkS=8JsJS82y%4&;q?&L&epC9e&2{+@N5XN1yG_U5fsP&c>vDQa&Fe~Bg#$*9
z%StH<`Fr`hmP3})s0mt;p-9#AR8v>kb-*hf<iQ+xCp@U|Xd(K5n}Zh{Mav?-vV;W$
z=AeWepNE(mmRI${5OXQ<;<3I6Q<K@a>8+I&%m*RFH#i?0eFtj}&!@zLp*W2&gg1dy
zlQ+c9F8q(ChDBD{G4krLljJtz8m38JT5m>I`A`vuS)Pt@l)-t&7|c!g&&M@cLI7XL
zFAMK*2fyB7cQ_6RrzgQxt7YXX9W8J45J~{txR1e!S23u#Ul@^I%?x;TW~^m!;&luv
zUN4L>y@44U3E;+?7@YVX1{L3n{T#ri)gPkkH)5jtjW|YNrKum=ac^9v_3>s}hgGgZ
zuy#*8NCEa|Z9GJq;w{t{Z>5cKi3*7QdgEbQ6OW)PpF<YJBg2^<W)acPNT#>Zu!I$e
zsJ7EK2|y5Mm1u|qHL$lJ%o3qYMZwLP-pnGJ$C=(io25BIqEQZROurQy`cS4vSOj-4
z(>pUgXyYV|wuJ`mXqc&wUyKLd)=Y1e9)~hLL=X`mNysxIqi^S^&oFmnI=1m0)<G0o
zE;eE(e!)kygs=|r7W$BQ3v<Piq-Qg$Z9KstVamGDNVwS8VHzbI{U{==G)w2s?9zFf
zHj<P5G!rdmcsrW)PP0|1<@Z8ic9FtsbS~)nUif~82GXG2#J+D6>ntuK_+{U;m7UTs
zyb+Y>=N)UWh859futH`HF>8cbt2?ZS42x(N#o!Tmc!r2FXfoSJ<jYQuPXMyqF)D*O
z$USahPKkTm(CKlEdN51a_W+DLv^p5D4i-YHv0XSYmL;+6wM{4`TSTOHu{Mtoz=cu*
z9P9=_K~-}$Gi+=oHa0V4Y$k+qZ)ZCj(>-{B1<`2Yiru;w>dY3X`=BWh?$@iJ<PaXz
zoZUd!q1VJ^sCb$6p`+pu?^bcvQLEz6KOd)@F$kzQ0&z5}TD28bxUIGw6^9lMa4uu|
z9kS*iDh~B9stXn0%IXQt!)RNq{`wiFS;nui4wwye)hee|Td_H#;yF8ligzqVR6J)f
zcT}9!`L>?2IbtO_O%)Y4IY&;#MN@}qz^XV~$6IZKr)h0NRNUBCn87x-vx;vQ6^DBD
zH^&hJE82pDZrnWwX)6-5akmYrimYYaJq4*uYaq=)Dp4P#6OafhI_@5YGzcXfcMn72
zLl)M;wxUGui>#$E5v%vRSW83qJMlDx4#OZEs6C$Ev7OL8VB8Va(h@r(@u5&gH@%;|
z5qmaG#Ss_r<cLz&_9_S|JPj%t*t?yBcjE=ttS17p3xY$UwN0i#75^KaNOAnU=)ey}
zok(Nb-B)6RlE|m8Tv}R$ouzMF21ZXCk5y9X8&^;cA-vWRBxMhuuR7(<&Dsmz?F)f)
zA@<w@*nq{$OG=^ym@hWR!(PB9)$82La_C85gtGLCvNC}TCJ;4sL0sY6IaW!(g0TE5
zA^_ja1lIs64!i?A4#83K=g>xt0OOIGhuuVg!CA8|r<X8+ccP0ReU7g)nsI=6mAGf*
z;uwWW9AmQ=#t`I2mwCx34WeL2H9<J}BktH<?=_r3<m2EWOqYXNDMTo6ge?VL7?K6s
zWBL;M4X6}7#XVzicT|1F;mb#LFhUiNHmbfVHIA*B=c>PuDmP#Cmr~{Bt6rC?LcZ#2
zQsw8X{z|HXeAQn|RWV=nH&Ru~SN*M2mGf0!m#Rv>>hGi~%var#s%pOK@1?4iulfh6
z>d9CAqg2&9RjD&?c1a@F3comcIlQBirSYpn7>#6>0jVtm5?uzQy$nc#8Kw;Ii$!VL
z0J3Q=ois3OV9vlP19%%uX&J~2v<;j#aK^w{1Lq8!H}JTDCk$LL@IC_<4J;Udfyzji
zEMB&F#o|?q*DOA1@%<LBTYSpm(-xnx$TtPNk`G#Z*5ZdOK4<a!EPlVmAFznbRNDWL
z#UHl#BNjhw@go+0)Z&j>eBR<mE&jO0pRo9X#h<kJF^fNC@kPOLS5muiSF%4z<~dL2
z^d5j400vwVFg$1gM#m+-d;ol#0lAnM$B8bL?=tXi1CJUwOi(ynYr^TqPIO6(wTy_o
zj8g|G$+T8B3wdgBX;Gzn)9ZY$b&gF~eL4NG)I7sY<&?qpvjzj~qWE+}NlwN@6-)`4
z16KwH*n^-{GEg>9F<{l7vq(^EPH8htn{Ub?dpj4knW@cFZPsdYSewz>{MKf>Hutre
zu+57%nelASY%}Nqp3DoL^)TdxU-MkfX6=PB^4EfKGjN0+`y&1v(*8yrOtWjiiOtET
zi=@E@dn$U4cdm*wslZQtxY&q-X)PzXpTeuZ8LAL10zMhAdlZ=S+)r^;#1Ug5bxbG7
zKaq8LCVX%Zz2RaR(VdrWIMYPJyx|O&$C}!=;_jw)A*TKeKNxJnyWqZN0G>Sc*|VTQ
zk-t1sjpt4246erTDx9f;;M+1<Rk`eT8q`uO?r>B0qyuL-w5eNSK;Ar|^0bC8n{Q#@
z4Q*^#X`VG|zSV+n!;Fxgm&dV0&W(}32NceOR1toEyLFSCJ#OIwhku7|UeM7#=oV9}
zOsz822Q^50EVXojB4mBSM38}1^qrwP)tKqdx6+d3RV{CyLcDw@obaID@4G9c@XWjB
z_vzjh3fQ2)!5|K9BGMPxczBeK;iO;cs<|d{NuJYHgWyD5eE5lqQ|iPdFXv(sgdb)y
zcTWe3BasPaGmEQx)*@$SI#mxh(*k12=It29{m(-e?u2{pxF`hQxQ4ZHOJL&`{0$^7
zLH+RtF%mwATJRSFL_2uDhj7+-He!K<&<|=>f23BxIf96$OofMQK2LBuhT_|R1{B<?
zlrXZyOC?;M6pRT#kXsC%L@u(~%?{Aa%SJYVL^g;dU_Hx9A{z;FxWJLktDPqt*>ISX
zq7UTx_L`K}`56qsH4@~YjI-$fJ!GQ(cRXaGewtqr-oejUykYSri$81e;}(C;qWtLq
z?QYsK@_Fg!7cBnQZlV9jy)fp$`I>+PbDYsh=@ia4MB@sYsg(859_Q;g=B;b|zwK^c
zzT<A|AxzLqU(H7x@Gv-B(^ct9Qfm`BY+50D*2E-t=Yg)x13!A1&t%wjzFE=abKxI*
zMO;xYxcC(C2`&<jvSH<=F8?J2E|M=thMPBWra|b}g`3*H$PD~9Md$G#9tZq*oi5(g
zrHdE%d4NBX+@b6MrA%rM?szKZd6^v@+Kk~z$O6Hm`ZG6m4bM^BjepX>st_n`Y;u29
z{A~u*9)7k-J3_643O9KXUeJeFCT@${CVcn6J#uf6P-;x!f$_&(p>TB%d>$wlajo{y
zhU*VuIV<%m@R|8S?+vpC4o%swmAE74rtXuzc+gP#?UA8-^G$2Fn~q7-K5kmYaF_(|
z5$=@n-6PFw`G(%@hP$~T9^Jq^ad&2>(!}Cr>p6JF%i=I3>O4av9fp7IIlOmEDtyg5
zIdzow(M)4@^2F)cY2tsQp_8YxHXUgY{^e%$@kVQIO*S(%*`TS}qm6TvwI^Ebj3(N&
zRHGxO+tipnYKp3_H8Fd<VHlRZqzV72LvzQ-JUcemBGVhHFzWI430hK-d5E6Ap=L{N
zg2uZhCtAnncC{MEr?PhI{I0Auxl5+HbFwwjZe%;B=0@*(VD|%)$L^mTKeFe@o;`by
z?V6lAb)wN49oxBk=Wc0%rj3b{J6oCJ_A^sQSllu>ck29O$69kIACpNZl+B%PVJplM
z?EHt9wvW)!xkiQ!YtzYz_T&jV+Q`~dvlH#9x!Jdpoe>;i>hmg6?*yL1XDdE^PNXWp
cC-51_l^5Sqeh<oT%RPS-a!;<z&trW49Wtbb$p8QV

diff --git a/backend/crypt/secretbox_test.js b/backend/crypt/secretbox_test.js
index 876cab9..0452b2c 100644
--- a/backend/crypt/secretbox_test.js
+++ b/backend/crypt/secretbox_test.js
@@ -315,3 +315,31 @@ test("decrypts the blocks of a file from any block", async () => {
     ),
   );
 });
+
+test("decrypts the box of the test of NaCl, over 3 blocks of Salsa20", async () => {
+  // The first test of crypto_secretbox in NaCl: 131 bytes.
+  const hex = (text) =>
+    Uint8Array.from(
+      text.replace(/\s/g, "").match(/../g),
+      (pair) => parseInt(pair, 16),
+    );
+  const key = hex(
+    "1b27556473e985d462cd51197a9a46c76009549eac6474f206c4ee0844f68389",
+  );
+  const nonce = hex("69696ee955b62b73cd62bda875fc73d68219e0036b7a0b37");
+  const message = hex(`
+    be075fc53c81f2d5cf141316ebeb0c7b5228c52a4c62cbd44b66849b64244ffc
+    e5ecbaaf33bd751a1ac728d45e6c61296cdc3c01233561f41db66cce314adb31
+    0e3be8250c46f06dceea3a7fa1348057e2f6556ad6b1318a024a838f21af1fde
+    048977eb48f59ffd4924ca1c60902e52f0a089bc76897040e082f93776384864
+    5e0705`);
+  const box = hex(`
+    f3ffc7703f9400e52a7dfb4b3d3305d98e993b9f48681273c29650ba32fc76ce
+    48332ea7164d96a4476fb8c531a1186ac0dfc17c98dce87b4da7f011ec48c972
+    71d2c20f9b928fe2270d6fb863d51738b48eeee314a7cc8ab932164548e526ae
+    90224368517acfeabd6bb3732bc0e9da99832b61ca01b6de56244a9e88d5f9b3
+    7973f622a43d14a6599b1f654cb45a74e355a5`);
+  const file = Uint8Array.from([...RCLONE.magic, ...nonce, ...box]);
+  const plain = await through([file], new DecryptionStream(key, RCLONE));
+  assert.deepEqual(plain, message);
+});

From 53815180c2301c25094112632d7d700e3277ef61 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sun, 18 Oct 2026 18:11:28 +0000
Subject: [PATCH 77/87] perf(crypt): join the small chunks of a stream only for
 a whole block

EncryptionStream and DecryptionStream joined the bytes that were not a
full block yet with each new chunk. A request body in a Worker comes in
chunks of a few KiB, thus each chunk of 4 KiB copied up to 64 KiB. Now
the chunks stay in a list, and join one time when a whole block, box or
header is there.

8 MiB in chunks of 4 KiB, in Node.js, 2 runs: seal 73 and 90 ms
before, 37 and 45 ms after; open 55 and 60 ms before, 33 and 37 ms
after. Chunks of 64 KiB and of 1 MiB do not change.
workerd (wrangler dev, 3 runs), with the module of the commit before:
crypt PUT 8 MiB 107 to 145 ms before, 69 to 82 ms after; crypt GET
8 MiB 102 to 124 ms before, 72 to 78 ms after.
---
 backend/crypt/secretbox.js | 75 ++++++++++++++++++++++++++++----------
 1 file changed, 55 insertions(+), 20 deletions(-)

diff --git a/backend/crypt/secretbox.js b/backend/crypt/secretbox.js
index dd5ddd9..d772bfc 100644
--- a/backend/crypt/secretbox.js
+++ b/backend/crypt/secretbox.js
@@ -40,25 +40,23 @@ export class EncryptionStream extends TransformStream {
     // Generates initial nonce from OS's crypto strong random number generator.
     const nonce = randomBytes(NONCE_SIZE);
     /** The data that is not a full block yet. */
-    let pending = new Uint8Array(0);
+    const pending = new Pending();
 
     super({
       start(controller) {
         controller.enqueue(concat(magic, nonce));
       },
       transform(chunk, controller) {
-        const data = pending.length ? concat(pending, chunk) : chunk;
+        pending.push(chunk);
+        if (pending.size < blockSize) return;
+        const data = pending.take();
         const size = data.length - data.length % blockSize;
-        if (size > 0) {
-          controller.enqueue(
-            seal(key, nonce, data.subarray(0, size), blockSize),
-          );
-        }
-        pending = data.slice(size);
+        controller.enqueue(seal(key, nonce, data.subarray(0, size), blockSize));
+        pending.push(data.subarray(size));
       },
       flush(controller) {
-        if (pending.length > 0) {
-          controller.enqueue(seal(key, nonce, pending, blockSize));
+        if (pending.size > 0) {
+          controller.enqueue(seal(key, nonce, pending.take(), blockSize));
         }
       },
     });
@@ -87,17 +85,15 @@ export class DecryptionStream extends TransformStream {
       ? add(options.nonce.slice(), options.block ?? 0)
       : null;
     /** The data that is not a full header or block yet. */
-    let pending = new Uint8Array(0);
+    const pending = new Pending();
 
     super({
       transform(chunk, controller) {
-        const data = pending.length ? concat(pending, chunk) : chunk;
+        pending.push(chunk);
+        if (pending.size < (nonce ? blockLength : headerSize)) return;
+        const data = pending.take();
         let offset = 0;
         if (!nonce) {
-          if (data.length < headerSize) {
-            pending = data.slice();
-            return;
-          }
           if (magic.some((byte, index) => data[index] !== byte)) {
             throw new Error(Errors.BAD_MAGIC);
           }
@@ -110,17 +106,17 @@ export class DecryptionStream extends TransformStream {
           const boxes = data.subarray(offset, offset + size);
           controller.enqueue(open(key, nonce, boxes, blockSize));
         }
-        pending = data.slice(offset + size);
+        pending.push(data.subarray(offset + size));
       },
       flush(controller) {
         if (!nonce) {
           throw new Error(Errors.TOO_SHORT);
         }
-        if (pending.length > 0) {
-          if (pending.length <= TAG_SIZE) {
+        if (pending.size > 0) {
+          if (pending.size <= TAG_SIZE) {
             throw new Error(Errors.BAD_HEADER);
           }
-          controller.enqueue(open(key, nonce, pending, blockSize));
+          controller.enqueue(open(key, nonce, pending.take(), blockSize));
         }
       },
     });
@@ -278,6 +274,45 @@ function randomBytes(length) {
   return crypto.getRandomValues(new Uint8Array(length));
 }
 
+/**
+ * The bytes of the chunks that are not a full block yet. The chunks join
+ * only when a full block is there: a join for each chunk copies the bytes
+ * again and again, and a request body in a Worker comes in chunks of a few
+ * KiB.
+ */
+class Pending {
+  /** @type {Uint8Array[]} */
+  #chunks = [];
+  size = 0;
+
+  /** @param {Uint8Array} chunk */
+  push(chunk) {
+    if (chunk.length === 0) return;
+    this.#chunks.push(chunk);
+    this.size += chunk.length;
+  }
+
+  /**
+   * Gives all the bytes in one array, and keeps no bytes.
+   * @returns {Uint8Array}
+   */
+  take() {
+    const chunks = this.#chunks;
+    let result = chunks[0] ?? new Uint8Array(0);
+    if (chunks.length > 1) {
+      result = new Uint8Array(this.size);
+      let offset = 0;
+      for (const chunk of chunks) {
+        result.set(chunk, offset);
+        offset += chunk.length;
+      }
+    }
+    this.#chunks = [];
+    this.size = 0;
+    return result;
+  }
+}
+
 /**
  * Concats two Uint8Arrays
  * @param {Uint8Array} a

From 4aef935fa50de8cfc9c5f3f3307305ec2418a04c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sun, 18 Oct 2026 18:18:04 +0000
Subject: [PATCH 78/87] fix(serve): a client sets no option of the remote

rfetch serve gave the request of a client to the backend with its query
and its headers. A field of the query won over the option of the served
remote, for example ?remote=/etc/ for an alias, and the headers RFETCH_*
and RCLONE_* went on to the remotes below, where fetch.js reads them as
options and remotes. Thus a client could read the other remotes of the
config, and with the absolute local paths of the commit before, each file
of the disk. Now serve removes the query and these headers of each
request, and sets only the options of the served remote.

The Worker has no local backend now: a client of the Worker tells all
its options, thus an alias to / would read the files of the runtime.
In workerd, node:fs reads no file today, but in Node.js it does.

Tests: a client of serve with ?remote= or the headers of an option reads
only the served folder; the Worker gives 404 for :local:, for an alias to
/etc/, and for a named remote of type local. Both tests fail with the
code before.
---
 _worker.js             |  7 +++++++
 cmd/serve/http/main.js | 22 +++++++++++++--------
 cmd/serve/main_test.js | 45 ++++++++++++++++++++++++++++++++++++++++++
 worker_test.js         | 14 +++++++++++++
 4 files changed, 80 insertions(+), 8 deletions(-)
 create mode 100644 cmd/serve/main_test.js

diff --git a/_worker.js b/_worker.js
index 6a10a2f..4f6688f 100644
--- a/_worker.js
+++ b/_worker.js
@@ -19,8 +19,15 @@
 // The import also sets the global `fetch`, which reads the paths of remotes.
 import { fetch } from "./fetch.js";
 import { lsjson } from "./cmd/lsjson/main.js";
+import { backends } from "./backend/main.js";
 import { parse } from "@rfetch/lib/fspath";
 
+// The Worker has no files of its users, and a client tells all the options
+// of its request: the local backend is not a backend of the Worker. Else a
+// client could read the files of the runtime, for example with an alias to
+// `/`.
+delete backends.local;
+
 /**
  * Gives the location of a request for the rfetch fetch: the remote of the
  * path with no percent-encoding, the fields of the query as parameters of
diff --git a/cmd/serve/http/main.js b/cmd/serve/http/main.js
index 0e521d5..73649bf 100644
--- a/cmd/serve/http/main.js
+++ b/cmd/serve/http/main.js
@@ -1,4 +1,5 @@
 import { serve as serveHTTP } from "@sntran/serve";
+import { isOption } from "@rfetch/lib/options";
 
 /**
  * Serve the remote over HTTP.
@@ -22,15 +23,20 @@ export function serve(fetch, flags = {}) {
     start(controller) {
       serveHTTP({
         fetch(request) {
+          // A client sets no option of the remote: its query and its
+          // headers RFETCH_* and RCLONE_* go away. Else a client could
+          // change the remote, for example `?remote=/etc/` for alias, or
+          // tell a new remote in the headers.
           const url = new URL(request.url);
-          Object.entries(backendFlags).forEach(([key, value]) => {
-            if (!url.searchParams.has(key)) {
-              url.searchParams.set(key, value);
-            }
-          });
-
-          request = new Request(url, request);
-          return fetch(request);
+          url.search = "";
+          for (const [key, value] of Object.entries(backendFlags)) {
+            url.searchParams.set(key, value);
+          }
+          const headers = new Headers(request.headers);
+          for (const key of [...headers.keys()]) {
+            if (isOption(key)) headers.delete(key);
+          }
+          return fetch(new Request(new Request(url, request), { headers }));
         },
         hostname,
         port: Number(port),
diff --git a/cmd/serve/main_test.js b/cmd/serve/main_test.js
new file mode 100644
index 0000000..46048be
--- /dev/null
+++ b/cmd/serve/main_test.js
@@ -0,0 +1,45 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { serve } from "./main.js";
+
+test("a client of serve cannot set an option of the remote", async () => {
+  const inside = await mkdtemp(join(tmpdir(), "rfetch-serve-inside-"));
+  const outside = await mkdtemp(join(tmpdir(), "rfetch-serve-outside-"));
+  await writeFile(join(inside, "a.txt"), "inside");
+  await writeFile(join(outside, "a.txt"), "outside");
+  const response = await serve("http", `:alias,remote='${inside}/':`, {
+    addr: "127.0.0.1:0",
+  });
+  const reader = response.body.getReader();
+  try {
+    const { value } = await reader.read();
+    const [url] = new TextDecoder().decode(value).match(/http:\/\/\S+/);
+    const get = async (path, headers = {}) => {
+      const answer = await fetch(new URL(path, url), { headers });
+      return answer.ok ? await answer.text() : answer.status;
+    };
+
+    assert.equal(await get("/a.txt"), "inside");
+    // The query of the client is not an option.
+    assert.equal(
+      await get(`/a.txt?remote=${encodeURIComponent(`${outside}/`)}`),
+      "inside",
+    );
+    // A header of the client is not an option, and tells no remote.
+    assert.equal(
+      await get("/a.txt", {
+        RFETCH_ALIAS_REMOTE: `${outside}/`,
+        RCLONE_ALIAS_REMOTE: `${outside}/`,
+      }),
+      "inside",
+    );
+  } finally {
+    await reader.cancel();
+    await rm(inside, { recursive: true, force: true });
+    await rm(outside, { recursive: true, force: true });
+  }
+});
diff --git a/worker_test.js b/worker_test.js
index d1caa8f..2f028e9 100644
--- a/worker_test.js
+++ b/worker_test.js
@@ -140,3 +140,17 @@ test("gives 400 or 404 for a remote that is not correct", async () => {
   assert.equal((await send("/:memory:/a?bad%20key=1")).status, 400);
   assert.equal((await send("/:memory%:/a")).status, 400);
 });
+
+test("has no local backend: a client reads no file of the runtime", async () => {
+  for (
+    const [path, headers] of [
+      ["/:local:/etc/hostname", {}],
+      ["/:alias:hostname", { RFETCH_ALIAS_REMOTE: "/etc/" }],
+      ["/disk:etc/hostname", { RFETCH_CONFIG_DISK_TYPE: "local" }],
+    ]
+  ) {
+    const response = await send(path, { headers });
+    assert.equal(response.status, 404, path);
+    assert.match(await response.text(), /Backend local not found/);
+  }
+});

From f2e5f34db7f6b7d92a3f21f3609e490fa465430d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sun, 18 Oct 2026 20:47:37 +0000
Subject: [PATCH 79/87] fix(lib): read HTML with lol-html again, not with a
 parser of rfetch

scanTags of d1133f0 was a small HTML parser of rfetch. A list can come
from any server: the index page of the http backend, or the remote of a
crypt at a URL. A small parser can read such a page wrongly. Now
readListing and the index of http read HTML with readElements of the new
@rfetch/lib/rewriter: HTMLRewriter, that is lol-html, the HTML parser of
Cloudflare.

- In workerd and in Bun, it is the HTMLRewriter of the runtime.
- In Node.js and in Deno, it is @sntran/lol-html, lol-html 2.8 in
  WebAssembly, with no stream: each chunk of HTML goes to write(), and the
  output goes away. Thus no queue of output chunks grows, as it did with
  html-rewriter-wasm. It loads at its first use.

HTMLRewriter gives the value of an attribute as it is in the document.
attributeOf decodes the character references with decodeHTMLAttribute of
the package entities, as the HTML standard tells. scanTags decoded only
the basic and the numeric references. A new case in
backend/http/rclone_test.js has a script, a comment and the reference
&eacute;: rfetch and rclone list the same files. With scanTags, this case
fails.

The list of crypt and relink of alias stay as in d1133f0: they read the
entries with readListing and write the list with renderListing.

bench/node.js in Node.js 22, with scanTags and now (3 runs):
- lib: readListing of 10000 entries: 62 ms, 140 to 154 ms.
- crypt: list 1000 files: 31 ms, 38 to 43 ms.
- crypt: lsjson of 1000 files: 36 ms, 49 to 53 ms.
With html-rewriter-wasm, before d1133f0, these were 349, 85 and 150 ms.

workerd (wrangler dev, 3 runs), with scanTags and now:
- lib: readListing of 10000 entries: 49 to 64 ms, 256 to 297 ms.
- crypt: list 1000 files: 24 to 29 ms, 42 to 58 ms.
- crypt: lsjson of 1000 files: 34 to 39 ms, 73 to 102 ms.
These are the times of the HTMLRewriter of workerd before d1133f0. The
output goes to arrayBuffer(): a pipe to a WritableStream of JavaScript
took 835 to 922 ms for 10000 entries.

Bun, now: 49 to 53 ms, 16 to 23 ms and 21 to 32 ms.
---
 CONTRIBUTING.md             |  12 +-
 backend/http/main.js        |  68 +++++-----
 backend/http/main_test.js   |   6 +
 backend/http/rclone_test.js |  13 +-
 lib/html.js                 | 261 ------------------------------------
 lib/html_test.js            | 105 +--------------
 lib/listing.js              |  67 +++++----
 lib/listing_test.js         | 152 ++++++++++-----------
 lib/package.json            |   6 +-
 lib/rewriter.js             |  86 ++++++++++++
 lib/rewriter_test.js        | 116 ++++++++++++++++
 package-lock.json           |  36 ++---
 12 files changed, 391 insertions(+), 537 deletions(-)
 create mode 100644 lib/rewriter.js
 create mode 100644 lib/rewriter_test.js

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 199a1b5..594a05b 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -207,9 +207,15 @@ a folder, and `readListing` reads it.
 A backend on top of another backend reads the list of the other backend with
 `readListing`, changes the entries, and writes the list with `renderListing`,
 for example the names of `crypt`. `lsjson` reads each list with `readListing`.
-The read is `scanTags` of `@rfetch/lib/html`, in JavaScript: do not use
-HTMLRewriter. In Node.js and in Deno, HTMLRewriter is WebAssembly, and its load
-and each element in it cost much time.
+
+Read HTML only with `readElements` of `@rfetch/lib/rewriter`. It is
+HTMLRewriter, that is lol-html, the HTML parser of Cloudflare, as the HTML
+standard tells. Do not write a parser of HTML: a list can come from any server,
+and its HTML can have scripts, comments and character references. HTMLRewriter
+gives the value of an attribute as it is in the document: read it with
+`attributeOf`, which decodes the character references, for example `&amp;`. In
+workerd and in Bun, HTMLRewriter is a part of the runtime. In Node.js and in
+Deno, it is the WebAssembly of `@sntran/lol-html`, which loads at its first use.
 
 ## Commands
 
diff --git a/backend/http/main.js b/backend/http/main.js
index 9b6b664..c62cd19 100644
--- a/backend/http/main.js
+++ b/backend/http/main.js
@@ -28,7 +28,7 @@ import { parseList } from "./list.js";
 import { childOf, renderListing } from "@rfetch/lib/listing";
 import { mimeType } from "@rfetch/lib/mime";
 import { optionsOf } from "@rfetch/lib/options";
-import { scanTags } from "@rfetch/lib/html";
+import { attributeOf, readElements } from "@rfetch/lib/rewriter";
 import { decodePath, encodePath } from "@rfetch/lib/path";
 
 export const options = {
@@ -253,51 +253,53 @@ async function readIndex(response, base) {
   /** @type {import("@rfetch/lib/listing").Entry[]} */
   const entries = [];
   const seen = new Set();
-  /** The number of open `tr` elements. */
-  let rows = 0;
+  let inRow = false;
   /** @type {import("@rfetch/lib/listing").Entry | null} */
   let current = null;
 
-  scanTags(await response.text(), {
-    start(name, attributes) {
-      if (name === "tr") {
-        rows++;
+  await readElements(response, [
+    ["tr", {
+      element(element) {
+        inRow = true;
         current = null;
-      } else if (name === "a") {
-        const href = attributes.get("href");
-        if (href === undefined) return;
-        const child = childOf(href, base);
-        if (child === null || seen.has(child)) return;
-        seen.add(child);
-        const isDir = child.endsWith("/");
+        element.onEndTag(() => {
+          inRow = false;
+          current = null;
+        });
+      },
+    }],
+    ["a[href]", {
+      element(element) {
+        const name = childOf(attributeOf(element, "href") ?? "", base);
+        if (name === null || seen.has(name)) return;
+        seen.add(name);
+        const isDir = name.endsWith("/");
         const entry = {
-          Name: isDir ? child.slice(0, -1) : child,
+          Name: isDir ? name.slice(0, -1) : name,
           IsDir: isDir,
           Size: -1,
-          MimeType: isDir ? "" : attributes.get("type") || "",
+          MimeType: isDir ? "" : attributeOf(element, "type") || "",
           ModTime: "",
         };
         entries.push(entry);
-        if (rows > 0) current = entry;
-      } else if (name === "data" && rows > 0) {
-        const value = attributes.get("value");
-        if (current && value !== undefined && /^\d+$/.test(value)) {
-          current.Size = Number(value);
-        }
-      } else if (name === "time" && rows > 0) {
-        const time = Date.parse(attributes.get("datetime") ?? "");
+        if (inRow) current = entry;
+      },
+    }],
+    ["tr data[value]", {
+      element(element) {
+        const value = attributeOf(element, "value") ?? "";
+        if (current && /^\d+$/.test(value)) current.Size = Number(value);
+      },
+    }],
+    ["tr time[datetime]", {
+      element(element) {
+        const time = Date.parse(attributeOf(element, "datetime") ?? "");
         if (current && !isNaN(time)) {
           current.ModTime = new Date(time).toISOString();
         }
-      }
-    },
-    end(name) {
-      if (name === "tr") {
-        rows--;
-        current = null;
-      }
-    },
-  });
+      },
+    }],
+  ]);
 
   return entries;
 }
diff --git a/backend/http/main_test.js b/backend/http/main_test.js
index 873342c..89f7ab4 100644
--- a/backend/http/main_test.js
+++ b/backend/http/main_test.js
@@ -141,6 +141,7 @@ describe("http with an index page that is not of rfetch", () => {
     "/files/a.txt": "a",
     "/files/b c.json": "{}",
     "/files/d.bin": "ddd",
+    "/files/e&f.txt": "eeee",
   };
   const INDEX = `<!DOCTYPE html>
 <html><body><h1>Index of /files</h1><pre>
@@ -151,6 +152,9 @@ describe("http with an index page that is not of rfetch", () => {
 <a href="http://127.0.0.1:1/files/x.txt">x.txt</a>
 <a href="/files/d.bin">d.bin</a>   17-Oct-2026 10:00    3
 <a href="d.bin">d.bin again</a>
+<a href="e&amp;f.txt">e&amp;f.txt</a>  17-Oct-2026 10:00    4
+<script>document.write('<a href="script.txt">')</script>
+<!-- <a href="comment.txt">comment.txt</a> -->
 <a href="lost.txt">lost.txt</a>
 <a href="sub/">sub/</a>
 <a href="sub/deep.txt">sub/deep.txt</a>
@@ -201,6 +205,7 @@ describe("http with an index page that is not of rfetch", () => {
         { Name: "a.txt", IsDir: false, Size: 1, ModTime: time },
         { Name: "b c.json", IsDir: false, Size: 2, ModTime: time },
         { Name: "d.bin", IsDir: false, Size: 3, ModTime: time },
+        { Name: "e&f.txt", IsDir: false, Size: 4, ModTime: time },
         // A file whose HEAD request fails is not in the list, as in rclone.
         { Name: "sub", IsDir: true, Size: -1, ModTime: "" },
       ],
@@ -221,6 +226,7 @@ describe("http with an index page that is not of rfetch", () => {
         { Name: "a.txt", Size: -1, MimeType: mimeType("a.txt") },
         { Name: "b c.json", Size: -1, MimeType: "application/json" },
         { Name: "d.bin", Size: -1, MimeType: "application/octet-stream" },
+        { Name: "e&f.txt", Size: -1, MimeType: mimeType("e&f.txt") },
         { Name: "lost.txt", Size: -1, MimeType: mimeType("lost.txt") },
         { Name: "sub", Size: -1, MimeType: "" },
       ],
diff --git a/backend/http/rclone_test.js b/backend/http/rclone_test.js
index 24b926d..12d2377 100644
--- a/backend/http/rclone_test.js
+++ b/backend/http/rclone_test.js
@@ -41,6 +41,10 @@ const INDEX = `<!DOCTYPE html>
 <a href="./b%20c.json">b c.json</a> 17-Oct-2026 10:00    2
 <a href="http://127.0.0.1:1/index/x.txt">x.txt</a>
 <a href="/index/a.txt">a.txt again</a>
+<A HREF=e&amp;f&#x20;g.txt>e&amp;f g.txt</A> 17-Oct-2026 10:00    3
+<a href="caf&eacute;.txt">caf&eacute;.txt</a> 17-Oct-2026 10:00    4
+<script>document.write('<a href="script.txt">script.txt</a>')</script>
+<!-- <a href="comment.txt">comment.txt</a> -->
 <a href="lost.txt">lost.txt</a>
 <a href="sub/">sub/</a>
 <a href="sub/deep.txt">sub/deep.txt</a>
@@ -48,7 +52,12 @@ const INDEX = `<!DOCTYPE html>
 </pre></body></html>`;
 
 /** The files of the index page. */
-const INDEX_FILES = { "/index/a.txt": "a", "/index/b c.json": "{}" };
+const INDEX_FILES = {
+  "/index/a.txt": "a",
+  "/index/b c.json": "{}",
+  "/index/e&f g.txt": "efg",
+  "/index/café.txt": "café",
+};
 
 /** @param {number} size */
 function content(size) {
@@ -160,6 +169,8 @@ describe("http and rclone", {
     assert.deepEqual(expected.map(({ Path }) => Path), [
       "a.txt",
       "b c.json",
+      "café.txt",
+      "e&f g.txt",
       "sub",
     ]);
     assert.deepEqual(normalize(await walk(url)), expected);
diff --git a/lib/html.js b/lib/html.js
index ce77600..0eb6bd4 100644
--- a/lib/html.js
+++ b/lib/html.js
@@ -17,264 +17,3 @@ const REFERENCES = {
 export function escapeHTML(text) {
   return String(text).replace(/[&<>"']/g, (character) => REFERENCES[character]);
 }
-
-/** The elements with no end tag, as the HTML standard tells. */
-const VOID = new Set([
-  "area",
-  "base",
-  "basefont",
-  "bgsound",
-  "br",
-  "col",
-  "embed",
-  "frame",
-  "hr",
-  "img",
-  "input",
-  "keygen",
-  "link",
-  "meta",
-  "param",
-  "source",
-  "track",
-  "wbr",
-]);
-
-/**
- * The elements with text that is not markup: only their end tag ends them.
- * The text of `plaintext` goes to the end of the document.
- */
-const RAW = new Set([
-  "iframe",
-  "noembed",
-  "noframes",
-  "plaintext",
-  "script",
-  "style",
-  "textarea",
-  "title",
-  "xmp",
-]);
-
-/** The basic character references, with no `;` at the end. */
-const BASIC = { amp: "&", lt: "<", gt: ">", quot: '"', apos: "'" };
-
-/**
- * Puts the characters in place of the basic character references of an
- * attribute value: `&amp;`, `&lt;`, `&gt;`, `&quot;`, `&apos;`, and the
- * numeric references, for example `&#39;` and `&#x27;`. Other named
- * references stay as they are. As the HTML standard tells, a reference with
- * no `;` and a letter, a digit or `=` after it is text.
- * @param {string} value
- * @returns {string}
- */
-export function decodeAttribute(value) {
-  if (!value.includes("&")) return value;
-  return value.replace(
-    /&(?:#([0-9]+)|#[xX]([0-9a-fA-F]+)|(amp|lt|gt|quot)|(apos);)(;?)(?=([=A-Za-z0-9]?))/g,
-    (reference, decimal, hex, name, apos, semicolon, after) => {
-      if (name !== undefined) {
-        if (!semicolon && after) return reference;
-        return BASIC[name];
-      }
-      if (apos !== undefined) return `'${semicolon}`;
-      const code = decimal !== undefined
-        ? Number.parseInt(decimal, 10)
-        : Number.parseInt(hex, 16);
-      const valid = code > 0 && code <= 0x10ffff &&
-        (code < 0xd800 || code > 0xdfff);
-      return String.fromCodePoint(valid ? code : 0xfffd);
-    },
-  );
-}
-
-/**
- * The start and the end of each element of an HTML document. The scan
- * follows the tokenizer of the HTML standard for tags, attributes, comments
- * and the text of elements such as `script`, but it does not make a tree:
- * an end tag ends the last open element with its name, and an end tag with
- * no such element does nothing.
- * @typedef {Object} TagHandlers
- * @property {(name: string, attributes: Map<string, string>) => void} start
- *   The name in lower case, and the attributes: the name of each in lower
- *   case, and its value after `decodeAttribute`. As in the standard, the
- *   first attribute with a name wins.
- * @property {(name: string) => void} [end] The element ends: its end tag, or
- *   the end tag of an element that has it in it.
- */
-
-/**
- * Scans the tags of an HTML document.
- * @param {string} html
- * @param {TagHandlers} handlers
- */
-export function scanTags(html, { start, end }) {
-  /** The names of the open elements, from the first. */
-  const open = [];
-  const length = html.length;
-  let position = 0;
-  for (;;) {
-    const lt = html.indexOf("<", position);
-    if (lt === -1 || lt + 1 >= length) return;
-    const next = html.charCodeAt(lt + 1);
-
-    if (next === 0x21) { // `<!`: a comment, a doctype or a bogus comment.
-      if (html.startsWith("<!--", lt)) {
-        if (html.startsWith("<!-->", lt)) position = lt + 5;
-        else if (html.startsWith("<!--->", lt)) position = lt + 6;
-        else {
-          const close = html.indexOf("-->", lt + 4);
-          if (close === -1) return;
-          position = close + 3;
-        }
-      } else {
-        const close = html.indexOf(">", lt + 2);
-        if (close === -1) return;
-        position = close + 1;
-      }
-      continue;
-    }
-    if (next === 0x3f) { // `<?`: a bogus comment.
-      const close = html.indexOf(">", lt + 2);
-      if (close === -1) return;
-      position = close + 1;
-      continue;
-    }
-
-    const isEnd = next === 0x2f; // `</`
-    const first = isEnd ? lt + 2 : lt + 1;
-    if (!isLetter(html.charCodeAt(first))) {
-      if (!isEnd) { // Text, for example `a < b`.
-        position = lt + 1;
-        continue;
-      }
-      // `</>` is nothing, and `</` with no letter is a bogus comment.
-      const close = html.indexOf(">", first);
-      if (close === -1) return;
-      position = close + 1;
-      continue;
-    }
-
-    let index = first;
-    while (index < length && !isNameEnd(html.charCodeAt(index))) index++;
-    const name = html.slice(first, index).toLowerCase();
-    const attributes = new Map();
-    index = readAttributes(html, index, attributes);
-    // A tag that the document does not end is not a tag.
-    if (index === -1) return;
-    position = index;
-
-    if (isEnd) {
-      const at = open.lastIndexOf(name);
-      if (at !== -1) {
-        while (open.length > at) {
-          const element = open.pop();
-          end?.(element);
-        }
-      }
-      continue;
-    }
-
-    start(name, attributes);
-    if (VOID.has(name)) continue;
-    open.push(name);
-    if (RAW.has(name)) {
-      if (name === "plaintext") return;
-      const close = findEndTag(html, name, position);
-      if (close === -1) return;
-      position = close;
-    }
-  }
-}
-
-/** @param {number} code */
-function isLetter(code) {
-  return (code >= 0x41 && code <= 0x5a) || (code >= 0x61 && code <= 0x7a);
-}
-
-/** Tab, line feed, form feed, carriage return and space. */
-function isSpace(code) {
-  return code === 0x20 || code === 0x0a || code === 0x09 || code === 0x0c ||
-    code === 0x0d;
-}
-
-/** The end of a tag name: a space, `/` or `>`. */
-function isNameEnd(code) {
-  return isSpace(code) || code === 0x2f || code === 0x3e;
-}
-
-/**
- * Reads the attributes of a tag, after its name.
- * @param {string} html
- * @param {number} index After the name of the tag.
- * @param {Map<string, string>} attributes
- * @returns {number} After the `>` of the tag, or -1 when the document ends
- *   in the tag.
- */
-function readAttributes(html, index, attributes) {
-  const length = html.length;
-  for (;;) {
-    while (index < length) {
-      const code = html.charCodeAt(index);
-      if (!isSpace(code) && code !== 0x2f) break;
-      index++;
-    }
-    if (index >= length) return -1;
-    if (html.charCodeAt(index) === 0x3e) return index + 1;
-
-    // The name. Its first character can be `=`.
-    const start = index++;
-    while (index < length) {
-      const code = html.charCodeAt(index);
-      if (isNameEnd(code) || code === 0x3d) break;
-      index++;
-    }
-    const name = html.slice(start, index).toLowerCase();
-    while (index < length && isSpace(html.charCodeAt(index))) index++;
-
-    let value = "";
-    if (index < length && html.charCodeAt(index) === 0x3d) {
-      index++;
-      while (index < length && isSpace(html.charCodeAt(index))) index++;
-      if (index >= length) return -1;
-      const quote = html.charCodeAt(index);
-      if (quote === 0x22 || quote === 0x27) {
-        const close = html.indexOf(quote === 0x22 ? '"' : "'", index + 1);
-        if (close === -1) return -1;
-        value = html.slice(index + 1, close);
-        index = close + 1;
-      } else {
-        const begin = index;
-        while (index < length) {
-          const code = html.charCodeAt(index);
-          if (isSpace(code) || code === 0x3e) break;
-          index++;
-        }
-        value = html.slice(begin, index);
-      }
-    }
-    if (!attributes.has(name)) attributes.set(name, decodeAttribute(value));
-  }
-}
-
-/**
- * Finds the end tag of an element whose text is not markup, for example
- * `</script>`, with no regard to case.
- * @param {string} html
- * @param {string} name In lower case.
- * @param {number} from
- * @returns {number} The index of the `<` of the end tag, or -1.
- */
-function findEndTag(html, name, from) {
-  for (let index = from;; index++) {
-    index = html.indexOf("</", index);
-    if (index === -1) return -1;
-    const after = index + 2 + name.length;
-    if (
-      html.slice(index + 2, after).toLowerCase() === name &&
-      (after >= html.length || isNameEnd(html.charCodeAt(after)))
-    ) {
-      return index;
-    }
-  }
-}
diff --git a/lib/html_test.js b/lib/html_test.js
index 7ef4c0a..cc1cb19 100644
--- a/lib/html_test.js
+++ b/lib/html_test.js
@@ -1,8 +1,7 @@
 import { test } from "node:test";
 import assert from "node:assert/strict";
-import fc from "fast-check";
 
-import { decodeAttribute, escapeHTML, scanTags } from "./html.js";
+import { escapeHTML } from "./html.js";
 
 test("escapeHTML", async (t) => {
   await t.test("puts a reference for each character of HTML", () => {
@@ -16,105 +15,3 @@ test("escapeHTML", async (t) => {
     assert.equal(escapeHTML("Hello, 世界 ≠ ?+#"), "Hello, 世界 ≠ ?+#");
   });
 });
-
-test("decodeAttribute", async (t) => {
-  await t.test("decodes the basic and the numeric references", () => {
-    assert.equal(
-      decodeAttribute("a&amp;b&lt;c&gt;d&quot;e&apos;f&#39;g&#x27;h&#X1F600;"),
-      "a&b<c>d\"e'f'g'h😀",
-    );
-  });
-
-  await t.test("keeps other references and the legacy cases as text", () => {
-    assert.equal(decodeAttribute("&eacute;&nbsp;"), "&eacute;&nbsp;");
-    assert.equal(decodeAttribute("?a=1&ampb=2"), "?a=1&ampb=2");
-    assert.equal(decodeAttribute("&amp=x"), "&amp=x");
-    assert.equal(decodeAttribute("&amp &lt"), "& <");
-    assert.equal(decodeAttribute("&apos"), "&apos");
-    assert.equal(decodeAttribute("&#0;&#xD800;&#x110000;"), "�".repeat(3));
-  });
-
-  await t.test("is the inverse of escapeHTML", () => {
-    fc.assert(
-      fc.property(fc.fullUnicodeString(), (text) => {
-        assert.equal(decodeAttribute(escapeHTML(text)), text);
-      }),
-    );
-  });
-});
-
-/** The tags of a document, as lines: `+name attributes` and `-name`. */
-function tagsOf(html) {
-  const lines = [];
-  scanTags(html, {
-    start(name, attributes) {
-      lines.push(`+${name}${JSON.stringify([...attributes])}`);
-    },
-    end(name) {
-      lines.push(`-${name}`);
-    },
-  });
-  return lines;
-}
-
-test("scanTags", async (t) => {
-  await t.test("reads the names and the attributes of tags", () => {
-    assert.deepEqual(
-      tagsOf(`<A HREF='a > b' Type=text/plain data-x="1" data-x="2" checked
-        title="&quot;x&quot;"/>t</A>`),
-      [
-        `+a[["href","a > b"],["type","text/plain"],["data-x","1"],["checked",""],["title","\\"x\\""]]`,
-        "-a",
-      ],
-    );
-  });
-
-  await t.test("does not read the tags in comments and in the text of script", () => {
-    assert.deepEqual(
-      tagsOf(`<!-- <a href="1"> --><!--><!---><!DOCTYPE html><?x <b>?>
-        <script>"<a href='2'></script >"</script><style><a></STYLE>
-        <title><a></title><textarea></textarea x><a href="3">`),
-      [
-        "+script[]",
-        "-script",
-        "+style[]",
-        "-style",
-        "+title[]",
-        "-title",
-        "+textarea[]",
-        "-textarea",
-        `+a[["href","3"]]`,
-      ],
-    );
-  });
-
-  await t.test("ends the open elements in an element at its end tag", () => {
-    assert.deepEqual(
-      tagsOf("<table><tr><td><br><img src=x></table></tr></p><p a<b>"),
-      [
-        "+table[]",
-        "+tr[]",
-        "+td[]",
-        "+br[]",
-        `+img[["src","x"]]`,
-        "-td",
-        "-tr",
-        "-table",
-        `+p[["a<b",""]]`,
-      ],
-    );
-  });
-
-  await t.test("is not a tag: text with <, and a tag at the end of the document", () => {
-    assert.deepEqual(tagsOf("a < b <3 </ > </1> <a href='x"), []);
-    assert.deepEqual(tagsOf("<plaintext><a href=x>"), ["+plaintext[]"]);
-  });
-
-  await t.test("reads any document with no error", () => {
-    fc.assert(
-      fc.property(fc.fullUnicodeString({ maxLength: 200 }), (html) => {
-        tagsOf(html);
-      }),
-    );
-  });
-});
diff --git a/lib/listing.js b/lib/listing.js
index 2d54b85..db1cbe4 100644
--- a/lib/listing.js
+++ b/lib/listing.js
@@ -6,7 +6,8 @@
  * change.
  */
 import { formatBytes } from "./format.js";
-import { escapeHTML, scanTags } from "./html.js";
+import { escapeHTML } from "./html.js";
+import { attributeOf, readElements } from "./rewriter.js";
 import { toLocaleISOString } from "./time.js";
 
 /**
@@ -25,10 +26,8 @@ import { toLocaleISOString } from "./time.js";
  * folder (`../`) is not an entry, and a name that has no percent-encoding
  * for `?`, `#` or `/` gives a wrong entry.
  *
- * The read is `scanTags` of `html.js`, not HTMLRewriter: in Node.js and in
- * Deno, HTMLRewriter is WebAssembly, and its load and each element in it
- * cost much time. The rules are the rules of the selectors `tr a[href]`,
- * `tr data[value]` and `tr time[datetime]` of HTMLRewriter.
+ * The read is HTMLRewriter, as the HTML standard tells, because the list
+ * can come from any server, for example the remote of a crypt at a URL.
  * @param {Response} response
  * @param {URL} base The URL of the folder.
  * @returns {Promise<Entry[]>}
@@ -37,50 +36,48 @@ export async function readListing(response, base) {
   /** @type {Entry[]} */
   const entries = [];
   /**
-   * The entry of the current row, at the end of `entries`.
+   * The entry of the current row, at the end of `entries`. A handler of an
+   * end tag costs much time in a Worker, thus the entry goes in the list at
+   * its link.
    * @type {Entry | null}
    */
   let entry = null;
-  /** The number of open `tr` elements. */
-  let rows = 0;
 
-  scanTags(await response.text(), {
-    start(name, attributes) {
-      if (name === "tr") {
-        rows++;
+  await readElements(response, [
+    ["tr", {
+      element() {
         entry = null;
-        return;
-      }
-      if (rows === 0) return;
-      if (name === "a") {
-        const href = attributes.get("href");
-        if (href === undefined) return;
-        const child = childOf(href, base);
-        if (child === null) return;
-        const isDir = child.endsWith("/");
+      },
+    }],
+    ["tr a[href]", {
+      element(element) {
+        const name = childOf(attributeOf(element, "href") ?? "", base);
+        if (name === null) return;
+        const isDir = name.endsWith("/");
         const link = {
-          Name: isDir ? child.slice(0, -1) : child,
+          Name: isDir ? name.slice(0, -1) : name,
           IsDir: isDir,
           Size: -1,
-          MimeType: attributes.get("type") || "",
+          MimeType: attributeOf(element, "type") || "",
           ModTime: "",
         };
         // The last link of a row gives the entry of the row.
         if (entry) entries[entries.length - 1] = link;
         else entries.push(link);
         entry = link;
-      } else if (name === "data") {
-        const value = attributes.get("value");
-        if (entry && value !== undefined) entry.Size = Number(value);
-      } else if (name === "time") {
-        const datetime = attributes.get("datetime");
-        if (entry && datetime !== undefined) entry.ModTime = datetime;
-      }
-    },
-    end(name) {
-      if (name === "tr") rows--;
-    },
-  });
+      },
+    }],
+    ["tr data[value]", {
+      element(element) {
+        if (entry) entry.Size = Number(attributeOf(element, "value"));
+      },
+    }],
+    ["tr time[datetime]", {
+      element(element) {
+        if (entry) entry.ModTime = attributeOf(element, "datetime") ?? "";
+      },
+    }],
+  ]);
 
   return entries;
 }
diff --git a/lib/listing_test.js b/lib/listing_test.js
index c2818a8..d3d1a5f 100644
--- a/lib/listing_test.js
+++ b/lib/listing_test.js
@@ -3,7 +3,6 @@ import assert from "node:assert/strict";
 import fc from "fast-check";
 
 import { childOf, readListing, renderListing } from "./listing.js";
-import { HTMLRewriter } from "@sntran/html-rewriter";
 
 const base = new URL("http://remote/folder/");
 
@@ -78,95 +77,80 @@ test("childOf gives the name of a child, or null", () => {
 });
 
 /**
- * The entries of a list, with HTMLRewriter and the selectors that
- * readListing follows: the reference for the tests.
+ * A response with the bytes of a text in chunks, cut at the places.
  * @param {string} html
+ * @param {number[]} cuts
  */
-async function readWithRewriter(html) {
-  const entries = [];
-  let entry = null;
-  await new HTMLRewriter()
-    .on("tr", {
-      element() {
-        entry = null;
-      },
-    })
-    .on("tr a[href]", {
-      element(element) {
-        const name = childOf(element.getAttribute("href"), base);
-        if (name === null) return;
-        const isDir = name.endsWith("/");
-        const link = {
-          Name: isDir ? name.slice(0, -1) : name,
-          IsDir: isDir,
-          Size: -1,
-          MimeType: element.getAttribute("type") || "",
-          ModTime: "",
-        };
-        if (entry) entries[entries.length - 1] = link;
-        else entries.push(link);
-        entry = link;
-      },
-    })
-    .on("tr data[value]", {
-      element(element) {
-        if (entry) entry.Size = Number(element.getAttribute("value"));
-      },
-    })
-    .on("tr time[datetime]", {
-      element(element) {
-        if (entry) entry.ModTime = element.getAttribute("datetime");
-      },
-    })
-    .transform(new Response(html))
-    .arrayBuffer();
-  return entries;
+function inChunks(html, cuts) {
+  const bytes = new TextEncoder().encode(html);
+  const places = [...new Set(cuts.map((cut) => cut % (bytes.length + 1)))]
+    .sort((a, b) => a - b);
+  const chunks = [];
+  let start = 0;
+  for (const place of [...places, bytes.length]) {
+    chunks.push(bytes.subarray(start, place));
+    start = place;
+  }
+  return new Response(new Blob(chunks).stream());
 }
 
-test("readListing gives the entries of HTMLRewriter", async (t) => {
-  await t.test("for each list of renderListing", async () => {
-    const entry = fc.record({
-      Name: fc.fullUnicodeString({ minLength: 1, maxLength: 12 }),
-      IsDir: fc.boolean(),
-      Size: fc.nat(),
-      MimeType: fc.constantFrom("", "text/plain; charset=utf-8", "image/png"),
-      ModTime: fc.constantFrom(
-        "",
-        "2026-10-18T12:00:00.000Z",
-        "2026-10-18T15:02:41.540476887Z",
-      ),
-    });
-    await fc.assert(
-      fc.asyncProperty(
-        fc.array(entry, { maxLength: 20 }),
-        fc.constantFrom("", "a=1&b=%3C"),
-        async (entries, query) => {
-          const html = await new Response(renderListing(entries, { query }))
-            .text();
-          assert.deepEqual(await read(html), await readWithRewriter(html));
-        },
-      ),
-      { numRuns: 50 },
-    );
+test("readListing gives back the entries of renderListing", async () => {
+  const entry = fc.record({
+    Name: fc.fullUnicodeString({ minLength: 1, maxLength: 12 }),
+    IsDir: fc.boolean(),
+    Size: fc.nat(),
+    MimeType: fc.constantFrom("", "text/plain; charset=utf-8", "image/png"),
+    ModTime: fc.constantFrom(
+      "",
+      "2026-10-18T12:00:00.000Z",
+      "2026-10-18T15:02:41.540476887Z",
+    ),
   });
+  await fc.assert(
+    fc.asyncProperty(
+      fc.array(entry, { maxLength: 20 }),
+      fc.constantFrom("", "a=1&b=%3C"),
+      // The places where the HTML is cut into chunks.
+      fc.array(fc.nat(), { maxLength: 8 }),
+      async (entries, query, cuts) => {
+        const html = await new Response(renderListing(entries, { query }))
+          .text();
+        const expected = entries
+          .toSorted((a, b) => a.Name.localeCompare(b.Name))
+          .map((entry) =>
+            entry.IsDir ? { ...entry, Size: -1, MimeType: "" } : entry
+          );
+        assert.deepEqual(
+          await readListing(inChunks(html, cuts), base),
+          expected,
+        );
+      },
+    ),
+    { numRuns: 50 },
+  );
+});
 
-  await t.test("for HTML that is not of renderListing", async () => {
-    const html = `<TABLE><tr><td><A HREF='q.txt' type=text/plain TYPE="x">q</A>
-      <a href=r.txt>r</a></td><td><DATA value=" 12 ">12</DATA></td></tr>
-      <tr><script>"<tr><td><a href='s.txt'>"</script><td><a href="t.txt"/>t
-      <time datetime=2026-10-18T12:00:00Z>now</time></td></tr>
-      <!-- <tr><td><a href="c.txt">c</a></td></tr> -->
-      <tr><td><a>no link</a><a href="d/">d</a><data>no value</data></td>
-      </table><a href="out.txt">x</a><tr><td><a href="u.txt">u</a>`;
-    const entries = await read(html);
-    assert.deepEqual(entries.map(({ Name }) => Name), [
-      "r.txt",
-      "t.txt",
-      "d",
-      "u.txt",
-    ]);
-    assert.deepEqual(entries, await readWithRewriter(html));
-  });
+test("readListing reads HTML as the HTML standard tells", async () => {
+  const html = `<TABLE><tr><td><A HREF='q.txt' type=text/plain TYPE="x">q</A>
+    <a href=r&amp;s.txt>r</a></td><td><DATA value="12">12</DATA></td></tr>
+    <tr><script>"<tr><td><a href='s.txt'>"</script><td><a href="t&eacute;.txt"/>t
+    <time datetime=2026-10-18T12:00:00Z>now</time></td></tr>
+    <!-- <tr><td><a href="c.txt">c</a></td></tr> -->
+    <tr><td><textarea><a href="ta.txt"></textarea><a>no link</a>
+      <a href="d/">d</a><data>no value</data></td>
+    </table><a href="out.txt">x</a><tr><td><a href="u.txt">u</a>`;
+  assert.deepEqual(await read(html), [
+    { Name: "r&s.txt", IsDir: false, Size: 12, MimeType: "", ModTime: "" },
+    {
+      Name: "té.txt",
+      IsDir: false,
+      Size: -1,
+      MimeType: "",
+      ModTime: "2026-10-18T12:00:00Z",
+    },
+    { Name: "d", IsDir: true, Size: -1, MimeType: "", ModTime: "" },
+    { Name: "u.txt", IsDir: false, Size: -1, MimeType: "", ModTime: "" },
+  ]);
 });
 
 test("renderListing keeps the digits of a time, as the precision of the remote", async () => {
diff --git a/lib/package.json b/lib/package.json
index 38bacf5..ae09c86 100644
--- a/lib/package.json
+++ b/lib/package.json
@@ -15,6 +15,7 @@
     "./path": "./path.js",
     "./progress": "./progress.js",
     "./range": "./range.js",
+    "./rewriter": "./rewriter.js",
     "./size": "./size.js",
     "./sized": "./sized.js",
     "./time": "./time.js",
@@ -36,8 +37,11 @@
   },
   "author": "Trần Nguyễn Sơn",
   "license": "ISC",
+  "dependencies": {
+    "@sntran/lol-html": "^2.8.1",
+    "entities": "^8.1.0"
+  },
   "devDependencies": {
-    "@sntran/html-rewriter": "^0.2.0",
     "fast-check": "^3.19.0"
   }
 }
diff --git a/lib/rewriter.js b/lib/rewriter.js
new file mode 100644
index 0000000..fed5211
--- /dev/null
+++ b/lib/rewriter.js
@@ -0,0 +1,86 @@
+/**
+ * HTMLRewriter, to read the elements of an HTML document, for example the
+ * list of a folder:
+ *
+ * ```js
+ * await readElements(response, [
+ *   ["tr a[href]", { element(element) { attributeOf(element, "href"); } }],
+ * ]);
+ * ```
+ *
+ * HTMLRewriter is lol-html, the HTML parser of Cloudflare, as the HTML
+ * standard tells: thus a list from a server reads the same in each runtime.
+ * In workerd and in Bun, HTMLRewriter is a part of the runtime. In Node.js and
+ * in Deno, it is the lol-html of `@sntran/lol-html` in WebAssembly, which
+ * loads at its first use: a command that reads no list does not need it.
+ */
+import { decodeHTMLAttribute } from "entities/decode";
+
+/**
+ * The handlers of the elements of a selector. A handler only reads: it is
+ * not async, and it does not change the document.
+ * @typedef {Object} ElementHandlers
+ * @property {(element: Element) => void} [element]
+ */
+
+/**
+ * An element of the document, in the handler of its start tag.
+ * @typedef {Object} Element
+ * @property {string} tagName
+ * @property {(name: string) => string | null | undefined} getAttribute
+ * @property {(handler: () => void) => void} onEndTag
+ */
+
+/**
+ * The lol-html of WebAssembly, at its first use.
+ * @type {Promise<{ HTMLRewriter: any }> | undefined}
+ */
+let loaded;
+
+/**
+ * Reads an HTML document, and calls the handlers of each selector for its
+ * elements. The document is UTF-8, as for rclone.
+ * @param {Response} response
+ * @param {Array<[string, ElementHandlers]>} handlers
+ * @returns {Promise<void>}
+ */
+export async function readElements(response, handlers) {
+  if (!response.body) return;
+  // @ts-ignore: HTMLRewriter is a global of workerd and of Bun.
+  const Native = globalThis.HTMLRewriter;
+  if (typeof Native === "function") {
+    const rewriter = new Native();
+    for (const [selector, handler] of handlers) rewriter.on(selector, handler);
+    // Only the handlers read the document: its output goes away. The
+    // runtime reads the output with no JavaScript between the chunks.
+    await rewriter.transform(response).arrayBuffer();
+    return;
+  }
+
+  loaded ??= import("@sntran/lol-html");
+  const { HTMLRewriter } = await loaded;
+  // The output of each chunk goes away. With no stream between the chunks,
+  // no queue of output chunks grows.
+  const rewriter = new HTMLRewriter("utf-8", () => {});
+  try {
+    for (const [selector, handler] of handlers) rewriter.on(selector, handler);
+    for await (const chunk of response.body) rewriter.write(chunk);
+    rewriter.end();
+  } finally {
+    rewriter.free();
+  }
+}
+
+/**
+ * The value of an attribute of an element, or null when the element does not
+ * have the attribute. HTMLRewriter gives the value as it is in the document:
+ * this function decodes its character references, as the HTML standard tells,
+ * for example `a&amp;b` gives `a&b`.
+ * @param {Element} element
+ * @param {string} name
+ * @returns {string | null}
+ */
+export function attributeOf(element, name) {
+  const value = element.getAttribute(name);
+  return value == null ? null : decodeHTMLAttribute(value);
+}
diff --git a/lib/rewriter_test.js b/lib/rewriter_test.js
new file mode 100644
index 0000000..ec0a574
--- /dev/null
+++ b/lib/rewriter_test.js
@@ -0,0 +1,116 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import fc from "fast-check";
+
+import { attributeOf, readElements } from "./rewriter.js";
+import { escapeHTML } from "./html.js";
+
+/**
+ * The elements of a document, as `name href` lines, for the selector.
+ * @param {Response} response
+ * @param {string} selector
+ */
+async function linesOf(response, selector) {
+  const lines = [];
+  await readElements(response, [
+    [selector, {
+      element(element) {
+        lines.push(`${element.tagName} ${attributeOf(element, "href")}`);
+      },
+    }],
+  ]);
+  return lines;
+}
+
+test("readElements reads HTML as the HTML standard tells", async () => {
+  const html = `<!DOCTYPE html><title><a href="title"></title>
+    <A HREF=one>1</A><a href='two'>2</a>
+    <script>document.write('<a href="script">')</script>
+    <!-- <a href="comment"> --><textarea><a href="textarea"></textarea>
+    <style>a { content: '<a href="style">' }</style>
+    <a href="three" href="not">3</a><a>no link</a>`;
+  assert.deepEqual(await linesOf(new Response(html), "a[href]"), [
+    "a one",
+    "a two",
+    "a three",
+  ]);
+});
+
+test("readElements gives the same elements for each cut in chunks", async () => {
+  const html = `<table><tr><td><a href="a%20b.txt">é</a></td></tr>
+    <tr><td><a href="c&amp;d/">c</a></td></tr></table>`;
+  const bytes = new TextEncoder().encode(html);
+  const expected = await linesOf(new Response(html), "tr a[href]");
+  assert.deepEqual(expected, ["a a%20b.txt", "a c&d/"]);
+  await fc.assert(
+    fc.asyncProperty(fc.array(fc.nat(bytes.length)), async (cuts) => {
+      const places = [...new Set([0, ...cuts, bytes.length])]
+        .sort((a, b) => a - b);
+      const chunks = places.slice(1).map((end, index) =>
+        bytes.subarray(places[index], end)
+      );
+      const response = new Response(new Blob(chunks).stream());
+      assert.deepEqual(await linesOf(response, "tr a[href]"), expected);
+    }),
+    { numRuns: 50 },
+  );
+});
+
+test("readElements reads no element of a response with no body", async () => {
+  const response = new Response(null);
+  assert.deepEqual(await linesOf(response, "a[href]"), []);
+});
+
+test("readElements gives the error of a handler", async () => {
+  await assert.rejects(
+    readElements(new Response("<a href=x>x</a>"), [
+      ["a", {
+        element() {
+          throw new Error("no");
+        },
+      }],
+    ]),
+  );
+});
+
+test("attributeOf", async (t) => {
+  /** The attribute `href` of the first link of the HTML. */
+  const hrefOf = async (html) => {
+    let href;
+    await readElements(new Response(html), [
+      ["a", {
+        element(element) {
+          href ??= attributeOf(element, "href");
+        },
+      }],
+    ]);
+    return href;
+  };
+
+  await t.test("decodes the character references", async () => {
+    assert.equal(
+      await hrefOf(`<a href="a&amp;b&lt;c&#x20;d&#39;&eacute;&nbsp;">x</a>`),
+      "a&b<c d'é\u00a0",
+    );
+  });
+
+  await t.test("keeps a legacy reference before = as text", async () => {
+    assert.equal(
+      await hrefOf(`<a href="?a=1&copy=2&amp">x</a>`),
+      "?a=1&copy=2&",
+    );
+  });
+
+  await t.test("gives null for no attribute", async () => {
+    assert.equal(await hrefOf(`<a>x</a>`), null);
+  });
+
+  await t.test("is the inverse of escapeHTML", async () => {
+    await fc.assert(
+      fc.asyncProperty(fc.fullUnicodeString(), async (text) => {
+        assert.equal(await hrefOf(`<a href="${escapeHTML(text)}">`), text);
+      }),
+      { numRuns: 50 },
+    );
+  });
+});
diff --git a/package-lock.json b/package-lock.json
index c80eb4d..407386d 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -141,8 +141,11 @@
       "name": "@rfetch/lib",
       "version": "0.1.0",
       "license": "ISC",
+      "dependencies": {
+        "@sntran/lol-html": "^2.8.1",
+        "entities": "^8.1.0"
+      },
       "devDependencies": {
-        "@sntran/html-rewriter": "^0.2.0",
         "fast-check": "^3.19.0"
       },
       "engines": {
@@ -185,14 +188,11 @@
       "resolved": "backend/s3",
       "link": true
     },
-    "node_modules/@sntran/html-rewriter": {
-      "version": "0.2.0",
-      "resolved": "https://registry.npmjs.org/@sntran/html-rewriter/-/html-rewriter-0.2.0.tgz",
-      "integrity": "sha512-jK3XgNC9snm630DhVcaiyzziUV+RWJEaB0gxl+eqLw740NRnTTp0/ywmCbYeFMGc3BDUdy8Tn8Txj1gmIi6fBg==",
-      "dev": true,
-      "dependencies": {
-        "html-rewriter-wasm": "^0.4.1"
-      }
+    "node_modules/@sntran/lol-html": {
+      "version": "2.8.1",
+      "resolved": "https://registry.npmjs.org/@sntran/lol-html/-/lol-html-2.8.1.tgz",
+      "integrity": "sha512-OQj7nsvUNQ89dX+iXjPmIN+Y8oMyALwE85K3QK6lsOFY9mN3NZBGIu6QzBcq2m63Rtsk101A6N53ZZVoL8lzsw==",
+      "license": "BSD-3-Clause"
     },
     "node_modules/@sntran/serve": {
       "version": "0.0.1",
@@ -215,6 +215,18 @@
         "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
       }
     },
+    "node_modules/entities": {
+      "version": "8.1.0",
+      "resolved": "https://registry.npmjs.org/entities/-/entities-8.1.0.tgz",
+      "integrity": "sha512-kxL7msIffSuh9aaFAMD7rxAIuTRMAHMeBtgHW2yUdWw732ZNh4MehkF2gdjvtdmikkaIP9bFDDJOPlsvm7avrA==",
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=20.19.0"
+      },
+      "funding": {
+        "url": "https://github.com/fb55/entities?sponsor=1"
+      }
+    },
     "node_modules/fast-check": {
       "version": "3.19.0",
       "resolved": "https://registry.npmjs.org/fast-check/-/fast-check-3.19.0.tgz",
@@ -237,12 +249,6 @@
         "node": ">=8.0.0"
       }
     },
-    "node_modules/html-rewriter-wasm": {
-      "version": "0.4.1",
-      "resolved": "https://registry.npmjs.org/html-rewriter-wasm/-/html-rewriter-wasm-0.4.1.tgz",
-      "integrity": "sha512-lNovG8CMCCmcVB1Q7xggMSf7tqPCijZXaH4gL6iE8BFghdQCbaY5Met9i1x2Ex8m/cZHDUtXK9H6/znKamRP8Q==",
-      "dev": true
-    },
     "node_modules/pure-rand": {
       "version": "6.1.0",
       "resolved": "https://registry.npmjs.org/pure-rand/-/pure-rand-6.1.0.tgz",

From a969d9b72c7be54b5867e0b40f0aa5ba7d2ef3b7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sun, 18 Oct 2026 20:58:33 +0000
Subject: [PATCH 80/87] fix(serve): serve the folder of the remote, with all
 its options

rfetch serve http REMOTE:PATH served the root of the remote, or the
current folder for a local path, and not PATH. The backend got only the
options in the query of TRACE: the options of the config file and of the
variables did not go, for example the password of a crypt remote in the
config file. Now each request of a client goes to the fetch of rfetch, at
REMOTE:PATH/ and the path of the request, with the flags of the backend
in the query. Thus the remote gets all its options, as for the other
commands.

The server now has all the options of the remote, thus these rules
protect it:
- A client only reads, as with rclone serve http: each method but GET
  and HEAD gives 405. The fetch of rfetch answers TRACE with the options
  of the remote, with its secrets.
- A name with a / after the decoding, for example ..%2F, gives 400.
- The links of a list have no query: the server reads no query, and the
  options of the backend do not show.
- An error gives 500 with no message, and the server continues.

The server is now node:http, not @sntran/serve. In @sntran/serve 0.0.1 to
0.0.3, new Request() refuses the method TRACE with a TypeError, and no
code catches it: one TRACE request of a client stopped rfetch serve with
the exit code 1. node:http works in Node.js, Deno and Bun. The test of
the global fetch in main_test.js uses listen of @rfetch/lib/testing/server.

main.js knows the flag --addr, thus --addr 127.0.0.1:8080 works. Before,
only --addr=127.0.0.1:8080 worked: parseArgs read the address as an
argument of the command.

Tests: cmd/serve/main_test.js serves a subfolder, a named remote of the
variables, a crypt remote of a config file, and a crypt remote with the
flag crypt_password. ..%2F gives 400. TRACE, PUT and DELETE give 405, and
the file stays. The links of a list have no query. An error gives 500,
and the next request works. main_test.js starts rfetch serve http . with
--addr 127.0.0.1:0, sends TRACE, then reads a file.
---
 CONTRIBUTING.md        |  12 ++-
 cmd/serve/http/main.js | 144 +++++++++++++++++++++++-------
 cmd/serve/main.js      |  26 ++----
 cmd/serve/main_test.js | 193 ++++++++++++++++++++++++++++++++++++-----
 main.js                |   4 +
 main_test.js           |  59 ++++++++-----
 package-lock.json      |   8 +-
 package.json           |   3 +-
 8 files changed, 343 insertions(+), 106 deletions(-)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 594a05b..a7b606e 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -121,8 +121,16 @@ A local path, for example `file.txt`, `../file.txt` or `/tmp/file.txt`, is
 relative to the current folder, as in rclone. The `fetch` of `fetch.js` gives
 the absolute path to the local backend, with `RFETCH_LOCAL_ROOT: /` in `env`.
 `RFETCH_LOCAL_ROOT` is not an option: a config file, a variable, a header or the
-query cannot set it. Thus `:local:path` and a client of `rfetch serve` stay in
-the current folder.
+query cannot set it. Thus `:local:path` stays in the current folder.
+
+`rfetch serve http REMOTE:PATH` serves the folder `REMOTE:PATH`, as
+`rclone serve http`: the path of a request is a path in that folder, and each
+request goes to the `fetch` of `fetch.js`. Thus the remote gets all its options,
+from the config file, the variables and the flags. A client only reads: the
+server refuses each method but `GET` and `HEAD`, and `TRACE` most of all,
+because the answer of `fetch.js` to `TRACE` tells the options of the remote. A
+client sets no option: the server removes its query and its headers `RFETCH_*`
+and `RCLONE_*`, and a name with a `/` after the decoding gives 400.
 
 ## Workspaces
 
diff --git a/cmd/serve/http/main.js b/cmd/serve/http/main.js
index 73649bf..c216445 100644
--- a/cmd/serve/http/main.js
+++ b/cmd/serve/http/main.js
@@ -1,12 +1,30 @@
-import { serve as serveHTTP } from "@sntran/serve";
+import { createServer } from "node:http";
+import { once } from "node:events";
+import { relink } from "@rfetch/lib/listing";
 import { isOption } from "@rfetch/lib/options";
+import { decodePath } from "@rfetch/lib/path";
+
+import { fetch } from "../../../fetch.js";
+
+/** The methods of a client, as `rclone serve http`: it only reads. */
+const METHODS = ["GET", "HEAD"];
 
 /**
- * Serve the remote over HTTP.
- * @param {(Request) => Response | Promise<Response>} fetch
- * @returns {Response}
+ * Serves a folder of a remote over HTTP, as `rclone serve http`. The path of
+ * a request is a path in the folder. Each request goes to the fetch of
+ * rfetch, thus the remote gets all its options: the config file, the
+ * variables of the environment, and the flags of the backend, for example
+ * `--crypt-password`.
+ *
+ * A client sets no option of the remote: its query and its headers
+ * `RFETCH_*` and `RCLONE_*` go away. Else a client could change the remote,
+ * for example `?remote=/etc/` for alias, or tell a new remote in the headers.
+ * @param {string} remote The remote and the path of the folder, for example
+ *   `remote:path/to/folder`.
+ * @param {Object} [flags] `addr`, and the flags of the backend.
+ * @returns {Response} The lines of the server, for example the address.
  */
-export function serve(fetch, flags = {}) {
+export function serve(remote, flags = {}) {
   const {
     addr = "127.0.0.1:8080",
     ...backendFlags
@@ -17,37 +35,103 @@ export function serve(fetch, flags = {}) {
     hostname = "0.0.0.0";
   }
 
-  const abortController = new AbortController();
+  // The path of each request goes after the folder.
+  const folder = /[:/]$/.test(remote) ? remote : `${remote}/`;
+  const query = `${new URLSearchParams(backendFlags)}`;
+
+  /**
+   * The answer to a request of a client.
+   * @param {import("node:http").IncomingMessage} incoming
+   * @param {AbortSignal} signal
+   * @returns {Promise<Response>}
+   */
+  async function answer(incoming, signal) {
+    // The check is before a Request: the Request of the Fetch standard
+    // refuses TRACE. TRACE of the fetch of rfetch also tells the options of
+    // the remote, with its secrets.
+    if (!METHODS.includes(incoming.method ?? "")) {
+      return new Response("Method Not Allowed", {
+        status: 405,
+        headers: { Allow: METHODS.join(", ") },
+      });
+    }
+    const { pathname } = new URL(incoming.url ?? "/", "http://localhost");
+    // The URL parser removes the names `.` and `..`, but a name such as
+    // `..%2F..%2Fetc` must not go out of the folder.
+    if (decodePath(pathname) === null) {
+      return new Response("Bad Request", { status: 400 });
+    }
+    const headers = new Headers();
+    const { rawHeaders } = incoming;
+    for (let i = 0; i < rawHeaders.length; i += 2) {
+      if (!isOption(rawHeaders[i])) {
+        headers.append(rawHeaders[i], rawHeaders[i + 1]);
+      }
+    }
+    const path = `${folder}${pathname.slice(1)}`;
+    const response = await fetch(query ? `${path}?${query}` : path, {
+      method: incoming.method,
+      headers,
+      signal,
+    });
+    // The links of a list have the options of the backend in their query.
+    // The server reads no query, thus the links of its lists have none.
+    const type = response.headers.get("Content-Type") || "";
+    if (response.ok && pathname.endsWith("/") && type.startsWith("text/html")) {
+      return relink(response, "");
+    }
+    return response;
+  }
+
+  const server = createServer(async (incoming, outgoing) => {
+    const controller = new AbortController();
+    outgoing.once("close", () => controller.abort());
+    /** @type {Response} */
+    let response;
+    try {
+      response = await answer(incoming, controller.signal);
+    } catch {
+      // An error does not stop the server. Its message can tell the
+      // config, thus the client does not get it.
+      response = new Response("Internal Server Error", { status: 500 });
+    }
+    try {
+      for (const [name, value] of response.headers) {
+        if (name !== "set-cookie") outgoing.setHeader(name, value);
+      }
+      const cookies = response.headers.getSetCookie();
+      if (cookies.length) outgoing.setHeader("Set-Cookie", cookies);
+      outgoing.writeHead(response.status, response.statusText || undefined);
+      if (incoming.method === "HEAD") {
+        await response.body?.cancel();
+      } else if (response.body) {
+        for await (const chunk of response.body) {
+          // Waits when the client reads slowly: else the file stays in memory.
+          if (!outgoing.write(chunk)) await once(outgoing, "drain");
+        }
+      }
+      outgoing.end();
+    } catch {
+      // The client went away.
+      await response.body?.cancel().catch(() => {});
+      outgoing.destroy();
+    }
+  });
 
   const body = new ReadableStream({
     start(controller) {
-      serveHTTP({
-        fetch(request) {
-          // A client sets no option of the remote: its query and its
-          // headers RFETCH_* and RCLONE_* go away. Else a client could
-          // change the remote, for example `?remote=/etc/` for alias, or
-          // tell a new remote in the headers.
-          const url = new URL(request.url);
-          url.search = "";
-          for (const [key, value] of Object.entries(backendFlags)) {
-            url.searchParams.set(key, value);
-          }
-          const headers = new Headers(request.headers);
-          for (const key of [...headers.keys()]) {
-            if (isOption(key)) headers.delete(key);
-          }
-          return fetch(new Request(new Request(url, request), { headers }));
-        },
-        hostname,
-        port: Number(port),
-        signal: abortController.signal,
-        onListen({ hostname, port }) {
-          controller.enqueue(`Listening on http://${hostname}:${port}`);
-        },
+      server.on("error", (error) => controller.error(error));
+      server.listen(Number(port), hostname, () => {
+        const info = server.address();
+        const where = typeof info === "string"
+          ? info
+          : `${info?.address}:${info?.port}`;
+        controller.enqueue(`Listening on http://${where}\n`);
       });
     },
     cancel() {
-      abortController.abort();
+      server.close();
+      server.closeAllConnections?.();
     },
   }).pipeThrough(new TextEncoderStream());
 
diff --git a/cmd/serve/main.js b/cmd/serve/main.js
index cee2670..7332134 100644
--- a/cmd/serve/main.js
+++ b/cmd/serve/main.js
@@ -4,33 +4,23 @@ import { load } from "../../backend/main.js";
 /**
  * Serves a remote backend
  * @param {'http'} protocol The protocol to serve.
- * @param {string} remote
+ * @param {string} remote The remote and the path of the folder to serve, for
+ *   example `remote:path/to/folder`.
  * @param {Object} flags
- * @returns {Response|Promise<Response>}
+ * @returns {Promise<Response>}
  */
 export async function serve(protocol, remote, flags = {}) {
-  // TRACE the remote to retrive its type and configuration.
+  // The remote must have a backend of rfetch. TRACE gives the type of the
+  // remote, and does not go to the backend.
   const response = await fetch(remote, { method: "TRACE" });
+  await response.body?.cancel();
   const [, type] = response.headers.get("Via")?.match(/^(.*?)(\/.*)?$/) || [];
-  const body = await response.text();
-  const [, url] = body.match(/^TRACE (.*) HTTP\/1.1$/m) ||
-    [];
-  const { searchParams } = new URL(url, "file:");
-  // Fills the options with the remote's configuration.
-  // TODO: remove prefix from flags specific for the remote.
-  searchParams.forEach((value, key) => {
-    if (!flags[key]) {
-      flags[key] = value;
-    }
-  });
-
-  const backend = await load(type);
-  if (!backend) {
+  if (!type || !await load(type)) {
     throw new Error(`Backend ${type} not found.`);
   }
 
   if (protocol === "http") {
     const { serve } = await import("./http/main.js");
-    return serve(backend.fetch, flags);
+    return serve(remote, flags);
   }
 }
diff --git a/cmd/serve/main_test.js b/cmd/serve/main_test.js
index 46048be..d98d89f 100644
--- a/cmd/serve/main_test.js
+++ b/cmd/serve/main_test.js
@@ -1,44 +1,189 @@
 import { test } from "node:test";
 import assert from "node:assert/strict";
-import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { request as httpRequest } from "node:http";
+import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import process from "node:process";
 
+import { obscure } from "@rfetch/lib/obscure";
+import { fetch as rfetch } from "../../fetch.js";
 import { serve } from "./main.js";
 
-test("a client of serve cannot set an option of the remote", async () => {
-  const inside = await mkdtemp(join(tmpdir(), "rfetch-serve-inside-"));
-  const outside = await mkdtemp(join(tmpdir(), "rfetch-serve-outside-"));
-  await writeFile(join(inside, "a.txt"), "inside");
-  await writeFile(join(outside, "a.txt"), "outside");
-  const response = await serve("http", `:alias,remote='${inside}/':`, {
+/**
+ * Serves a remote over HTTP while `check` runs. `check` gets a function that
+ * sends a request with a path and gives the text of the answer, or its
+ * status when it is not ok.
+ * @param {string} remote
+ * @param {(get: (path: string, init?: RequestInit) => Promise<string | number>, url: string) => Promise<void>} check
+ * @param {Object} [flags]
+ */
+async function serving(remote, check, flags = {}) {
+  const response = await serve("http", remote, {
     addr: "127.0.0.1:0",
+    ...flags,
   });
   const reader = response.body.getReader();
   try {
     const { value } = await reader.read();
     const [url] = new TextDecoder().decode(value).match(/http:\/\/\S+/);
-    const get = async (path, headers = {}) => {
-      const answer = await fetch(new URL(path, url), { headers });
+    await check(async (path, init = {}) => {
+      const answer = await fetch(new URL(path, url), init);
       return answer.ok ? await answer.text() : answer.status;
-    };
+    }, url);
+  } finally {
+    await reader.cancel();
+  }
+}
 
-    assert.equal(await get("/a.txt"), "inside");
-    // The query of the client is not an option.
-    assert.equal(
-      await get(`/a.txt?remote=${encodeURIComponent(`${outside}/`)}`),
-      "inside",
-    );
-    // A header of the client is not an option, and tells no remote.
-    assert.equal(
-      await get("/a.txt", {
-        RFETCH_ALIAS_REMOTE: `${outside}/`,
-        RCLONE_ALIAS_REMOTE: `${outside}/`,
-      }),
-      "inside",
+/**
+ * Sends a request with a method that fetch does not send, and gives its
+ * status.
+ * @param {string} url
+ * @param {string} method
+ * @returns {Promise<number | undefined>}
+ */
+function statusOf(url, method) {
+  return new Promise((resolve, reject) => {
+    httpRequest(url, { method }, (response) => {
+      response.resume();
+      resolve(response.statusCode);
+    }).on("error", reject).end();
+  });
+}
+
+/** A folder with `b.txt`, and `sub/a.txt` in it. */
+async function folder() {
+  const root = await mkdtemp(join(tmpdir(), "rfetch-serve-"));
+  await mkdir(join(root, "sub"));
+  await writeFile(join(root, "b.txt"), "b");
+  await writeFile(join(root, "sub", "a.txt"), "a");
+  return root;
+}
+
+test("serve serves only the folder of the remote", async () => {
+  const root = await folder();
+  try {
+    await serving(join(root, "sub"), async (get) => {
+      assert.equal(await get("/a.txt"), "a");
+      assert.equal(await get("/b.txt"), 404);
+      // The URL parser removes `..`, and a `/` after the decoding is bad.
+      assert.equal(await get("/../b.txt"), 404);
+      assert.equal(await get("/..%2Fb.txt"), 400);
+      assert.equal(await get("/x%2F..%2F..%2Fb.txt"), 400);
+    });
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test("serve gives the remote its options of the environment, of the config file and of the flags", async (t) => {
+  const root = await folder();
+  const config = await mkdtemp(join(tmpdir(), "rfetch-serve-config-"));
+  const { XDG_CONFIG_HOME } = process.env;
+  t.after(async () => {
+    if (XDG_CONFIG_HOME === undefined) delete process.env.XDG_CONFIG_HOME;
+    else process.env.XDG_CONFIG_HOME = XDG_CONFIG_HOME;
+    delete process.env.RFETCH_CONFIG_SERVED_TYPE;
+    delete process.env.RFETCH_CONFIG_SERVED_REMOTE;
+    await rm(root, { recursive: true, force: true });
+    await rm(config, { recursive: true, force: true });
+  });
+
+  await t.test("the environment", async () => {
+    process.env.RFETCH_CONFIG_SERVED_TYPE = "alias";
+    process.env.RFETCH_CONFIG_SERVED_REMOTE = `${root}/`;
+    await serving("served:sub", async (get) => {
+      assert.equal(await get("/a.txt"), "a");
+      // A request that fails does not stop the server.
+      delete process.env.RFETCH_CONFIG_SERVED_TYPE;
+      assert.equal(await get("/a.txt"), 500);
+      process.env.RFETCH_CONFIG_SERVED_TYPE = "alias";
+      assert.equal(await get("/a.txt"), "a");
+    });
+  });
+
+  const password = await (await obscure("serve password")).text();
+
+  await t.test("the config file", async () => {
+    process.env.XDG_CONFIG_HOME = config;
+    await mkdir(join(config, "rfetch"));
+    await writeFile(
+      join(config, "rfetch", "rfetch.conf"),
+      `[secret]\ntype = crypt\nremote = ${root}/encrypted/\npassword = ${password}\n`,
     );
+    const put = await rfetch("secret:sub/c.txt", {
+      method: "PUT",
+      body: "secret c",
+    });
+    assert.equal(put.status, 201);
+    await serving("secret:sub", async (get) => {
+      assert.equal(await get("/c.txt"), "secret c");
+    });
+  });
+
+  await t.test("the flags", async () => {
+    await serving(`:crypt,remote='${root}/encrypted/':sub`, async (get) => {
+      assert.equal(await get("/c.txt"), "secret c");
+    }, { crypt_password: password });
+  });
+});
+
+test("serve gives lists with no query in the links", async () => {
+  const root = await folder();
+  try {
+    await serving(`:alias,remote='${root}/':`, async (get) => {
+      const html = await get("/");
+      assert.match(html, /href="sub\/"/);
+      assert.match(html, /href="b\.txt"/);
+      assert.doesNotMatch(html, /href="[^"]*\?/);
+    });
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test("serve only reads, as rclone serve http", async () => {
+  const root = await folder();
+  try {
+    await serving(join(root, "sub"), async (get, url) => {
+      // TRACE of the fetch of rfetch tells the options of the remote.
+      assert.equal(await statusOf(url, "TRACE"), 405);
+      assert.equal(await get("/a.txt", { method: "PUT", body: "x" }), 405);
+      assert.equal(await get("/a.txt", { method: "DELETE" }), 405);
+      assert.equal(await get("/", { method: "DELETE" }), 405);
+      assert.equal(await readFile(join(root, "sub", "a.txt"), "utf8"), "a");
+    });
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test("a client of serve cannot set an option of the remote", async () => {
+  const inside = await mkdtemp(join(tmpdir(), "rfetch-serve-inside-"));
+  const outside = await mkdtemp(join(tmpdir(), "rfetch-serve-outside-"));
+  await writeFile(join(inside, "a.txt"), "inside");
+  await writeFile(join(outside, "a.txt"), "outside");
+  try {
+    await serving(`:alias,remote='${inside}/':`, async (get) => {
+      assert.equal(await get("/a.txt"), "inside");
+      // The query of the client is not an option.
+      assert.equal(
+        await get(`/a.txt?remote=${encodeURIComponent(`${outside}/`)}`),
+        "inside",
+      );
+      // A header of the client is not an option, and tells no remote.
+      assert.equal(
+        await get("/a.txt", {
+          headers: {
+            RFETCH_ALIAS_REMOTE: `${outside}/`,
+            RCLONE_ALIAS_REMOTE: `${outside}/`,
+          },
+        }),
+        "inside",
+      );
+    });
   } finally {
-    await reader.cancel();
     await rm(inside, { recursive: true, force: true });
     await rm(outside, { recursive: true, force: true });
   }
diff --git a/main.js b/main.js
index 3bbd6d8..12b4045 100755
--- a/main.js
+++ b/main.js
@@ -21,6 +21,10 @@ import { FOLDERS } from "./cmd/folders.js";
 
 /** Optional params for the subcommand. */
 const options = {
+  // The address of `serve`, for example `--addr :8080`.
+  "addr": {
+    type: "string",
+  },
   "dry-run": {
     type: "boolean",
     default: env["RCLONE_DRY_RUN"] === "true",
diff --git a/main_test.js b/main_test.js
index 7ee8467..4942a5e 100644
--- a/main_test.js
+++ b/main_test.js
@@ -1,12 +1,12 @@
 import { test } from "node:test";
 import process from "node:process";
 import { spawn } from "node:child_process";
+import { request } from "node:http";
 import { once } from "node:events";
 import { mkdir, mkdtemp, rm, stat, unlink, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { basename, join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { serve } from "@sntran/serve";
 import assert from "node:assert/strict";
 
 import { listen } from "@rfetch/lib/testing/server";
@@ -25,28 +25,16 @@ function variableOf(body, name) {
 }
 
 test("fetch", async (t) => {
-  await t.test("global", () => {
-    const controller = new AbortController();
-    serve({
-      fetch: (_request) => new Response(),
-      port: 0,
-      signal: controller.signal,
-      async onListen({ port, hostname }) {
-        const url = `http://${hostname}:${port}/`;
-        let response = await fetch(url, {
-          method: "HEAD",
-        });
-        assert(response.ok);
-
-        const request = new Request(url, {
-          method: "HEAD",
-        });
-        response = await fetch(request);
-        assert(response.ok);
-
-        controller.abort();
-      },
-    });
+  await t.test("global", async () => {
+    const server = await listen(() => new Response());
+    try {
+      let response = await fetch(`${server.url}`, { method: "HEAD" });
+      assert(response.ok);
+      response = await fetch(new Request(server.url, { method: "HEAD" }));
+      assert(response.ok);
+    } finally {
+      await server.close();
+    }
   });
 
   await t.test("TRACE", async (t) => {
@@ -514,6 +502,31 @@ test("the command line", async (t) => {
       assert.equal(code, 0);
       assert.equal(stderr, "");
     });
+
+    await t.test("serve reads --addr, and a TRACE does not stop it", async () => {
+      const child = spawn(
+        process.execPath,
+        [MAIN, "serve", "http", ".", "--addr", "127.0.0.1:0"],
+        { cwd: folder },
+      );
+      try {
+        const [line] = await once(child.stdout, "data");
+        const [url] = `${line}`.match(/http:\/\/127\.0\.0\.1:\d+/) ?? [];
+        assert.ok(url, `${line}`);
+        const status = await new Promise((resolve, reject) => {
+          request(`${url}/`, { method: "TRACE" }, (response) => {
+            response.resume();
+            resolve(response.statusCode);
+          }).on("error", reject).end();
+        });
+        assert.equal(status, 405);
+        const response = await fetch(new URL("a.txt", `${url}/`));
+        assert.equal(await response.text(), "a");
+        assert.equal(child.exitCode, null);
+      } finally {
+        child.kill();
+      }
+    });
   } finally {
     await rm(folder, { recursive: true, force: true });
   }
diff --git a/package-lock.json b/package-lock.json
index 407386d..b1f24ca 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -21,8 +21,7 @@
         "@rfetch/lib": "^0.1.0",
         "@rfetch/local": "^0.1.0",
         "@rfetch/memory": "^0.1.0",
-        "@rfetch/s3": "^0.1.0",
-        "@sntran/serve": "^0.0.1"
+        "@rfetch/s3": "^0.1.0"
       },
       "bin": {
         "rfetch": "main.js"
@@ -194,11 +193,6 @@
       "integrity": "sha512-OQj7nsvUNQ89dX+iXjPmIN+Y8oMyALwE85K3QK6lsOFY9mN3NZBGIu6QzBcq2m63Rtsk101A6N53ZZVoL8lzsw==",
       "license": "BSD-3-Clause"
     },
-    "node_modules/@sntran/serve": {
-      "version": "0.0.1",
-      "resolved": "https://registry.npmjs.org/@sntran/serve/-/serve-0.0.1.tgz",
-      "integrity": "sha512-yejSB/mTWeRg7fK++lLZcz5Av407HZ7VN4l84FxxpCoERpGRL1fP43wNeRC4xeup7xPtnHXsjinxz6xEByglNA=="
-    },
     "node_modules/base32-decode": {
       "version": "1.0.0",
       "resolved": "https://registry.npmjs.org/base32-decode/-/base32-decode-1.0.0.tgz",
diff --git a/package.json b/package.json
index 09acd96..ea63b49 100644
--- a/package.json
+++ b/package.json
@@ -39,8 +39,7 @@
     "@rfetch/lib": "^0.1.0",
     "@rfetch/local": "^0.1.0",
     "@rfetch/memory": "^0.1.0",
-    "@rfetch/s3": "^0.1.0",
-    "@sntran/serve": "^0.0.1"
+    "@rfetch/s3": "^0.1.0"
   },
   "devDependencies": {
     "fast-check": "^3.19.0"

From b6933d97a139032d53fb7cc24b6d2538d51d4abc Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sun, 18 Oct 2026 21:01:07 +0000
Subject: [PATCH 81/87] docs(readme): the time of the commands on each runtime
 and with rclone

The new section Runtimes tells how to run rfetch on Node.js, Deno and
Bun, and gives one run of bench/rclone.js on Node.js 22, 24 and 26, Deno
2.9, Bun 1.4 and rclone 1.75.1. It recommends no runtime: the times
change from one run to the next and from one machine to the next, thus a
user runs the benchmark on the machine of the user to choose.
---
 README.md | 38 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 38 insertions(+)

diff --git a/README.md b/README.md
index 32d203c..1f69798 100644
--- a/README.md
+++ b/README.md
@@ -60,6 +60,44 @@ bytes, with ranges. The prefix `RCLONE_` of rclone also works.
 - `reveal`
 - `serve`
 
+## Runtimes
+
+rfetch runs on Node.js 22.2 or later, on Deno and on Bun:
+
+```sh
+node main.js COMMAND ...
+deno run -A main.js COMMAND ...
+bun main.js COMMAND ...
+```
+
+`node bench/rclone.js RUNTIME...` runs the same commands with rfetch on each
+runtime and with rclone, and first makes sure that they give the same data and
+the same lists. Each time is the median of 5 runs of the command as a new
+process, in ms, thus the start of the runtime is in it. The table is one run on
+a Linux machine with 4 CPUs (Intel Xeon at 2.10 GHz) and rclone 1.75.1. The
+times on one machine can change by 10 to 25 % from one run to the next, also for
+rclone. Run the benchmark on your machine to choose a runtime.
+
+| Command, in ms                             | Node.js 22.22 | Node.js 24.21 | Node.js 26.12 | Deno 2.9.6 | Bun 1.4.3 | rclone 1.75.1 |
+| ------------------------------------------ | ------------: | ------------: | ------------: | ---------: | --------: | ------------: |
+| `lsjson` of an empty folder                |           135 |           130 |           142 |        108 |        48 |            57 |
+| local: `cat` of 64 MiB                     |           166 |           187 |           176 |        155 |        90 |            90 |
+| local: `lsjson --recursive`, 1000 files    |           267 |           249 |           226 |        212 |        73 |            50 |
+| crypt: `cat` of 64 MiB                     |           383 |           395 |           416 |        411 |       402 |           228 |
+| crypt: `rcat` of 64 MiB                    |           469 |           449 |           429 |        535 |       461 |           443 |
+| crypt: `lsjson --recursive`, 1000 files    |           387 |           347 |           346 |        347 |       160 |           113 |
+| chunker: `cat` of 64 MiB, chunks of 8 MiB  |           235 |           209 |           220 |        188 |       113 |            81 |
+| chunker: `rcat` of 64 MiB, chunks of 8 MiB |           377 |           364 |           363 |        474 |       285 |           380 |
+
+- `lsjson` of an empty folder shows the time of the start.
+- crypt and chunker are on top of local files. rclone writes the files that
+  rfetch reads.
+- Deno gives the time of a local file to the millisecond. The other runtimes and
+  rclone give it to the nanosecond.
+- In Bun and in a Cloudflare Worker, HTMLRewriter is a part of the runtime. In
+  Node.js and in Deno, it is WebAssembly, which loads when a command reads the
+  first list.
+
 ## Development
 
 - Clone the repository and go to its folder.

From 2143813f7f386b8e05a02a4e430e0b15778db005 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sun, 18 Oct 2026 21:58:09 +0000
Subject: [PATCH 82/87] test(lib): the property of readListing makes only names
 of files

The property of f2e5f34 made a name of each text, and failed about one
time in five runs. The link of the name . is the folder, the link of ..
is its parent, and a name with / is two names: readListing cannot give
them back, and decodePath refuses them. Now the property makes no such
name. It passes in 150 runs.
---
 lib/listing_test.js | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/lib/listing_test.js b/lib/listing_test.js
index d3d1a5f..c33da1a 100644
--- a/lib/listing_test.js
+++ b/lib/listing_test.js
@@ -96,7 +96,11 @@ function inChunks(html, cuts) {
 
 test("readListing gives back the entries of renderListing", async () => {
   const entry = fc.record({
-    Name: fc.fullUnicodeString({ minLength: 1, maxLength: 12 }),
+    // `.`, `..` and a name with `/` are not names of files: the link of `.`
+    // is the folder, the link of `..` is its parent, and `/` is between two
+    // names.
+    Name: fc.fullUnicodeString({ minLength: 1, maxLength: 12 })
+      .filter((name) => name !== "." && name !== ".." && !name.includes("/")),
     IsDir: fc.boolean(),
     Size: fc.nat(),
     MimeType: fc.constantFrom("", "text/plain; charset=utf-8", "image/png"),

From 2603acd2325bc114d740818ec3e723bcd41fd965 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sun, 18 Oct 2026 21:58:09 +0000
Subject: [PATCH 83/87] fix(cli): a value after a space for each flag, as
 rclone

The parseArgs of Node.js takes the next argument as the value only for
a flag that it knows as a string. main.js told it few flags, with strict
false: thus --crypt-password x or --max-depth 2 gave the flag true, and
the value became an argument of the command.

Now parseFlags of the new cmd/flags.js tells parseArgs the type of each
flag, as rclone:
- FLAGS has the flags of the commands. A boolean flag takes no value, or
  a value after =, for example --dir-slash=false. A string flag takes
  the next argument, or a value after =.
- A flag of a backend, for example --crypt-password, has the type of the
  option in the options of the module of the backend. Only the backends
  of the flags load. alias, crypt and drive now export their options.
- An unknown flag, a flag with no value, and a boolean value that Go does
  not read give the error of rclone, with the exit code 1.
- A flag with the name no-... is not the negation of a flag. Before,
  allowNegative made --no-clobber of copyurl into clobber: false.
- --help shows the help, and rfetch help flags lists the flags.
- The short flags of rclone: -R, -F, -s, -d, -a, -p, -n.

Two bugs of the boolean flags in the lists, fixed with isTrue of
@rfetch/lib/options, which reads true and the text true:
- lsd gave recursive the text false, which is true in JavaScript: thus
  lsd listed all the folders below. Now it lists one level, as rclone.
- lsjson . and lsjson .. gave directory not found. A path with . or .. at
  the end is a folder now, as in rclone.

Tests: cmd/flags_test.js reads flags after a space and after =, the
flags of backends, the booleans of rclone, the arguments after --, the
errors, and each option of each backend of rfetch as a flag. main_test.js
runs lsf with flags after a space, an unknown flag, lsd and lsjson .
---
 CONTRIBUTING.md       |  17 ++++
 backend/alias/main.js |   8 ++
 backend/crypt/main.js |   8 ++
 backend/drive/main.js |  20 +++++
 cmd/flags.js          | 185 ++++++++++++++++++++++++++++++++++++++++++
 cmd/flags_test.js     | 157 +++++++++++++++++++++++++++++++++++
 cmd/help/main.js      |  16 +++-
 cmd/ls/main.js        |   4 +-
 cmd/lsd/main.js       |   4 +-
 cmd/lsf/main.js       |  14 ++--
 cmd/lsjson/main.js    |   8 +-
 cmd/lsl/main.js       |   4 +-
 lib/options.js        |  10 +++
 main.js               |  78 +++++-------------
 main_test.js          |  42 ++++++++++
 15 files changed, 496 insertions(+), 79 deletions(-)
 create mode 100644 cmd/flags.js
 create mode 100644 cmd/flags_test.js

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index a7b606e..461ac22 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -103,6 +103,12 @@ then the secret is not in a URL. A backend makes the links of a list from the
 query of the request only, with no secret option. Thus an option of a header or
 of `env` is never in a link.
 
+The module of a backend exports its options with their types, for example
+`export const options = { boolean: ["no_head"], string: ["url"] }`. An option in
+`default` and in no list is a `string`. The command line makes a flag of each
+option, for example `--http-no-head` and `--http-url URL`. An option that is not
+in `options` has no flag: its flag is an unknown flag.
+
 A backend on top of another remote sends the headers
 `remoteHeaders(request.headers, "remote", remote)` to that remote. The other
 options of the request go on, for example a remote `RFETCH_CONFIG_NAME_TYPE`
@@ -235,6 +241,17 @@ commands takes much time. A command imports `fetch.js` and the modules of the
 other commands that it uses, not `mod.js`. The test `cmd/folders_test.js` makes
 sure that the two lists are the same.
 
+`parseFlags` of `cmd/flags.js` reads the flags of the command line, as rclone.
+Each flag has a type: a flag of type `boolean` takes no value, or a value after
+`=`, for example `--dir-slash=false`. A flag of type `string` takes the next
+argument, for example `--max-depth 2`, or a value after `=`. The `parseArgs` of
+Node.js knows the type only of the flags that it gets: it reads an unknown flag
+as a `boolean`, and the value of the flag as an argument of the command. Thus a
+new flag of a command goes in `FLAGS` of `cmd/flags.js`, and a new option of a
+backend goes in its `options`. An unknown flag is an error, as in rclone. A
+command reads a boolean flag with `isTrue` of `@rfetch/lib/options`: the flag
+can be `true` or the text `true` of a query.
+
 ## Tests of a backend
 
 Each backend must pass the shared tests of `@rfetch/lib/testing/suite`. These
diff --git a/backend/alias/main.js b/backend/alias/main.js
index ed378c0..fbf31c0 100644
--- a/backend/alias/main.js
+++ b/backend/alias/main.js
@@ -23,6 +23,14 @@ import { relink } from "@rfetch/lib/listing";
 import { optionsOf, remoteHeaders } from "@rfetch/lib/options";
 import { decodePath, encodePath } from "@rfetch/lib/path";
 
+/**
+ * The options of the backend, with their types, for example for the flag
+ * `--alias-remote` of the command line.
+ */
+export const options = {
+  string: ["remote"],
+};
+
 /**
  * Sends the requests to the remote of the alias with the global `fetch`.
  * @param {Request} request
diff --git a/backend/crypt/main.js b/backend/crypt/main.js
index 1baaca4..aa5bb73 100644
--- a/backend/crypt/main.js
+++ b/backend/crypt/main.js
@@ -149,6 +149,14 @@ const SECRETBOX_OPTIONS = {
   magic: encoder.encode("RCLONE\x00\x00"),
 };
 
+/**
+ * The options of the backend, with their types, for example for the flag
+ * `--crypt-password` of the command line.
+ */
+export const options = {
+  string: ["remote", "password", "password2"],
+};
+
 /**
  * The options that are secret. They are not in the links of a list, which a
  * browser can keep in its history and send to other sites.
diff --git a/backend/drive/main.js b/backend/drive/main.js
index 0dfbbce..80a9b7d 100644
--- a/backend/drive/main.js
+++ b/backend/drive/main.js
@@ -15,6 +15,26 @@ const FILE_HEADERS = new Headers({
   "Content-Type": "application/octet-stream",
 });
 
+/**
+ * The options of the backend, with their types, for example for the flag
+ * `--drive-client-id` of the command line.
+ */
+export const options = {
+  string: [
+    "chunk_size",
+    "client_id",
+    "client_secret",
+    "fields",
+    "root_folder_id",
+    "scope",
+    "service_account_credentials",
+    "service_account_file",
+    "team_drive",
+    "token",
+    "token_url",
+  ],
+};
+
 /**
  * The options that are secret. They are not in the links of a list.
  */
diff --git a/cmd/flags.js b/cmd/flags.js
new file mode 100644
index 0000000..281925b
--- /dev/null
+++ b/cmd/flags.js
@@ -0,0 +1,185 @@
+/**
+ * The flags of the command line, as in rclone. Each flag has a type:
+ *
+ * - A flag of type `boolean` takes no value, for example `--recursive`, or a
+ *   value after `=`, for example `--dir-slash=false`.
+ * - A flag of type `string` takes the next argument as its value, for
+ *   example `--addr :8080`, or a value after `=`, for example
+ *   `--addr=:8080`.
+ *
+ * The `parseArgs` of Node.js takes the next argument as the value only for a
+ * flag that it knows as `string`: it reads an unknown flag as `boolean`, and
+ * its value as an argument of the command. Thus rfetch tells it the type of
+ * each flag, and an unknown flag is an error, as in rclone.
+ */
+import { env } from "node:process";
+import { parseArgs } from "node:util";
+
+/**
+ * The value of a variable of rfetch, or of rclone for compatibility, for
+ * example `RFETCH_DRY_RUN` or `RCLONE_DRY_RUN`.
+ * @param {string} name For example `DRY_RUN`.
+ * @returns {string | undefined}
+ */
+function variable(name) {
+  return env[`RFETCH_${name}`] ?? env[`RCLONE_${name}`];
+}
+
+/**
+ * The flags of the commands, in the format of `parseArgs`.
+ * @type {Record<string, import("node:util").ParseArgsOptionDescriptor>}
+ */
+export const FLAGS = {
+  // `serve`
+  "addr": { type: "string" },
+  // `copyurl`
+  "auto-filename": { type: "boolean", short: "a" },
+  // `lsf`
+  "csv": { type: "boolean" },
+  // `lsf`
+  "dir-slash": { type: "boolean", short: "d" },
+  // `lsf`
+  "dirs-only": { type: "boolean" },
+  "dry-run": {
+    type: "boolean",
+    short: "n",
+    default: variable("DRY_RUN") === "true",
+  },
+  // `lsf`
+  "files-only": { type: "boolean" },
+  // `lsf`
+  "format": { type: "string", short: "F" },
+  "header": { type: "string", multiple: true },
+  "header-download": { type: "string", multiple: true },
+  // `copyurl`
+  "header-filename": { type: "boolean" },
+  "header-upload": { type: "string", multiple: true },
+  "help": { type: "boolean", short: "h" },
+  "human-readable": { type: "boolean" },
+  // The lists
+  "max-depth": { type: "string" },
+  // `copyurl`
+  "no-clobber": { type: "boolean" },
+  // `copyurl`
+  "print-filename": { type: "boolean", short: "p" },
+  "progress": {
+    type: "boolean",
+    short: "P",
+    default: variable("PROGRESS") === "true",
+  },
+  // The lists
+  "recursive": { type: "boolean", short: "R" },
+  // `lsf`
+  "separator": { type: "string", short: "s" },
+  // `copyurl`
+  "stdout": { type: "boolean" },
+  "transfers": { type: "string", default: variable("TRANSFERS") || "4" },
+};
+
+/**
+ * The options of a backend, for example `{ boolean: ["no_head"], string:
+ * ["url"] }`. An option of `default` that is in no list is a `string`.
+ * @typedef {Object} BackendOptions
+ * @property {string[]} [boolean]
+ * @property {string[]} [string]
+ * @property {Record<string, unknown>} [default]
+ */
+
+/**
+ * The values that `strconv.ParseBool` of Go reads, as rclone.
+ * @type {Record<string, boolean>}
+ */
+const BOOLEANS = {
+  "1": true,
+  "t": true,
+  "T": true,
+  "true": true,
+  "TRUE": true,
+  "True": true,
+  "0": false,
+  "f": false,
+  "F": false,
+  "false": false,
+  "FALSE": false,
+  "False": false,
+};
+
+/**
+ * Reads the flags and the arguments of a command line.
+ *
+ * A flag of a backend has the type of the backend before its name, for
+ * example `--crypt-password` for the option `password` of `crypt`. Its type
+ * comes from the `options` of the module of the backend. Only the backends
+ * that the flags tell load.
+ *
+ * Each flag is in the result with its name, for example `dry-run`, and with
+ * `_` in the place of `-`, for example `dry_run`.
+ * @param {string[]} args The arguments, with no program, for example
+ *   `["lsjson", "--max-depth", "2", "remote:"]`.
+ * @param {Record<string, () => Promise<{ options?: BackendOptions }>>} backends
+ *   The modules of the backends, by type.
+ * @returns {Promise<{ flags: Record<string, unknown>, positionals: string[] }>}
+ * @throws {Error} For an unknown flag, a flag with no value, or a value that
+ *   is not a boolean, with the message of rclone.
+ */
+export async function parseFlags(args, backends) {
+  /** @type {Record<string, import("node:util").ParseArgsOptionDescriptor>} */
+  const options = { ...FLAGS };
+
+  for (const arg of args) {
+    if (arg === "--") break;
+    if (!arg.startsWith("--")) continue;
+    const name = arg.slice(2).split("=", 1)[0];
+    if (Object.hasOwn(options, name)) continue;
+    const type = name.slice(0, name.indexOf("-"));
+    if (!type || !Object.hasOwn(backends, type)) continue;
+    const declared = (await backends[type]()).options ?? {};
+    const booleans = declared.boolean ?? [];
+    const names = [
+      ...booleans,
+      ...declared.string ?? [],
+      ...Object.keys(declared.default ?? {}),
+    ];
+    for (const option of names) {
+      options[`${type}-${option.replaceAll("_", "-")}`] = {
+        type: booleans.includes(option) ? "boolean" : "string",
+      };
+    }
+  }
+
+  const { values, positionals, tokens } = parseArgs({
+    args,
+    options,
+    strict: false,
+    allowPositionals: true,
+    tokens: true,
+  });
+
+  for (const token of tokens) {
+    if (token.kind !== "option") continue;
+    const option = options[token.name];
+    if (!option) throw new Error(`unknown flag: ${token.rawName}`);
+    if (option.type === "string" && token.value === undefined) {
+      throw new Error(`flag needs an argument: ${token.rawName}`);
+    }
+    if (option.type === "boolean" && token.value !== undefined) {
+      const value = Object.hasOwn(BOOLEANS, token.value)
+        ? BOOLEANS[token.value]
+        : undefined;
+      if (value === undefined) {
+        throw new Error(
+          `invalid argument "${token.value}" for "${token.rawName}" flag`,
+        );
+      }
+      values[token.name] = value;
+    }
+  }
+
+  /** @type {Record<string, unknown>} */
+  const flags = {};
+  for (const [name, value] of Object.entries(values)) {
+    flags[name] = value;
+    flags[name.replaceAll("-", "_")] = value;
+  }
+  return { flags, positionals };
+}
diff --git a/cmd/flags_test.js b/cmd/flags_test.js
new file mode 100644
index 0000000..f23d65a
--- /dev/null
+++ b/cmd/flags_test.js
@@ -0,0 +1,157 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+
+import { backends } from "../backend/main.js";
+import { FLAGS, parseFlags } from "./flags.js";
+
+/**
+ * Backends with options, as the modules of `backend/main.js`. `loaded` has
+ * the type of each backend that loads.
+ */
+function fakeBackends() {
+  /** @type {string[]} */
+  const loaded = [];
+  const module = (type, options) => () => {
+    loaded.push(type);
+    return Promise.resolve({ options });
+  };
+  return {
+    loaded,
+    backends: {
+      crypt: module("crypt", { string: ["remote", "password"] }),
+      http: module("http", { boolean: ["no_head"], string: ["url"] }),
+      local: module("local", undefined),
+      s3: module("s3", {
+        boolean: ["force_path_style"],
+        default: { chunk_size: "5Mi" },
+      }),
+    },
+  };
+}
+
+test("parseFlags reads the value of a flag after a space or after =", async () => {
+  for (
+    const args of [
+      ["serve", "http", ".", "--addr", ":8080"],
+      ["serve", "--addr=:8080", "http", "."],
+      ["--addr", ":8080", "serve", "http", "."],
+    ]
+  ) {
+    const { flags, positionals } = await parseFlags(args, {});
+    assert.equal(flags.addr, ":8080", args.join(" "));
+    assert.deepEqual(positionals, ["serve", "http", "."], args.join(" "));
+  }
+});
+
+test("parseFlags reads a flag of a backend with the type of its option", async () => {
+  const { backends, loaded } = fakeBackends();
+  const { flags, positionals } = await parseFlags([
+    "lsjson",
+    "--crypt-password",
+    "secret",
+    "--http-no-head",
+    "remote:",
+    "--s3-force-path-style=false",
+    "--s3-chunk-size",
+    "8Mi",
+  ], backends);
+  assert.deepEqual(positionals, ["lsjson", "remote:"]);
+  assert.equal(flags.crypt_password, "secret");
+  assert.equal(flags["crypt-password"], "secret");
+  assert.equal(flags.http_no_head, true);
+  assert.equal(flags.s3_force_path_style, false);
+  assert.equal(flags.s3_chunk_size, "8Mi");
+  // Only the backends of the flags load.
+  assert.deepEqual(loaded.toSorted(), ["crypt", "http", "s3"]);
+});
+
+test("parseFlags reads the boolean flags as rclone", async () => {
+  const { flags, positionals } = await parseFlags([
+    "lsf",
+    "-R",
+    "--dir-slash=false",
+    "--files-only=1",
+    "--no-clobber",
+    "remote:",
+  ], {});
+  assert.deepEqual(positionals, ["lsf", "remote:"]);
+  assert.equal(flags.recursive, true);
+  assert.equal(flags.dir_slash, false);
+  assert.equal(flags.files_only, true);
+  // A flag with the name `no-...` is not the negation of a flag.
+  assert.equal(flags.no_clobber, true);
+  assert.equal(flags.clobber, undefined);
+});
+
+test("parseFlags gives the arguments after -- as they are", async () => {
+  const { flags, positionals } = await parseFlags(
+    ["cat", "--", "--addr"],
+    {},
+  );
+  assert.deepEqual(positionals, ["cat", "--addr"]);
+  assert.equal(flags.addr, undefined);
+});
+
+test("parseFlags gives the errors of rclone", async () => {
+  const { backends } = fakeBackends();
+  for (
+    const [args, message] of [
+      [["lsjson", "--nosuch", "x"], "unknown flag: --nosuch"],
+      [["lsjson", "-x"], "unknown flag: -x"],
+      // The local backend has no option: the root is not a flag.
+      [["lsjson", "--local-root", "/"], "unknown flag: --local-root"],
+      [["lsjson", "--crypt-nosuch", "x"], "unknown flag: --crypt-nosuch"],
+      [["lsjson", "--max-depth"], "flag needs an argument: --max-depth"],
+      [
+        ["lsjson", "--dry-run=maybe"],
+        'invalid argument "maybe" for "--dry-run" flag',
+      ],
+      [
+        ["lsjson", "--dry-run=constructor"],
+        'invalid argument "constructor" for "--dry-run" flag',
+      ],
+    ]
+  ) {
+    await assert.rejects(parseFlags(args, backends), { message }, `${args}`);
+  }
+});
+
+test("parseFlags reads each option of each backend of rfetch as a flag", async () => {
+  for (const [type, load] of Object.entries(backends)) {
+    const { options } = await load();
+    if (!options) continue;
+    const booleans = options.boolean ?? [];
+    const strings = [
+      ...options.string ?? [],
+      ...Object.keys(options.default ?? {}),
+    ].filter((name) => !booleans.includes(name));
+    for (const name of booleans) {
+      const flag = `--${type}-${name.replaceAll("_", "-")}`;
+      const { flags, positionals } = await parseFlags(
+        ["lsjson", flag, "remote:"],
+        backends,
+      );
+      assert.equal(flags[`${type}_${name}`], true, flag);
+      assert.deepEqual(positionals, ["lsjson", "remote:"], flag);
+    }
+    for (const name of strings) {
+      const flag = `--${type}-${name.replaceAll("_", "-")}`;
+      const { flags, positionals } = await parseFlags(
+        ["lsjson", flag, "value", "remote:"],
+        backends,
+      );
+      assert.equal(flags[`${type}_${name}`], "value", flag);
+      assert.deepEqual(positionals, ["lsjson", "remote:"], flag);
+    }
+  }
+});
+
+test("FLAGS has a type for each flag, and no short name two times", () => {
+  const shorts = Object.values(FLAGS).map(({ short }) => short).filter(
+    Boolean,
+  );
+  assert.equal(new Set(shorts).size, shorts.length);
+  for (const [name, { type }] of Object.entries(FLAGS)) {
+    assert.ok(type === "boolean" || type === "string", name);
+  }
+});
diff --git a/cmd/help/main.js b/cmd/help/main.js
index acad915..54a937b 100644
--- a/cmd/help/main.js
+++ b/cmd/help/main.js
@@ -1,4 +1,5 @@
 import { backends } from "../../backend/main.js";
+import { FLAGS } from "../flags.js";
 import { FOLDERS } from "../folders.js";
 
 /**
@@ -21,14 +22,21 @@ Use "rfetch help backends" for a list of supported services.
 
 usage["flags"] = () =>
   `Usage:
-  rfetch help flags [<regexp to match>] [flags]
-
-Flags:
-  -h, --help   help for flags
+  rfetch help flags
 
 Global Flags:
+${
+    Object.entries(FLAGS).map(([name, { type, short }]) =>
+      `  ${short ? `-${short}, ` : "    "}--${name}${
+        type === "string" ? " string" : ""
+      }`
+    ).join("\n")
+  }
 
 Backend Flags:
+  --TYPE-NAME string   The option NAME of the backend TYPE, for example
+                       --crypt-password or --s3-chunk-size. A boolean
+                       option takes no value, for example --http-no-head.
 `;
 
 usage["backends"] = () =>
diff --git a/cmd/ls/main.js b/cmd/ls/main.js
index 8ee5269..7ed74d4 100644
--- a/cmd/ls/main.js
+++ b/cmd/ls/main.js
@@ -24,9 +24,9 @@ import { lsf } from "../lsf/main.js";
  */
 export function ls(location, flags = {}) {
   flags = {
-    recursive: "true",
+    recursive: true,
     max_depth: "Infinity",
-    files_only: "true",
+    files_only: true,
     format: "sp",
     separator: "\t",
     ...flags,
diff --git a/cmd/lsd/main.js b/cmd/lsd/main.js
index de0b51e..a65261d 100644
--- a/cmd/lsd/main.js
+++ b/cmd/lsd/main.js
@@ -12,9 +12,9 @@ import { lsf } from "../lsf/main.js";
  */
 export function lsd(location, flags = {}) {
   flags = {
-    dirs_only: "true",
+    dirs_only: true,
     format: "stp",
-    recursive: "false",
+    recursive: false,
     separator: "\t",
     ...flags,
   };
diff --git a/cmd/lsf/main.js b/cmd/lsf/main.js
index 2e1516c..6a8ee6b 100644
--- a/cmd/lsf/main.js
+++ b/cmd/lsf/main.js
@@ -1,3 +1,4 @@
+import { isTrue } from "@rfetch/lib/options";
 import { lsjson } from "../lsjson/main.js";
 
 const FORMATS = {
@@ -115,14 +116,11 @@ const FORMATS = {
  * @returns {Promise<Response>}
  */
 export async function lsf(location, flags = {}) {
-  const {
-    csv = false,
-    dir_slash: dirSlash = true,
-    dirs_only: dirsOnly = false,
-    files_only: filesOnly = false,
-    format = "p",
-    separator = ";",
-  } = flags;
+  const { format = "p", separator = ";" } = flags;
+  const csv = isTrue(flags.csv);
+  const dirSlash = flags.dir_slash === undefined || isTrue(flags.dir_slash);
+  const dirsOnly = isTrue(flags.dirs_only);
+  const filesOnly = isTrue(flags.files_only);
 
   const response = await lsjson(location, flags);
   let { ok, headers, body } = response;
diff --git a/cmd/lsjson/main.js b/cmd/lsjson/main.js
index cac35c2..4a3ea1f 100644
--- a/cmd/lsjson/main.js
+++ b/cmd/lsjson/main.js
@@ -1,5 +1,6 @@
 import { parse } from "@rfetch/lib/fspath";
 import { readListing } from "@rfetch/lib/listing";
+import { isTrue } from "@rfetch/lib/options";
 import { toLocaleISOString } from "@rfetch/lib/time";
 
 import { fetch } from "../../fetch.js";
@@ -59,6 +60,8 @@ const FOLDER = new URL("http://remote/folder/");
  * @returns {Promise<Response>}
  */
 export async function lsjson(location, flags = {}, init = {}) {
+  // A path that ends with `.` or `..` is a folder, as in rclone.
+  if (/(^|[:/])\.\.?$/.test(location)) location = `${location}/`;
   // Only the path in the remote has folders: a value of the connection
   // string can have a "/" too, for example `:crypt,remote='a/b':path`.
   const parsed = parse(location);
@@ -98,8 +101,9 @@ export async function lsjson(location, flags = {}, init = {}) {
     }
   }
 
-  let maxDepth = Number(flags.max_depth || (flags.recursive ? Infinity : 1));
-  if (!isDirectory || !flags.recursive) {
+  const recursive = isTrue(flags.recursive);
+  let maxDepth = Number(flags.max_depth || (recursive ? Infinity : 1));
+  if (!isDirectory || !recursive) {
     maxDepth = 1;
   }
 
diff --git a/cmd/lsl/main.js b/cmd/lsl/main.js
index 3c82937..ef858ee 100644
--- a/cmd/lsl/main.js
+++ b/cmd/lsl/main.js
@@ -25,9 +25,9 @@ import { lsf } from "../lsf/main.js";
  */
 export function lsl(location, flags = {}) {
   flags = {
-    recursive: "true",
+    recursive: true,
     max_depth: "Infinity",
-    files_only: "true",
+    files_only: true,
     format: "stp",
     separator: "\t",
     ...flags,
diff --git a/lib/options.js b/lib/options.js
index 050db23..17a31f1 100644
--- a/lib/options.js
+++ b/lib/options.js
@@ -12,6 +12,16 @@
 /** The prefixes of the options, the primary one first. */
 export const PREFIXES = ["rfetch_", "rclone_"];
 
+/**
+ * Tells if a flag or an option is on: `true`, or the text `true` of a query
+ * or of a variable.
+ * @param {unknown} value
+ * @returns {boolean}
+ */
+export function isTrue(value) {
+  return value === true || value === "true";
+}
+
 /**
  * Gives the options of a backend for a request: a field of the query
  * first, then the header `RFETCH_TYPE_NAME` or `RCLONE_TYPE_NAME`, then the
diff --git a/main.js b/main.js
index 12b4045..8e1049b 100755
--- a/main.js
+++ b/main.js
@@ -10,78 +10,38 @@
  * ./main.js copy source:/path/to/file destination:/path/to/file
  * ```
  */
-import process, { argv, env, stderr, stdout } from "node:process";
+import process, { argv, stderr, stdout } from "node:process";
 import { once } from "node:events";
-import { parseArgs } from "node:util";
 
 // The import sets the global `fetch`, which reads the paths of remotes.
 import "./fetch.js";
 
+import { backends } from "./backend/main.js";
+import { parseFlags } from "./cmd/flags.js";
 import { FOLDERS } from "./cmd/folders.js";
 
-/** Optional params for the subcommand. */
-const options = {
-  // The address of `serve`, for example `--addr :8080`.
-  "addr": {
-    type: "string",
-  },
-  "dry-run": {
-    type: "boolean",
-    default: env["RCLONE_DRY_RUN"] === "true",
-  },
-  "header": {
-    type: "string",
-    multiple: true,
-  },
-  "header-download": {
-    type: "string",
-    multiple: true,
-  },
-  "header-upload": {
-    type: "string",
-    multiple: true,
-  },
-  "human-readable": {
-    type: "boolean",
-  },
-  "progress": {
-    type: "boolean",
-    short: "P",
-    default: env["RCLONE_PROGRESS"] === "true",
-  },
-  "transfers": {
-    type: "string",
-    default: env["RCLONE_TRANSFERS"] || "4",
-  },
-};
-
-const {
-  values: flags,
-  positionals: [
-    subcommand = "help",
-    ...args
-  ],
-} = parseArgs({
-  args: argv.slice(2),
-  options,
-  strict: false,
-  allowPositionals: true,
-  allowNegative: true,
-  tokens: true,
-});
-
-for (const name of Object.keys(flags)) {
-  // Adds snake_case version of the flag.
-  flags[name.replace(/-/g, "_")] = flags[name];
-}
-
 (async () => {
+  /** @type {Awaited<ReturnType<typeof parseFlags>>} */
+  let parsed;
+  try {
+    parsed = await parseFlags(argv.slice(2), backends);
+  } catch (error) {
+    // As rclone: for example `Error: unknown flag: --nosuch`.
+    stderr.write(`Error: ${error.message}\n`);
+    process.exitCode = 1;
+    return;
+  }
+  const { flags, positionals: [subcommand = "help", ...positionals] } = parsed;
+
   let name = subcommand;
+  let args = positionals;
   if (!Object.hasOwn(FOLDERS, name)) {
     stderr.write(`Error: unknown command "${name}" for "rfetch"\n`);
     process.exitCode = 1;
-    name = "help";
+    [name, args] = ["help", []];
   }
+  // `rfetch COMMAND --help` shows the help.
+  if (flags.help) [name, args] = ["help", []];
   const module = await import(`./cmd/${FOLDERS[name]}/main.js`);
   /** TODO merge global flags into config */
   const response = await module[name](...args, flags);
diff --git a/main_test.js b/main_test.js
index 4942a5e..3f24afa 100644
--- a/main_test.js
+++ b/main_test.js
@@ -486,6 +486,48 @@ test("the command line", async (t) => {
       assert.match(stdout, /Available Commands:/);
     });
 
+    await t.test("reads the value of a flag after a space", async () => {
+      await mkdir(join(folder, "deep", "deeper"), { recursive: true });
+      await writeFile(join(folder, "deep", "deeper", "b.txt"), "b");
+      const { code, stdout } = await run(folder, [
+        "lsf",
+        "--max-depth",
+        "2",
+        "-R",
+        "--separator",
+        "|",
+        "--format",
+        "ps",
+        "deep",
+      ]);
+      assert.equal(code, 0);
+      assert.equal(stdout, "deeper/|-1\ndeeper/b.txt|1\n");
+    });
+
+    await t.test("gives the exit code 1 for an unknown flag, as rclone", async () => {
+      const { code, stdout, stderr } = await run(folder, [
+        "lsjson",
+        "--nosuch",
+        ".",
+      ]);
+      assert.equal(code, 1);
+      assert.equal(stdout, "");
+      assert.equal(stderr, "Error: unknown flag: --nosuch\n");
+    });
+
+    await t.test("lists one level with lsd, and . as a folder, as rclone", async () => {
+      await mkdir(join(folder, "deep", "deeper"), { recursive: true });
+      const lsd = await run(join(folder, "deep"), ["lsd", "."]);
+      assert.equal(lsd.code, 0);
+      assert.match(lsd.stdout, /\tdeeper\/\n$/);
+      assert.equal(lsd.stdout.split("\n").length, 2);
+      const lsjson = await run(join(folder, "deep"), ["lsjson", "."]);
+      assert.equal(lsjson.code, 0);
+      assert.deepEqual(JSON.parse(lsjson.stdout).map(({ Path }) => Path), [
+        "deeper",
+      ]);
+    });
+
     await t.test("stops with no error when the reader closes the pipe", async () => {
       await writeFile(
         join(folder, "big.bin"),

From 781d6e58e0ab892802c02b13f7f9d9fb3e50fd85 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sun, 18 Oct 2026 23:05:30 +0000
Subject: [PATCH 84/87] fix(lsjson): the time of a folder with no time, and the
 times of http, as rclone

rclone gives a folder with no time the time of the flag --default-time,
2000-01-01T00:00:00Z. lsjson of rfetch gave "", for example for the
folders of memory, http and s3. Now lsjson gives DEFAULT_TIME of
@rfetch/lib/time.

The precision of the http backend of rclone is 1 s: lsjson gives
2026-01-02T03:04:05Z. rfetch gave 2026-01-02T03:04:05.000Z. Now the http
backend writes its times to the second, and toLocaleISOString keeps the
digits of a time in a string from 0 to 9, not from 3 to 9: the digits
tell the precision of the remote. A Date still gives 3 digits.

Test: lsjson -R of rfetch and of rclone on the same http index, of
python3 -m http.server, give the same items. lsjson of a folder of
memory gives 2000-01-01T00:00:00Z.
---
 backend/http/main.js      | 17 +++++++++++++----
 backend/http/main_test.js |  3 ++-
 cmd/lsjson/main.js        |  5 +++--
 cmd/lsjson/main_test.js   |  7 +++++++
 lib/time.js               | 27 ++++++++++++++++++---------
 lib/time_test.js          | 17 ++++++++++++++---
 6 files changed, 57 insertions(+), 19 deletions(-)

diff --git a/backend/http/main.js b/backend/http/main.js
index c62cd19..cde8fff 100644
--- a/backend/http/main.js
+++ b/backend/http/main.js
@@ -241,6 +241,17 @@ async function getFolder(url, method, headers, noHead, query) {
   return new Response(renderListing(entries, { query }), { headers: result });
 }
 
+/**
+ * Writes a time to the second, as the http backend of rclone: its precision
+ * is 1 s, and the time of `Last-Modified` has no milliseconds.
+ * @param {number} time The milliseconds since 1970.
+ * @returns {string} For example `2026-10-17T10:00:00Z`.
+ */
+function toSecond(time) {
+  return new Date(Math.floor(time / 1000) * 1000).toISOString()
+    .replace(/\.\d+Z$/, "Z");
+}
+
 /**
  * Reads the files and the folders of an index page, as `parse` of the http
  * backend of rclone: each link to a child of the folder, one time. The rows
@@ -294,9 +305,7 @@ async function readIndex(response, base) {
     ["tr time[datetime]", {
       element(element) {
         const time = Date.parse(attributeOf(element, "datetime") ?? "");
-        if (current && !isNaN(time)) {
-          current.ModTime = new Date(time).toISOString();
-        }
+        if (current && !isNaN(time)) current.ModTime = toSecond(time);
       },
     }],
   ]);
@@ -333,7 +342,7 @@ async function head(entries, base, headers) {
       }
       entry.Size = isEncoded(response) ? -1 : sizeOf(response.headers);
       const time = Date.parse(response.headers.get("Last-Modified") ?? "");
-      if (!isNaN(time)) entry.ModTime = new Date(time).toISOString();
+      if (!isNaN(time)) entry.ModTime = toSecond(time);
       entry.MimeType = response.headers.get("Content-Type") ?? "";
     }
   };
diff --git a/backend/http/main_test.js b/backend/http/main_test.js
index 89f7ab4..122771e 100644
--- a/backend/http/main_test.js
+++ b/backend/http/main_test.js
@@ -193,7 +193,8 @@ describe("http with an index page that is not of rfetch", () => {
 
   test("lists each link to a child of the folder one time", async () => {
     const entries = await fs.list("");
-    const time = new Date(LAST_MODIFIED).toISOString();
+    // The time is to the second, as the precision of http in rclone.
+    const time = "2026-10-17T10:00:00Z";
     assert.deepEqual(
       entries.map(({ Name, IsDir, Size, ModTime }) => ({
         Name,
diff --git a/cmd/lsjson/main.js b/cmd/lsjson/main.js
index 4a3ea1f..dceb670 100644
--- a/cmd/lsjson/main.js
+++ b/cmd/lsjson/main.js
@@ -1,7 +1,7 @@
 import { parse } from "@rfetch/lib/fspath";
 import { readListing } from "@rfetch/lib/listing";
 import { isTrue } from "@rfetch/lib/options";
-import { toLocaleISOString } from "@rfetch/lib/time";
+import { DEFAULT_TIME, toLocaleISOString } from "@rfetch/lib/time";
 
 import { fetch } from "../../fetch.js";
 
@@ -211,7 +211,8 @@ function folderOf(entries, { location, depth, flags, init, filename }) {
       Name,
       Size,
       MimeType: IsDir ? "inode/directory" : MimeType,
-      ModTime: ModTime ? toLocaleISOString(ModTime) : "",
+      // A folder with no time has the default time of rclone.
+      ModTime: ModTime ? toLocaleISOString(ModTime) : IsDir ? DEFAULT_TIME : "",
       IsDir,
     });
     if (IsDir && depth > 1) {
diff --git a/cmd/lsjson/main_test.js b/cmd/lsjson/main_test.js
index 2a745a8..8f65c13 100644
--- a/cmd/lsjson/main_test.js
+++ b/cmd/lsjson/main_test.js
@@ -257,3 +257,10 @@ test("lsjson gives 404 for a path that is not found, as rclone", async () => {
     await response.body?.cancel();
   }
 });
+
+test("lsjson gives a folder with no time the default time of rclone", async () => {
+  const items = await lsjson(":memory:/A/").then((response) => response.json());
+  const folder = items.find(({ Name }) => Name === "D");
+  assert.equal(folder.IsDir, true);
+  assert.equal(folder.ModTime, "2000-01-01T00:00:00Z");
+});
diff --git a/lib/time.js b/lib/time.js
index d78f8a9..84a49c8 100644
--- a/lib/time.js
+++ b/lib/time.js
@@ -5,8 +5,9 @@
  * `+hh:mm` or `-hh:mm`.
  *
  * As rclone, the number of digits after the second tells the precision of
- * the remote: 9 for 1 ns, for example a local file, and 3 for 1 ms. A time
- * in a string keeps its digits, from 3 to 9. A Date or a number has 3.
+ * the remote: 9 for 1 ns, for example a local file, 3 for 1 ms, and none for
+ * 1 s, for example the http backend. A time in a string keeps its digits,
+ * from 0 to 9. A Date or a number has 3.
  * @param {string | number | Date | null | undefined} value
  * @param {number} [offset] The minutes after UTC of the time zone. By
  *   default, the offset of the local time zone at that time.
@@ -15,14 +16,14 @@
  */
 export function toLocaleISOString(value, offset) {
   if (value === null || value === undefined || value === "") return undefined;
-  /** The digits after the second, when there are more than 3. */
-  let digits = "";
+  /** The digits after the second of a string, or undefined for 3. */
+  let digits;
   if (typeof value === "string") {
-    const match = /^(.*T\d\d:\d\d:\d\d)\.(\d{4,})(Z|[+-]\d\d:\d\d)$/i
+    const match = /^(.*T\d\d:\d\d:\d\d)(?:\.(\d+))?(Z|[+-]\d\d:\d\d)$/i
       .exec(value);
     if (match) {
-      digits = match[2].slice(0, 9);
-      value = `${match[1]}.${digits.slice(0, 3)}${match[3]}`;
+      digits = (match[2] ?? "").slice(0, 9);
+      value = `${match[1]}.${digits.slice(0, 3).padEnd(3, "0")}${match[3]}`;
     }
   }
   const date = new Date(value);
@@ -31,8 +32,10 @@ export function toLocaleISOString(value, offset) {
   offset ??= -date.getTimezoneOffset();
   let local = new Date(date.getTime() + offset * 60000).toISOString()
     .slice(0, -1);
-  // The time zone does not change the digits after the millisecond.
-  if (digits) local = `${local.slice(0, -3)}${digits}`;
+  // The time zone does not change the digits after the second.
+  if (digits !== undefined) {
+    local = local.slice(0, -4) + (digits ? `.${digits}` : "");
+  }
   if (offset === 0) return `${local}Z`;
   const minutes = Math.abs(offset);
   const pad = (number) => String(number).padStart(2, "0");
@@ -40,3 +43,9 @@ export function toLocaleISOString(value, offset) {
     pad(minutes % 60)
   }`;
 }
+
+/**
+ * The time of a folder that has no time, as the default of the flag
+ * `--default-time` of rclone.
+ */
+export const DEFAULT_TIME = "2000-01-01T00:00:00Z";
diff --git a/lib/time_test.js b/lib/time_test.js
index 016811a..b0635da 100644
--- a/lib/time_test.js
+++ b/lib/time_test.js
@@ -17,9 +17,19 @@ test("toLocaleISOString writes the times of rclone lsjson", () => {
   ) {
     assert.equal(toLocaleISOString(time, offset), expected, `${offset}`);
   }
-  // The milliseconds stay, also when they are zero.
+  // A time to the second stays a time to the second, as the precision of the
+  // remote, for example http.
   assert.equal(
     toLocaleISOString("2026-10-17T03:56:05Z", 0),
+    "2026-10-17T03:56:05Z",
+  );
+  assert.equal(
+    toLocaleISOString("2026-10-17T03:56:05Z", 90),
+    "2026-10-17T05:26:05+01:30",
+  );
+  // The milliseconds of a Date stay, also when they are zero.
+  assert.equal(
+    toLocaleISOString(new Date("2026-10-17T03:56:05Z"), 0),
     "2026-10-17T03:56:05.000Z",
   );
   for (const value of [null, undefined, "", "not a time"]) {
@@ -27,7 +37,7 @@ test("toLocaleISOString writes the times of rclone lsjson", () => {
   }
 });
 
-test("toLocaleISOString keeps the digits of the time, from 3 to 9", () => {
+test("toLocaleISOString keeps the digits of the time, from 0 to 9", () => {
   for (
     const [time, offset, expected] of [
       ["2026-10-18T15:02:41.540476887Z", 0, "2026-10-18T15:02:41.540476887Z"],
@@ -43,7 +53,8 @@ test("toLocaleISOString keeps the digits of the time, from 3 to 9", () => {
       ],
       ["2026-10-18T15:02:41.540476Z", 0, "2026-10-18T15:02:41.540476Z"],
       ["2026-10-18T15:02:41.1234567891Z", 0, "2026-10-18T15:02:41.123456789Z"],
-      ["2026-10-18T15:02:41.5Z", 0, "2026-10-18T15:02:41.500Z"],
+      ["2026-10-18T15:02:41.5Z", 0, "2026-10-18T15:02:41.5Z"],
+      ["2026-10-18T15:02:41.540Z", 0, "2026-10-18T15:02:41.540Z"],
     ]
   ) {
     assert.equal(toLocaleISOString(time, offset), expected, time);

From c58f0f2a14b34bd47bd9dfe8e746f38fb7d37539 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sun, 18 Oct 2026 23:06:07 +0000
Subject: [PATCH 85/87] fix(lists): ls, lsl, lsd and lsf write the lines of
 rclone

The lists of text of rfetch had tabs and ISO times. Now each line is the
line of rclone 1.75:
- ls: the size on the right of 9 characters, then the path.
- lsl: the size, the local time 2006-01-02 15:04:05.000000000, then the
  path.
- lsd: the size on the right of 12 characters, the local time to the
  second, the count of items on the right of 9 characters, then the path
  with no / at the end. A folder has -1 for the size and the count. rclone
  gives the size of a local folder on the disk, for example 4096: rfetch
  gives -1, as the other backends.
- --human-readable: the size with a suffix of 1024, for example
  120.562Ki, and the count with a suffix of 1000, in fields of 9 and 8
  characters. The rounding is the rounding of %.3f of Go: a half goes to
  the even digit.
- lsf: the letter t gives the local time 2006-01-02 15:04:05. With --csv,
  the separator is , when the flag does not tell it, and a value with the
  separator, a quote, a line break or a space at the start is in quotes,
  as csv.Writer of Go.

The new listLines of cmd/lsf/main.js reads the items of lsjson, and each
command gives the line of an item. toListTime of @rfetch/lib/time writes
the times, and sizeString, countString, sizeField and countField of
@rfetch/lib/format write the sizes and the counts, as SizeString and
SizeStringField of rclone.

Tests: cmd/lsf/rclone_test.js compares the lines of ls, lsl, lsd and lsf
with the lines of rclone on the same local files, with names that CSV
puts in quotes. It passes with TZ UTC, America/New_York and
Asia/Kathmandu. The tests of each command check the lines on memory, and
lib/format_test.js checks the texts of SizeSuffix and CountSuffix of Go.
---
 CONTRIBUTING.md        |   7 +++
 cmd/ls/main.js         |  23 ++++---
 cmd/ls/main_test.js    |  23 ++++++-
 cmd/lsd/main.js        |  23 ++++---
 cmd/lsd/main_test.js   |  27 +++++++-
 cmd/lsf/main.js        |  98 +++++++++++++++++------------
 cmd/lsf/main_test.js   |  53 +++++++++++++++-
 cmd/lsf/rclone_test.js | 138 +++++++++++++++++++++++++++++++++++++++++
 cmd/lsl/main.js        |  26 +++++---
 cmd/lsl/main_test.js   |  16 ++++-
 lib/format.js          |  91 ++++++++++++++++++++++++++-
 lib/format_test.js     |  55 +++++++++++++++-
 lib/time.js            |  16 +++++
 lib/time_test.js       |  19 +++++-
 main_test.js           |   2 +-
 15 files changed, 538 insertions(+), 79 deletions(-)
 create mode 100644 cmd/lsf/rclone_test.js

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 461ac22..affcc26 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -252,6 +252,13 @@ backend goes in its `options`. An unknown flag is an error, as in rclone. A
 command reads a boolean flag with `isTrue` of `@rfetch/lib/options`: the flag
 can be `true` or the text `true` of a query.
 
+The lists of text, `ls`, `lsl`, `lsd` and `lsf`, read the items of `lsjson` with
+`listLines` of `cmd/lsf/main.js`, and write each line as rclone writes it: the
+time with `toListTime` of `@rfetch/lib/time`, in the local time zone, and the
+size and the count with `sizeField` and `countField` of `@rfetch/lib/format`, in
+fields of the widths of rclone. `cmd/lsf/rclone_test.js` compares the lines with
+the lines of rclone.
+
 ## Tests of a backend
 
 Each backend must pass the shared tests of `@rfetch/lib/testing/suite`. These
diff --git a/cmd/ls/main.js b/cmd/ls/main.js
index 7ed74d4..456fc59 100644
--- a/cmd/ls/main.js
+++ b/cmd/ls/main.js
@@ -1,4 +1,6 @@
-import { lsf } from "../lsf/main.js";
+import { sizeField } from "@rfetch/lib/format";
+import { isTrue } from "@rfetch/lib/options";
+import { listLines } from "../lsf/main.js";
 /**
  * List the objects in the path with size and path.
  *
@@ -23,13 +25,14 @@ import { lsf } from "../lsf/main.js";
  * @returns {Promise<Response>}
  */
 export function ls(location, flags = {}) {
-  flags = {
-    recursive: true,
-    max_depth: "Infinity",
-    files_only: true,
-    format: "sp",
-    separator: "\t",
-    ...flags,
-  };
-  return lsf(location, flags);
+  const human = isTrue(flags.human_readable);
+  // As `rclone ls`: the size in 9 characters, then the path.
+  return listLines(
+    location,
+    { recursive: true, max_depth: "Infinity", ...flags },
+    (item) => {
+      if (item.IsDir) return;
+      return `${sizeField(item.Size, human, 9)} ${item.Path}`;
+    },
+  );
 }
diff --git a/cmd/ls/main_test.js b/cmd/ls/main_test.js
index 7effdd4..00f5263 100644
--- a/cmd/ls/main_test.js
+++ b/cmd/ls/main_test.js
@@ -1,7 +1,26 @@
 import { test } from "node:test";
 import assert from "node:assert/strict";
+
+import { fetch } from "../../fetch.js";
 import { ls } from "./main.js";
 
-test("ls", () => {
-  assert(ls);
+await fetch(":memory:/ls/a.txt", { method: "PUT", body: "hello" });
+await fetch(":memory:/ls/sub/b.bin", {
+  method: "PUT",
+  body: new Uint8Array(123456),
+});
+
+test("ls gives the size in 9 characters and the path of each file, as rclone", async () => {
+  const text = await (await ls(":memory:/ls/")).text();
+  assert.equal(text, "        5 a.txt\n   123456 sub/b.bin\n");
+});
+
+test("ls --human-readable gives the size with a suffix of rclone", async () => {
+  const response = await ls(":memory:/ls/", { human_readable: true });
+  assert.equal(await response.text(), "        5 a.txt\n120.562Ki sub/b.bin\n");
+});
+
+test("ls --max-depth 1 lists only the files of the folder", async () => {
+  const response = await ls(":memory:/ls/", { max_depth: "1" });
+  assert.equal(await response.text(), "        5 a.txt\n");
 });
diff --git a/cmd/lsd/main.js b/cmd/lsd/main.js
index a65261d..b85dc78 100644
--- a/cmd/lsd/main.js
+++ b/cmd/lsd/main.js
@@ -1,4 +1,7 @@
-import { lsf } from "../lsf/main.js";
+import { countField, sizeField } from "@rfetch/lib/format";
+import { isTrue } from "@rfetch/lib/options";
+import { toListTime } from "@rfetch/lib/time";
+import { listLines } from "../lsf/main.js";
 /**
  * List all directories/containers/buckets in the path.
  *
@@ -11,12 +14,14 @@ import { lsf } from "../lsf/main.js";
  * @returns {Promise<Response>}
  */
 export function lsd(location, flags = {}) {
-  flags = {
-    dirs_only: true,
-    format: "stp",
-    recursive: false,
-    separator: "\t",
-    ...flags,
-  };
-  return lsf(location, flags);
+  const human = isTrue(flags.human_readable);
+  // As `rclone lsd`: the size in 12 characters, the local time to the
+  // second, the count of items in 9 characters, then the path. A folder has
+  // no size and no count: -1 for both.
+  return listLines(location, { recursive: false, ...flags }, (item) => {
+    if (!item.IsDir) return;
+    const time = toListTime(item.ModTime).padStart(13);
+    const count = countField(-1, human, 9);
+    return `${sizeField(item.Size, human, 12)} ${time} ${count} ${item.Path}`;
+  });
 }
diff --git a/cmd/lsd/main_test.js b/cmd/lsd/main_test.js
index 7cb45d4..ad87040 100644
--- a/cmd/lsd/main_test.js
+++ b/cmd/lsd/main_test.js
@@ -1,7 +1,30 @@
 import { test } from "node:test";
 import assert from "node:assert/strict";
+
+import { DEFAULT_TIME, toListTime } from "@rfetch/lib/time";
+import { fetch } from "../../fetch.js";
 import { lsd } from "./main.js";
 
-test("lsd", () => {
-  assert(lsd);
+await fetch(":memory:/lsd/a.txt", { method: "PUT", body: "a" });
+await fetch(":memory:/lsd/sub/deep/b.txt", { method: "PUT", body: "b" });
+
+// A folder of memory has no time: it has the default time of rclone.
+const time = toListTime(DEFAULT_TIME);
+
+test("lsd gives the folders of one level, as rclone", async () => {
+  const text = await (await lsd(":memory:/lsd/")).text();
+  assert.equal(text, `          -1 ${time}        -1 sub\n`);
+});
+
+test("lsd --recursive gives the folders of each level", async () => {
+  const response = await lsd(":memory:/lsd/", { recursive: true });
+  assert.equal(
+    await response.text(),
+    `          -1 ${time}        -1 sub\n          -1 ${time}        -1 sub/deep\n`,
+  );
+});
+
+test("lsd --human-readable gives fields of 9 and 8 characters", async () => {
+  const response = await lsd(":memory:/lsd/", { human_readable: true });
+  assert.equal(await response.text(), `       -1 ${time}       -1 sub\n`);
 });
diff --git a/cmd/lsf/main.js b/cmd/lsf/main.js
index 6a8ee6b..dce7c84 100644
--- a/cmd/lsf/main.js
+++ b/cmd/lsf/main.js
@@ -1,4 +1,5 @@
 import { isTrue } from "@rfetch/lib/options";
+import { toListTime } from "@rfetch/lib/time";
 import { lsjson } from "../lsjson/main.js";
 
 const FORMATS = {
@@ -115,61 +116,82 @@ const FORMATS = {
  * @param {string} [flags.separator=";"] - Separator for the listing.
  * @returns {Promise<Response>}
  */
-export async function lsf(location, flags = {}) {
-  const { format = "p", separator = ";" } = flags;
+export function lsf(location, flags = {}) {
+  const format = flags.format ?? "p";
   const csv = isTrue(flags.csv);
+  // As rclone, the separator of CSV is "," when the flag does not tell it.
+  const separator = flags.separator ?? (csv ? "," : ";");
   const dirSlash = flags.dir_slash === undefined || isTrue(flags.dir_slash);
   const dirsOnly = isTrue(flags.dirs_only);
   const filesOnly = isTrue(flags.files_only);
+  // CSV has a separator of one character.
+  const comma = [...separator][0] ?? ",";
 
-  const response = await lsjson(location, flags);
-  let { ok, headers, body } = response;
+  return listLines(location, flags, (item) => {
+    if (dirsOnly && !item.IsDir) return;
+    if (filesOnly && item.IsDir) return;
+    const values = [...format].map((letter) => {
+      if (letter === "p") {
+        return item.IsDir && dirSlash ? `${item.Path}/` : item.Path;
+      }
+      if (letter === "t") return toListTime(item.ModTime);
+      const value = item[FORMATS[letter]] ?? "";
+      return typeof value === "object" ? JSON.stringify(value) : `${value}`;
+    });
+    if (!csv) return values.join(separator);
+    return values.map((value) => quoted(value, comma)).join(comma);
+  });
+}
 
-  if (!ok) {
-    return response;
-  }
+/**
+ * Puts a value of CSV in quotes when it must have them, as `csv.Writer` of
+ * Go: when it has the comma, a quote, a line break, or a space at the
+ * start. A quote in the value becomes two quotes.
+ * @param {string} value
+ * @param {string} comma
+ * @returns {string}
+ */
+function quoted(value, comma) {
+  const needs = value === "\\." || value.includes(comma) ||
+    /["\r\n]/.test(value) || SPACE.test(value);
+  return needs ? `"${value.replaceAll('"', '""')}"` : value;
+}
+
+/** A space at the start of a text, as `unicode.IsSpace` of Go. */
+const SPACE =
+  /^[\t\n\v\f\r \u0085\u00a0\u1680\u2000-\u200a\u2028\u2029\u202f\u205f\u3000]/;
+
+/**
+ * Lists a path as `lsjson`, with a line for each item, for the lists of
+ * text: `lsf`, `ls`, `lsl` and `lsd`.
+ * @param {string} location
+ * @param {Object} flags The flags of `lsjson`, for example `recursive`.
+ * @param {(item: import("../../mod.js").File) => string | undefined} line
+ *   Gives the line of an item, with no line break, or no line.
+ * @returns {Promise<Response>}
+ */
+export async function listLines(location, flags, line) {
+  const response = await lsjson(location, flags);
+  if (!response.ok) return response;
 
-  headers = new Headers(response.headers);
+  const headers = new Headers(response.headers);
   headers.set("Content-Type", "text/plain");
 
-  body = body
+  const body = response.body
     .pipeThrough(new TextDecoderStream())
     .pipeThrough(
       new TransformStream({
         transform(chunk, controller) {
-          // `lsjson returns each item on a new line, and except the
-          // last line, all lines ends with a comma. We strip that
-          // trailing comma and any new lines.
+          // `lsjson` gives each item on a line, with a comma at the end of
+          // each line but the last.
           chunk = chunk.trim().replace(/,$/, "");
-
-          if (chunk.startsWith("{") && chunk.at(-1) === "}") {
-            /**
-             * @type {import("../../mod.js").File}
-             */
-            const item = JSON.parse(chunk);
-            if (dirsOnly && !item.IsDir) return;
-            if (filesOnly && item.IsDir) return;
-
-            if (item.IsDir && dirSlash) {
-              item.Path += "/";
-            }
-
-            chunk = [...format].map((f) => {
-              let value = item[FORMATS[f]];
-              if (csv && typeof value === "string" && value.includes(",")) {
-                value = `"${value}"`;
-              }
-              return value;
-            }).join(separator);
-
-            controller.enqueue(`${chunk}\n`);
-          }
+          if (!chunk.startsWith("{") || chunk.at(-1) !== "}") return;
+          const text = line(JSON.parse(chunk));
+          if (text !== undefined) controller.enqueue(`${text}\n`);
         },
       }),
     )
     .pipeThrough(new TextEncoderStream());
 
-  return new Response(body, {
-    headers,
-  });
+  return new Response(body, { headers });
 }
diff --git a/cmd/lsf/main_test.js b/cmd/lsf/main_test.js
index cd9a63d..d4b14c7 100644
--- a/cmd/lsf/main_test.js
+++ b/cmd/lsf/main_test.js
@@ -1,7 +1,56 @@
 import { test } from "node:test";
 import assert from "node:assert/strict";
+
+import { DEFAULT_TIME, toListTime } from "@rfetch/lib/time";
+import { fetch } from "../../fetch.js";
 import { lsf } from "./main.js";
 
-test("lsf", () => {
-  assert(lsf);
+for (const name of ["a,b.txt", 'q"t.txt', " space.txt", "plain.txt"]) {
+  await fetch(`:memory:/lsf/${encodeURIComponent(name)}`, {
+    method: "PUT",
+    body: "x",
+  });
+}
+await fetch(":memory:/lsf/sub/c.txt", { method: "PUT", body: "x" });
+
+/** The lines of lsf, in order. */
+async function lines(flags) {
+  const text = await (await lsf(":memory:/lsf/", flags)).text();
+  return text.split("\n").slice(0, -1).sort();
+}
+
+test("lsf gives the paths, with a / at the end of a folder", async () => {
+  assert.deepEqual(await lines(), [
+    " space.txt",
+    "a,b.txt",
+    "plain.txt",
+    'q"t.txt',
+    "sub/",
+  ]);
+  assert.deepEqual(await lines({ dir_slash: false, dirs_only: true }), [
+    "sub",
+  ]);
+});
+
+test("lsf --csv uses , and the quotes of CSV, as rclone", async () => {
+  assert.deepEqual(
+    await lines({ csv: true, format: "ps", files_only: true }),
+    [
+      '" space.txt",1',
+      '"a,b.txt",1',
+      "plain.txt,1",
+      '"q""t.txt",1',
+    ].sort(),
+  );
+  // With a separator, CSV uses it, and puts in quotes a value that has it.
+  assert.deepEqual(
+    await lines({ csv: true, format: "sp", separator: ";", files_only: true }),
+    ['1;" space.txt"', "1;a,b.txt", "1;plain.txt", '1;"q""t.txt"'].sort(),
+  );
+});
+
+test("lsf --format t gives the local time to the second, as rclone", async () => {
+  const [line] = await lines({ format: "tp", separator: "|", dirs_only: true });
+  assert.equal(line, `${toListTime(DEFAULT_TIME)}|sub/`);
+  assert.match(line, /^\d{4}-\d\d-\d\d \d\d:\d\d:\d\d\|sub\/$/);
 });
diff --git a/cmd/lsf/rclone_test.js b/cmd/lsf/rclone_test.js
new file mode 100644
index 0000000..7b74195
--- /dev/null
+++ b/cmd/lsf/rclone_test.js
@@ -0,0 +1,138 @@
+/**
+ * The tests of the lists of text against the lists of rclone, on the same
+ * local folder: ls, lsl, lsd and lsf. The tests run when rclone is in the
+ * PATH, or when RCLONE is the path of rclone.
+ */
+import { after, before, describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import process from "node:process";
+
+import { ls } from "../ls/main.js";
+import { lsd } from "../lsd/main.js";
+import { lsl } from "../lsl/main.js";
+import { lsf } from "./main.js";
+
+const RCLONE = process.env.RCLONE || "rclone";
+const hasRclone = spawnSync(RCLONE, ["version"]).status === 0;
+
+/** The files, with names that CSV puts in quotes, and their sizes. */
+const FILES = {
+  "a,b.txt": 1,
+  'q"t.txt': 1024,
+  " space.txt": 1536,
+  "semi;colon/big.bin": 123456,
+  "n o/ê é/Hello, 世界.bin": 5,
+};
+
+describe("the lists of text and the lists of rclone", {
+  skip: !hasRclone && "rclone is not installed. Set RCLONE to its path.",
+}, () => {
+  const folder = mkdtempSync(join(tmpdir(), "rfetch-lsf-"));
+  const cwd = process.cwd();
+
+  before(() => {
+    for (const [path, size] of Object.entries(FILES)) {
+      mkdirSync(dirname(join(folder, "tree", path)), { recursive: true });
+      writeFileSync(join(folder, "tree", path), new Uint8Array(size));
+    }
+    // The local backend serves the current folder.
+    process.chdir(folder);
+  });
+  after(() => {
+    process.chdir(cwd);
+    rmSync(folder, { recursive: true, force: true });
+  });
+
+  /**
+   * The lines of rclone, in order: rclone lists the folders at the same
+   * time, thus its order can change.
+   * @param {string[]} args
+   */
+  function rclone(args) {
+    const { status, stdout, stderr } = spawnSync(RCLONE, args, {
+      cwd: folder,
+      env: {
+        PATH: process.env.PATH,
+        HOME: folder,
+        // The same time zone as the test.
+        ...process.env.TZ ? { TZ: process.env.TZ } : {},
+      },
+    });
+    assert.equal(status, 0, `${stderr}`);
+    return `${stdout}`.split("\n").slice(0, -1).sort();
+  }
+
+  /** @param {Promise<Response>} response */
+  async function lines(response) {
+    const text = await (await response).text();
+    return text.split("\n").slice(0, -1).sort();
+  }
+
+  test("ls", async () => {
+    assert.deepEqual(await lines(ls("tree/")), rclone(["ls", "tree"]));
+    assert.deepEqual(
+      await lines(ls("tree/", { human_readable: true })),
+      rclone(["ls", "--human-readable", "tree"]),
+    );
+  });
+
+  test("lsl", async () => {
+    assert.deepEqual(await lines(lsl("tree/")), rclone(["lsl", "tree"]));
+  });
+
+  test("lsd", async () => {
+    // rclone gives the size of a local folder on the disk, and rfetch -1,
+    // as the other backends: the lines are the same after the size.
+    const cut = (list, width) => list.map((line) => line.slice(width)).sort();
+    assert.deepEqual(
+      cut(await lines(lsd("tree/", { recursive: true })), 12),
+      cut(rclone(["lsd", "-R", "tree"]), 12),
+    );
+    assert.deepEqual(
+      cut(await lines(lsd("tree/", { human_readable: true })), 9),
+      cut(rclone(["lsd", "--human-readable", "tree"]), 9),
+    );
+  });
+
+  test("lsf", async () => {
+    for (
+      const [flags, args] of [
+        [{ recursive: true }, ["-R"]],
+        [{ recursive: true, format: "pst", files_only: true }, [
+          "-R",
+          "--format",
+          "pst",
+          "--files-only",
+        ]],
+        [{ recursive: true, csv: true, format: "ps", files_only: true }, [
+          "-R",
+          "--csv",
+          "--format",
+          "ps",
+          "--files-only",
+        ]],
+        [{ csv: true, separator: ";", format: "sp" }, [
+          "--csv",
+          "--separator",
+          ";",
+          "--format",
+          "sp",
+        ]],
+        [{ dirs_only: true, dir_slash: false }, [
+          "--dirs-only",
+          "--dir-slash=false",
+        ]],
+      ]
+    ) {
+      assert.deepEqual(
+        await lines(lsf("tree/", flags)),
+        rclone(["lsf", ...args, "tree"]),
+        args.join(" "),
+      );
+    }
+  });
+});
diff --git a/cmd/lsl/main.js b/cmd/lsl/main.js
index ef858ee..d2b4317 100644
--- a/cmd/lsl/main.js
+++ b/cmd/lsl/main.js
@@ -1,4 +1,7 @@
-import { lsf } from "../lsf/main.js";
+import { sizeField } from "@rfetch/lib/format";
+import { isTrue } from "@rfetch/lib/options";
+import { toListTime } from "@rfetch/lib/time";
+import { listLines } from "../lsf/main.js";
 
 /**
  * List the objects in path with modification time, size and path.
@@ -24,13 +27,16 @@ import { lsf } from "../lsf/main.js";
  * @returns {Promise<Response>}
  */
 export function lsl(location, flags = {}) {
-  flags = {
-    recursive: true,
-    max_depth: "Infinity",
-    files_only: true,
-    format: "stp",
-    separator: "\t",
-    ...flags,
-  };
-  return lsf(location, flags);
+  const human = isTrue(flags.human_readable);
+  // As `rclone lsl`: the size in 9 characters, the local time to the
+  // nanosecond, then the path.
+  return listLines(
+    location,
+    { recursive: true, max_depth: "Infinity", ...flags },
+    (item) => {
+      if (item.IsDir) return;
+      const time = toListTime(item.ModTime, 9);
+      return `${sizeField(item.Size, human, 9)} ${time} ${item.Path}`;
+    },
+  );
 }
diff --git a/cmd/lsl/main_test.js b/cmd/lsl/main_test.js
index f619fda..4f5ab09 100644
--- a/cmd/lsl/main_test.js
+++ b/cmd/lsl/main_test.js
@@ -1,7 +1,19 @@
 import { test } from "node:test";
 import assert from "node:assert/strict";
+
+import { toListTime } from "@rfetch/lib/time";
+import { fetch } from "../../fetch.js";
+import { lsjson } from "../lsjson/main.js";
 import { lsl } from "./main.js";
 
-test("lsl", () => {
-  assert(lsl);
+await fetch(":memory:/lsl/a.txt", { method: "PUT", body: "hello" });
+
+test("lsl gives the size, the local time to the nanosecond and the path, as rclone", async () => {
+  const [{ ModTime }] = await (await lsjson(":memory:/lsl/")).json();
+  const text = await (await lsl(":memory:/lsl/")).text();
+  assert.equal(text, `        5 ${toListTime(ModTime, 9)} a.txt\n`);
+  assert.match(
+    text,
+    /^ {8}5 \d{4}-\d\d-\d\d \d\d:\d\d:\d\d\.\d{9} a\.txt\n$/,
+  );
 });
diff --git a/lib/format.js b/lib/format.js
index c271030..2ef7fb3 100644
--- a/lib/format.js
+++ b/lib/format.js
@@ -1,5 +1,6 @@
 /**
- * Formats of numbers for people: a size in bytes and a duration.
+ * Formats of numbers for people: a size in bytes and a duration, and the
+ * sizes and the counts of the lists of rclone.
  *
  * They give the same text as `format` of `@std/fmt/bytes` and of
  * `@std/fmt/duration` for the options that rfetch uses, but with `KiB` in
@@ -95,3 +96,91 @@ export function formatDuration(milliseconds) {
   )
     .join(" ");
 }
+
+/** The suffixes of the sizes of rclone: powers of 1024. */
+const SIZE_SUFFIXES = ["", "Ki", "Mi", "Gi", "Ti", "Pi", "Ei"];
+
+/** The suffixes of the counts of rclone: powers of 1000. */
+const COUNT_SUFFIXES = ["", "k", "M", "G", "T", "P", "E"];
+
+/**
+ * Writes a number that is 0 or more with the suffix of a power of `base`, as
+ * `SizeSuffix` and `CountSuffix` of rclone: with no digit after the point
+ * when the number is whole, else with 3 digits. The rounding is the rounding
+ * of `%.3f` of Go: to the nearest, and to the even digit for a half.
+ * @param {number} value
+ * @param {number} base
+ * @param {string[]} suffixes
+ * @returns {string}
+ */
+function suffixed(value, base, suffixes) {
+  const number = BigInt(value);
+  const step = BigInt(base);
+  let divisor = 1n;
+  let exponent = 0;
+  while (exponent < suffixes.length - 1 && number >= divisor * step) {
+    divisor *= step;
+    exponent++;
+  }
+  const suffix = suffixes[exponent];
+  if (number % divisor === 0n) return `${number / divisor}${suffix}`;
+  let thousandths = number * 1000n / divisor;
+  const rest = number * 1000n % divisor * 2n;
+  if (rest > divisor || (rest === divisor && thousandths % 2n === 1n)) {
+    thousandths++;
+  }
+  const fraction = `${thousandths % 1000n}`.padStart(3, "0");
+  return `${thousandths / 1000n}.${fraction}${suffix}`;
+}
+
+/**
+ * Writes a size in bytes as the lists of rclone: the number, or with
+ * `humanReadable` the number with a suffix of a power of 1024, for example
+ * `120.562Ki`, as the flag `--human-readable` of rclone.
+ * @param {number} size A whole number of bytes, or -1 for no size.
+ * @param {boolean} [humanReadable]
+ * @returns {string}
+ */
+export function sizeString(size, humanReadable = false) {
+  if (!humanReadable) return `${size}`;
+  if (size < 0) return `-${suffixed(-size, 1024, SIZE_SUFFIXES)}`;
+  return suffixed(size, 1024, SIZE_SUFFIXES);
+}
+
+/**
+ * Writes a count of items as the lists of rclone: the number, or with
+ * `humanReadable` the number with a suffix of a power of 1000, for example
+ * `1.235M`.
+ * @param {number} count A whole number, or -1 for no count.
+ * @param {boolean} [humanReadable]
+ * @returns {string}
+ */
+export function countString(count, humanReadable = false) {
+  if (!humanReadable) return `${count}`;
+  if (count < 0) return `-${suffixed(-count, 1000, COUNT_SUFFIXES)}`;
+  return suffixed(count, 1000, COUNT_SUFFIXES);
+}
+
+/**
+ * Writes a size in a field of fixed width, as `SizeStringField` of rclone:
+ * on the right of `width` characters, or of 9 with `humanReadable`.
+ * @param {number} size
+ * @param {boolean} humanReadable
+ * @param {number} width
+ * @returns {string}
+ */
+export function sizeField(size, humanReadable, width) {
+  return sizeString(size, humanReadable).padStart(humanReadable ? 9 : width);
+}
+
+/**
+ * Writes a count in a field of fixed width, as `CountStringField` of rclone:
+ * on the right of `width` characters, or of 8 with `humanReadable`.
+ * @param {number} count
+ * @param {boolean} humanReadable
+ * @param {number} width
+ * @returns {string}
+ */
+export function countField(count, humanReadable, width) {
+  return countString(count, humanReadable).padStart(humanReadable ? 8 : width);
+}
diff --git a/lib/format_test.js b/lib/format_test.js
index 7dd5d78..c94eaf4 100644
--- a/lib/format_test.js
+++ b/lib/format_test.js
@@ -1,7 +1,12 @@
 import { test } from "node:test";
 import assert from "node:assert/strict";
 
-import { formatBytes, formatDuration } from "./format.js";
+import {
+  countString,
+  formatBytes,
+  formatDuration,
+  sizeString,
+} from "./format.js";
 
 // The texts of `format` of @std/fmt 0.225, which these functions replace.
 test("formatBytes", () => {
@@ -32,3 +37,51 @@ test("formatDuration", () => {
   assert.equal(formatDuration(0.000001), "1ns");
   assert.equal(formatDuration(-3600000), "1h");
 });
+
+test("sizeString writes the sizes of rclone", () => {
+  // The texts of SizeSuffix of rclone, from Go.
+  for (
+    const [size, text] of [
+      [0, "0"],
+      [1, "1"],
+      [1023, "1023"],
+      [1024, "1Ki"],
+      [1025, "1.001Ki"],
+      [1536, "1.500Ki"],
+      // 120.5625: Go rounds a half to the even digit.
+      [123456, "120.562Ki"],
+      [1408, "1.375Ki"],
+      [1048575, "1023.999Ki"],
+      [1048576, "1Mi"],
+      [5242881, "5.000Mi"],
+      [67108864, "64Mi"],
+      [1099511627776, "1Ti"],
+      [1125899906842624, "1Pi"],
+      [9007199254740991, "8.000Pi"],
+    ]
+  ) {
+    assert.equal(sizeString(size, true), text, `${size}`);
+    assert.equal(sizeString(size), `${size}`);
+  }
+  assert.equal(sizeString(-1, true), "-1");
+  assert.equal(sizeString(-1), "-1");
+});
+
+test("countString writes the counts of rclone", () => {
+  for (
+    const [count, text] of [
+      [0, "0"],
+      [999, "999"],
+      [1000, "1k"],
+      [1001, "1.001k"],
+      [1500, "1.500k"],
+      [999999, "999.999k"],
+      [1234567, "1.235M"],
+      [1000000, "1M"],
+    ]
+  ) {
+    assert.equal(countString(count, true), text, `${count}`);
+  }
+  assert.equal(countString(-1, true), "-1");
+  assert.equal(countString(-1), "-1");
+});
diff --git a/lib/time.js b/lib/time.js
index 84a49c8..4a1d5de 100644
--- a/lib/time.js
+++ b/lib/time.js
@@ -49,3 +49,19 @@ export function toLocaleISOString(value, offset) {
  * `--default-time` of rclone.
  */
 export const DEFAULT_TIME = "2000-01-01T00:00:00Z";
+
+/**
+ * Writes a time as the lists of rclone, in the local time zone: the format
+ * `2006-01-02 15:04:05` of Go, for example for `rclone lsd` and `rclone lsf`,
+ * with `digits` digits after the second, for example 9 for `rclone lsl`.
+ * @param {string | number | Date | null | undefined} value
+ * @param {number} [digits]
+ * @returns {string} For no time, the zero time of Go, as rclone.
+ */
+export function toListTime(value, digits = 0) {
+  const iso = toLocaleISOString(value) ?? "0001-01-01T00:00:00Z";
+  const [, day, time, fraction = ""] =
+    /^(.+)T(\d\d:\d\d:\d\d)(?:\.(\d+))?/.exec(iso) ?? [];
+  if (!digits) return `${day} ${time}`;
+  return `${day} ${time}.${fraction.padEnd(digits, "0").slice(0, digits)}`;
+}
diff --git a/lib/time_test.js b/lib/time_test.js
index b0635da..db50af7 100644
--- a/lib/time_test.js
+++ b/lib/time_test.js
@@ -1,7 +1,7 @@
 import { test } from "node:test";
 import assert from "node:assert/strict";
 
-import { toLocaleISOString } from "./time.js";
+import { toListTime, toLocaleISOString } from "./time.js";
 
 test("toLocaleISOString writes the times of rclone lsjson", () => {
   const time = "2026-10-17T03:56:05.819Z";
@@ -60,3 +60,20 @@ test("toLocaleISOString keeps the digits of the time, from 0 to 9", () => {
     assert.equal(toLocaleISOString(time, offset), expected, time);
   }
 });
+
+test("toListTime writes the times of the lists of rclone", () => {
+  const offset = new Date("2026-10-18T15:02:41Z").getTimezoneOffset();
+  // The local time zone of the tests is not known: the test makes the
+  // expected time in it.
+  const local = new Date(Date.parse("2026-10-18T15:02:41Z") - offset * 60000)
+    .toISOString().slice(0, 19).replace("T", " ");
+  assert.equal(toListTime("2026-10-18T15:02:41.540476887Z"), local);
+  assert.equal(
+    toListTime("2026-10-18T15:02:41.540476887Z", 9),
+    `${local}.540476887`,
+  );
+  assert.equal(toListTime("2026-10-18T15:02:41.5Z", 9), `${local}.500000000`);
+  assert.equal(toListTime("2026-10-18T15:02:41Z", 9), `${local}.000000000`);
+  assert.equal(toListTime(""), "0001-01-01 00:00:00");
+  assert.equal(toListTime(undefined, 9), "0001-01-01 00:00:00.000000000");
+});
diff --git a/main_test.js b/main_test.js
index 3f24afa..51186ef 100644
--- a/main_test.js
+++ b/main_test.js
@@ -519,7 +519,7 @@ test("the command line", async (t) => {
       await mkdir(join(folder, "deep", "deeper"), { recursive: true });
       const lsd = await run(join(folder, "deep"), ["lsd", "."]);
       assert.equal(lsd.code, 0);
-      assert.match(lsd.stdout, /\tdeeper\/\n$/);
+      assert.match(lsd.stdout, /^ {10}-1 \S+ \S+ {8}-1 deeper\n$/);
       assert.equal(lsd.stdout.split("\n").length, 2);
       const lsjson = await run(join(folder, "deep"), ["lsjson", "."]);
       assert.equal(lsjson.code, 0);

From 4a82b02c2dd2fd50ce68409b9f46c9fa7e27eeda Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sun, 18 Oct 2026 23:12:16 +0000
Subject: [PATCH 86/87] refactor(lists): a LineStream in place of listLines

listLines read the body of lsjson with a TransformStream on chunks, not
on lines. It worked only because lsjson gives each line in its own chunk.
When the body comes in other chunks, for example from the Worker on the
network, the list was empty and there was no error.

The new LineStream of cmd/lsjson/main.js is a TransformStream from bytes
to bytes. It keeps only the part of a line that has no "\n" yet, as the
ParseStream of @rfetch/lib/ini, and gives the line of each item. A line
that is not an item is an error of the stream. ls, lsl, lsd and lsf send
the body of lsjson through it, thus any body of lsjson can go through it.

Tests: LineStream reads a body in one chunk, in a chunk for each byte, and
in chunks of 7 bytes, and gives an error for a broken line.
---
 CONTRIBUTING.md         | 13 +++++-----
 cmd/ls/main.js          | 25 ++++++++++--------
 cmd/lsd/main.js         | 11 +++++---
 cmd/lsf/main.js         | 46 ++++++---------------------------
 cmd/lsjson/main.js      | 56 +++++++++++++++++++++++++++++++++++++++++
 cmd/lsjson/main_test.js | 36 +++++++++++++++++++++++++-
 cmd/lsl/main.js         | 27 ++++++++++++--------
 7 files changed, 145 insertions(+), 69 deletions(-)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index affcc26..3fab2e6 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -252,12 +252,13 @@ backend goes in its `options`. An unknown flag is an error, as in rclone. A
 command reads a boolean flag with `isTrue` of `@rfetch/lib/options`: the flag
 can be `true` or the text `true` of a query.
 
-The lists of text, `ls`, `lsl`, `lsd` and `lsf`, read the items of `lsjson` with
-`listLines` of `cmd/lsf/main.js`, and write each line as rclone writes it: the
-time with `toListTime` of `@rfetch/lib/time`, in the local time zone, and the
-size and the count with `sizeField` and `countField` of `@rfetch/lib/format`, in
-fields of the widths of rclone. `cmd/lsf/rclone_test.js` compares the lines with
-the lines of rclone.
+The lists of text, `ls`, `lsl`, `lsd` and `lsf`, send the body of `lsjson`
+through a `LineStream` of `cmd/lsjson/main.js`. This stream reads the body in
+chunks of any size, and gives the line of each item. Each command writes the
+line as rclone writes it: the time with `toListTime` of `@rfetch/lib/time`, in
+the local time zone, and the size and the count with `sizeField` and
+`countField` of `@rfetch/lib/format`, in fields of the widths of rclone.
+`cmd/lsf/rclone_test.js` compares the lines with the lines of rclone.
 
 ## Tests of a backend
 
diff --git a/cmd/ls/main.js b/cmd/ls/main.js
index 456fc59..bd85226 100644
--- a/cmd/ls/main.js
+++ b/cmd/ls/main.js
@@ -1,6 +1,6 @@
 import { sizeField } from "@rfetch/lib/format";
 import { isTrue } from "@rfetch/lib/options";
-import { listLines } from "../lsf/main.js";
+import { LineStream, lsjson } from "../lsjson/main.js";
 /**
  * List the objects in the path with size and path.
  *
@@ -24,15 +24,20 @@ import { listLines } from "../lsf/main.js";
  * @param {number} [flags.max_depth=Infinity] - Maximum depth of recursion.
  * @returns {Promise<Response>}
  */
-export function ls(location, flags = {}) {
+export async function ls(location, flags = {}) {
   const human = isTrue(flags.human_readable);
+  const response = await lsjson(location, {
+    recursive: true,
+    max_depth: "Infinity",
+    ...flags,
+  });
+  if (!response.ok) return response;
   // As `rclone ls`: the size in 9 characters, then the path.
-  return listLines(
-    location,
-    { recursive: true, max_depth: "Infinity", ...flags },
-    (item) => {
-      if (item.IsDir) return;
-      return `${sizeField(item.Size, human, 9)} ${item.Path}`;
-    },
-  );
+  const lines = new LineStream((item) => {
+    if (item.IsDir) return;
+    return `${sizeField(item.Size, human, 9)} ${item.Path}`;
+  });
+  return new Response(response.body.pipeThrough(lines), {
+    headers: { "Content-Type": "text/plain" },
+  });
 }
diff --git a/cmd/lsd/main.js b/cmd/lsd/main.js
index b85dc78..24af1cc 100644
--- a/cmd/lsd/main.js
+++ b/cmd/lsd/main.js
@@ -1,7 +1,7 @@
 import { countField, sizeField } from "@rfetch/lib/format";
 import { isTrue } from "@rfetch/lib/options";
 import { toListTime } from "@rfetch/lib/time";
-import { listLines } from "../lsf/main.js";
+import { LineStream, lsjson } from "../lsjson/main.js";
 /**
  * List all directories/containers/buckets in the path.
  *
@@ -13,15 +13,20 @@ import { listLines } from "../lsf/main.js";
  * @param {boolean} [flags.recursive=false] - Only list directories.
  * @returns {Promise<Response>}
  */
-export function lsd(location, flags = {}) {
+export async function lsd(location, flags = {}) {
   const human = isTrue(flags.human_readable);
+  const response = await lsjson(location, { recursive: false, ...flags });
+  if (!response.ok) return response;
   // As `rclone lsd`: the size in 12 characters, the local time to the
   // second, the count of items in 9 characters, then the path. A folder has
   // no size and no count: -1 for both.
-  return listLines(location, { recursive: false, ...flags }, (item) => {
+  const lines = new LineStream((item) => {
     if (!item.IsDir) return;
     const time = toListTime(item.ModTime).padStart(13);
     const count = countField(-1, human, 9);
     return `${sizeField(item.Size, human, 12)} ${time} ${count} ${item.Path}`;
   });
+  return new Response(response.body.pipeThrough(lines), {
+    headers: { "Content-Type": "text/plain" },
+  });
 }
diff --git a/cmd/lsf/main.js b/cmd/lsf/main.js
index dce7c84..6ca9943 100644
--- a/cmd/lsf/main.js
+++ b/cmd/lsf/main.js
@@ -1,6 +1,6 @@
 import { isTrue } from "@rfetch/lib/options";
 import { toListTime } from "@rfetch/lib/time";
-import { lsjson } from "../lsjson/main.js";
+import { LineStream, lsjson } from "../lsjson/main.js";
 
 const FORMATS = {
   "p": "Path",
@@ -116,7 +116,7 @@ const FORMATS = {
  * @param {string} [flags.separator=";"] - Separator for the listing.
  * @returns {Promise<Response>}
  */
-export function lsf(location, flags = {}) {
+export async function lsf(location, flags = {}) {
   const format = flags.format ?? "p";
   const csv = isTrue(flags.csv);
   // As rclone, the separator of CSV is "," when the flag does not tell it.
@@ -127,7 +127,9 @@ export function lsf(location, flags = {}) {
   // CSV has a separator of one character.
   const comma = [...separator][0] ?? ",";
 
-  return listLines(location, flags, (item) => {
+  const response = await lsjson(location, flags);
+  if (!response.ok) return response;
+  const lines = new LineStream((item) => {
     if (dirsOnly && !item.IsDir) return;
     if (filesOnly && item.IsDir) return;
     const values = [...format].map((letter) => {
@@ -141,6 +143,9 @@ export function lsf(location, flags = {}) {
     if (!csv) return values.join(separator);
     return values.map((value) => quoted(value, comma)).join(comma);
   });
+  return new Response(response.body.pipeThrough(lines), {
+    headers: { "Content-Type": "text/plain" },
+  });
 }
 
 /**
@@ -160,38 +165,3 @@ function quoted(value, comma) {
 /** A space at the start of a text, as `unicode.IsSpace` of Go. */
 const SPACE =
   /^[\t\n\v\f\r \u0085\u00a0\u1680\u2000-\u200a\u2028\u2029\u202f\u205f\u3000]/;
-
-/**
- * Lists a path as `lsjson`, with a line for each item, for the lists of
- * text: `lsf`, `ls`, `lsl` and `lsd`.
- * @param {string} location
- * @param {Object} flags The flags of `lsjson`, for example `recursive`.
- * @param {(item: import("../../mod.js").File) => string | undefined} line
- *   Gives the line of an item, with no line break, or no line.
- * @returns {Promise<Response>}
- */
-export async function listLines(location, flags, line) {
-  const response = await lsjson(location, flags);
-  if (!response.ok) return response;
-
-  const headers = new Headers(response.headers);
-  headers.set("Content-Type", "text/plain");
-
-  const body = response.body
-    .pipeThrough(new TextDecoderStream())
-    .pipeThrough(
-      new TransformStream({
-        transform(chunk, controller) {
-          // `lsjson` gives each item on a line, with a comma at the end of
-          // each line but the last.
-          chunk = chunk.trim().replace(/,$/, "");
-          if (!chunk.startsWith("{") || chunk.at(-1) !== "}") return;
-          const text = line(JSON.parse(chunk));
-          if (text !== undefined) controller.enqueue(`${text}\n`);
-        },
-      }),
-    )
-    .pipeThrough(new TextEncoderStream());
-
-  return new Response(body, { headers });
-}
diff --git a/cmd/lsjson/main.js b/cmd/lsjson/main.js
index dceb670..05ac369 100644
--- a/cmd/lsjson/main.js
+++ b/cmd/lsjson/main.js
@@ -268,6 +268,62 @@ async function* walk(folder, path) {
   }
 }
 
+/**
+ * A stream that reads the body of `lsjson`, in chunks of any size, and gives
+ * the body of a list of text: a line for each item. It keeps only the part of
+ * a line that has no "\n" yet. The lists of text `ls`, `lsl`, `lsd` and `lsf`
+ * use it.
+ *
+ * Example
+ *
+ * ```js
+ * import { LineStream, lsjson } from "./main.js";
+ * const response = await lsjson("remote:path");
+ * const paths = response.body.pipeThrough(
+ *   new LineStream((item) => item.Path),
+ * );
+ * ```
+ * @extends {TransformStream<Uint8Array, Uint8Array>}
+ */
+export class LineStream extends TransformStream {
+  /**
+   * @param {(item: Item) => string | undefined} line Gives the line of an
+   *   item, with no line break, or no line.
+   */
+  constructor(line) {
+    const decoder = new TextDecoder();
+    let rest = "";
+    /**
+     * Writes the lines of the items of the lines of `lsjson`.
+     * @param {string[]} texts
+     * @param {TransformStreamDefaultController<Uint8Array>} controller
+     */
+    const write = (texts, controller) => {
+      let lines = "";
+      for (let text of texts) {
+        // `lsjson` gives each item on a line, with a comma at the end of
+        // each line but the last.
+        text = text.trim().replace(/,$/, "");
+        if (!text.startsWith("{")) continue;
+        const value = line(JSON.parse(text));
+        if (value !== undefined) lines += `${value}\n`;
+      }
+      if (lines) controller.enqueue(encoder.encode(lines));
+    };
+    super({
+      transform(chunk, controller) {
+        const texts = (rest + decoder.decode(chunk, { stream: true }))
+          .split("\n");
+        rest = texts.pop() ?? "";
+        write(texts, controller);
+      },
+      flush(controller) {
+        write([rest + decoder.decode()], controller);
+      },
+    });
+  }
+}
+
 /**
  * The name of a file in the path of a location, as a backend reads it: with
  * no percent-encoding.
diff --git a/cmd/lsjson/main_test.js b/cmd/lsjson/main_test.js
index 8f65c13..741ac2b 100644
--- a/cmd/lsjson/main_test.js
+++ b/cmd/lsjson/main_test.js
@@ -3,7 +3,7 @@ import assert from "node:assert/strict";
 import { listen } from "@rfetch/lib/testing/server";
 import memory from "@rfetch/memory";
 import { fetch } from "../../mod.js";
-import { lsjson } from "./main.js";
+import { LineStream, lsjson } from "./main.js";
 
 const encoder = new TextEncoder();
 const decoder = new TextDecoder();
@@ -264,3 +264,37 @@ test("lsjson gives a folder with no time the default time of rclone", async () =
   assert.equal(folder.IsDir, true);
   assert.equal(folder.ModTime, "2000-01-01T00:00:00Z");
 });
+
+test("LineStream reads the body of lsjson in chunks of any size", async () => {
+  const text = [
+    "[",
+    '{"Path":"a","Name":"a","IsDir":false},',
+    '{"Path":"日本語 b","Name":"日本語 b","IsDir":false},',
+    '{"Path":"C","Name":"C","IsDir":true}',
+    "]",
+    "",
+  ].join("\n");
+  const bytes = encoder.encode(text);
+  // All in one chunk, a chunk for each byte (thus a character of three
+  // bytes is in three chunks), and chunks of 7 bytes.
+  for (const size of [bytes.length, 1, 7]) {
+    const body = new ReadableStream({
+      start(controller) {
+        for (let i = 0; i < bytes.length; i += size) {
+          controller.enqueue(bytes.slice(i, i + size));
+        }
+        controller.close();
+      },
+    });
+    const lines = body.pipeThrough(
+      new LineStream(({ Path, IsDir }) => IsDir ? undefined : Path),
+    );
+    assert.equal(await new Response(lines).text(), "a\n日本語 b\n", `${size}`);
+  }
+});
+
+test("LineStream gives an error for a line that is not an item", async () => {
+  const body = new Response('[\n{"Path":"a",\n]\n').body;
+  const lines = body.pipeThrough(new LineStream(({ Path }) => Path));
+  await assert.rejects(new Response(lines).text(), SyntaxError);
+});
diff --git a/cmd/lsl/main.js b/cmd/lsl/main.js
index d2b4317..107f321 100644
--- a/cmd/lsl/main.js
+++ b/cmd/lsl/main.js
@@ -1,7 +1,7 @@
 import { sizeField } from "@rfetch/lib/format";
 import { isTrue } from "@rfetch/lib/options";
 import { toListTime } from "@rfetch/lib/time";
-import { listLines } from "../lsf/main.js";
+import { LineStream, lsjson } from "../lsjson/main.js";
 
 /**
  * List the objects in path with modification time, size and path.
@@ -26,17 +26,22 @@ import { listLines } from "../lsf/main.js";
  * @param {number} [flags.max_depth=Infinity] - Maximum depth of recursion.
  * @returns {Promise<Response>}
  */
-export function lsl(location, flags = {}) {
+export async function lsl(location, flags = {}) {
   const human = isTrue(flags.human_readable);
+  const response = await lsjson(location, {
+    recursive: true,
+    max_depth: "Infinity",
+    ...flags,
+  });
+  if (!response.ok) return response;
   // As `rclone lsl`: the size in 9 characters, the local time to the
   // nanosecond, then the path.
-  return listLines(
-    location,
-    { recursive: true, max_depth: "Infinity", ...flags },
-    (item) => {
-      if (item.IsDir) return;
-      const time = toListTime(item.ModTime, 9);
-      return `${sizeField(item.Size, human, 9)} ${time} ${item.Path}`;
-    },
-  );
+  const lines = new LineStream((item) => {
+    if (item.IsDir) return;
+    const time = toListTime(item.ModTime, 9);
+    return `${sizeField(item.Size, human, 9)} ${time} ${item.Path}`;
+  });
+  return new Response(response.body.pipeThrough(lines), {
+    headers: { "Content-Type": "text/plain" },
+  });
 }

From 04880f395e4c9921456c50feafae8a88277ed7df Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C6=A1n=20Tr=E1=BA=A7n-Nguy=E1=BB=85n?= <github@sntran.com>
Date: Sun, 18 Oct 2026 23:21:13 +0000
Subject: [PATCH 87/87] docs: Bun 1.4 or later

On Bun 1.3, rfetch cannot read the list of a local folder: the
HTMLRewriter of Bun gives the error "Failed to pipe stream". An http
remote works. On Bun 1.4.0 and 1.4.3, the lists of a local folder and of
an http remote are correct.

The README tells the minimum version and the error. The engines of
package.json have bun >=1.4.0, next to node.
---
 README.md         | 5 ++++-
 package-lock.json | 1 +
 package.json      | 1 +
 3 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 1f69798..f6eb5f9 100644
--- a/README.md
+++ b/README.md
@@ -62,7 +62,7 @@ bytes, with ranges. The prefix `RCLONE_` of rclone also works.
 
 ## Runtimes
 
-rfetch runs on Node.js 22.2 or later, on Deno and on Bun:
+rfetch runs on Node.js 22.2 or later, on Deno and on Bun 1.4 or later:
 
 ```sh
 node main.js COMMAND ...
@@ -70,6 +70,9 @@ deno run -A main.js COMMAND ...
 bun main.js COMMAND ...
 ```
 
+Bun 1.3 cannot read the list of a local folder: its HTMLRewriter gives the error
+`Failed to pipe stream`.
+
 `node bench/rclone.js RUNTIME...` runs the same commands with rfetch on each
 runtime and with rclone, and first makes sure that they give the same data and
 the same lists. Each time is the median of 5 runs of the command as a new
diff --git a/package-lock.json b/package-lock.json
index b1f24ca..5995018 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -30,6 +30,7 @@
         "fast-check": "^3.19.0"
       },
       "engines": {
+        "bun": ">=1.4.0",
         "node": ">=22.2.0"
       }
     },
diff --git a/package.json b/package.json
index ea63b49..73bd17b 100644
--- a/package.json
+++ b/package.json
@@ -3,6 +3,7 @@
   "version": "0.1.0",
   "description": "Fetching between remotes, using Web APIs.",
   "engines": {
+    "bun": ">=1.4.0",
     "node": ">=22.2.0"
   },
   "bin": {