@ctrl/torrent-file 4.4.0 → 4.5.0

package/README.md

@@ -1,8 +1,12 @@
-# torrent-file [![npm](https://badgen.net/npm/v/@ctrl/torrent-file)](https://www.npmjs.com/package/@ctrl/torrent-file) [![coverage](https://badgen.net/codecov/c/github/scttcper/torrent-file)](https://codecov.io/gh/scttcper/torrent-file) [![bundlesize](https://badgen.net/bundlephobia/min/@ctrl/torrent-file)](https://bundlephobia.com/result?p=@ctrl/torrent-file)
+# torrent-file [![npm](https://badgen.net/npm/v/@ctrl/torrent-file)](https://www.npmjs.com/package/@ctrl/torrent-file)
 
 > Parse a torrent file and read encoded data.
 
-This project is based on [parse-torrent](https://www.npmjs.com/package/parse-torrent) and [node-bencode](https://github.com/themasch/node-bencode) to parse the data of a torrent file. This library implements its own [bencode](http://www.bittorrent.org/beps/bep_0003.html) encoder and decoder that does not use `Buffer`.
+Supports BitTorrent v1 ([BEP-3](http://www.bittorrent.org/beps/bep_0003.html)), v2 ([BEP-52](http://www.bittorrent.org/beps/bep_0052.html)), and hybrid torrent files.
+
+This project is based on [parse-torrent](https://www.npmjs.com/package/parse-torrent) and [node-bencode](https://github.com/themasch/node-bencode) to parse the data of a torrent file. This library implements its own [bencode](http://www.bittorrent.org/beps/bep_0003.html) encoder and decoder that does not use `Buffer` making it easier to use in browser or non node environments.
+
+demo: https://torrent-file.pages.dev
 
 ### Install
 
@@ -14,7 +18,7 @@ npm install @ctrl/torrent-file
 
 ##### info
 
-The content of the metainfo file.
+The content of the metainfo file. Includes a `version` field (`'v1'`, `'v2'`, or `'hybrid'`).
 
 ```ts
 import fs from 'fs';
@@ -27,7 +31,7 @@ console.log({ torrentInfo });
 
 ##### files
 
-data about the files described in the torrent file, includes hashes of the pieces
+Data about the files described in the torrent file, includes hashes of the pieces. For v2/hybrid torrents, files include `piecesRoot` and the result includes `pieceLayers`. `pieces` is undefined for v2-only torrents.
 
 ```ts
 import fs from 'fs';
@@ -40,20 +44,78 @@ console.log({ torrentFiles });
 
 ##### hash
 
-sha1 of torrent file info. This hash is commenly used by torrent clients as the ID of the torrent. It is async and sha1 encoding is handled by [crypto-hash](https://github.com/sindresorhus/crypto-hash)
+SHA-1 of torrent file info. This hash is commonly used by torrent clients as the ID of the torrent.
 
 ```ts
 import fs from 'fs';
 
 import { hash } from '@ctrl/torrent-file';
 
-(async () => {
-  const torrentHash = await hash(fs.readFileSync('myfile'));
-  console.log({ torrentHash });
-})();
+const torrentHash = hash(fs.readFileSync('myfile'));
+console.log({ torrentHash });
+```
+
+##### hashes
+
+Returns both v1 (SHA-1) and v2 (SHA-256) info hashes along with the detected torrent version. `infoHashV2` is only present for v2 and hybrid torrents.
+
+```ts
+import fs from 'fs';
+
+import { hashes } from '@ctrl/torrent-file';
+
+const h = hashes(fs.readFileSync('myfile'));
+console.log(h.version); // 'v1', 'v2', or 'hybrid'
+console.log(h.infoHash); // SHA-1 (always present)
+console.log(h.infoHashV2); // SHA-256 (v2/hybrid only)
+```
+
+### Encode
+
+Convert a parsed torrent object back into a `.torrent` file buffer.
+
+```ts
+import fs from 'fs';
+
+import { toTorrentFile } from '@ctrl/torrent-file';
+
+// Minimal example: create a .torrent buffer from fields
+const buf = toTorrentFile({
+  info: {
+    // Required info fields
+    'piece length': 16384,
+    pieces: new Uint8Array(/* 20-byte SHA1 hashes concatenated */),
+    name: 'example.txt',
+    length: 12345,
+  },
+  // Optional fields
+  announce: ['udp://tracker.publicbt.com:80/announce'],
+  urlList: ['https://example.com/example.txt'],
+  private: false,
+  created: new Date(),
+  createdBy: 'my-app/1.0.0',
+  comment: 'Generated by @ctrl/torrent-file',
+});
+
+fs.writeFileSync('example.torrent', buf);
+```
+
+### Demo
+
+Run a local demo UI to drop a `.torrent` file and view parsed output:
+
+```bash
+pnpm install
+pnpm demo:watch
+```
+
+To build the demo for static hosting:
+
+```bash
+pnpm demo:build
 ```
 
 ### See Also
 
-[parse-torrent](https://www.npmjs.com/package/parse-torrent) - "@ctrl/torrent-file" torrent parsing based very heavily off this project  
-[node-bencode](https://github.com/themasch/node-bencode) - bencoder built into this project heavily based off this project
+[parse-torrent](https://www.npmjs.com/package/parse-torrent) - torrent parsing based very heavily off this package  
+[node-bencode](https://github.com/themasch/node-bencode) - bencoder built into this project heavily based off this package

package/dist/src/bencode/decode.js

@@ -1,64 +1,28 @@
-import { stringToUint8Array, uint8ArrayToString } from 'uint8array-extras';
-const td = new TextDecoder();
+// Byte constants
+const COLON = 0x3a; // ':'
+const CHAR_d = 0x64; // 'd'
+const CHAR_e = 0x65; // 'e'
+const CHAR_i = 0x69; // 'i'
+const CHAR_l = 0x6c; // 'l'
+const CHAR_0 = 0x30; // '0'
+const CHAR_MINUS = 0x2d; // '-'
+const te = new TextEncoder();
 class Decoder {
     idx = 0;
     buf;
     constructor(buf) {
         this.buf = buf;
     }
-    readByte() {
-        if (this.idx >= this.buf.length) {
-            return null;
-        }
-        return String.fromCharCode(this.buf[this.idx++]);
-    }
-    readBytes(length) {
-        if (this.idx + length > this.buf.length) {
-            throw new Error(`could not read ${length} bytes, insufficient content`);
-        }
-        const result = this.buf.slice(this.idx, this.idx + length);
-        this.idx += length;
-        return result;
-    }
-    readUntil(char) {
-        const targetIdx = this.buf.indexOf(char.charCodeAt(0), this.idx);
-        if (targetIdx === -1) {
-            throw new Error(`could not find terminated char: ${char}`);
-        }
-        const result = this.buf.slice(this.idx, targetIdx);
-        this.idx = targetIdx;
-        return result;
-    }
-    readNumber() {
-        const buf = this.readUntil(':');
-        return parseInt(uint8ArrayToString(buf), 10);
-    }
-    peekByte() {
-        if (this.idx >= this.buf.length) {
-            return '';
-        }
-        const result = this.readByte();
-        if (result === null) {
-            return '';
-        }
-        this.idx--;
-        return result;
-    }
-    assertByte(expected) {
-        const b = this.readByte();
-        if (b !== expected) {
-            throw new Error(`expecte ${expected}, got ${b}`);
-        }
-    }
     next() {
-        switch (this.peekByte()) {
-            case 'd': {
+        const byte = this.buf[this.idx];
+        switch (byte) {
+            case CHAR_d: {
                 return this.nextDictionary();
             }
-            case 'l': {
+            case CHAR_l: {
                 return this.nextList();
             }
-            case 'i': {
+            case CHAR_i: {
                 return this.nextNumber();
             }
             default: {
@@ -67,52 +31,84 @@ class Decoder {
         }
     }
     nextBufOrString() {
-        const length = this.readNumber();
-        this.assertByte(':');
-        return this.readBytes(length);
+        const length = this.readLength();
+        const result = this.buf.subarray(this.idx, this.idx + length);
+        this.idx += length;
+        return result;
     }
-    nextString() {
-        const length = this.readNumber();
-        this.assertByte(':');
-        return td.decode(this.readBytes(length));
+    // Read a length prefix including the trailing colon: "123:"
+    readLength() {
+        let n = 0;
+        for (;;) {
+            const byte = this.buf[this.idx++];
+            if (byte === COLON) {
+                return n;
+            }
+            n = n * 10 + (byte - CHAR_0);
+        }
     }
     nextNumber() {
-        this.assertByte('i');
-        const content = td.decode(this.readUntil('e'));
-        this.assertByte('e');
-        const result = Number(content);
-        if (isNaN(result)) {
-            throw new Error(`not a number: ${content}`);
+        this.idx++; // skip 'i'
+        let negative = false;
+        if (this.buf[this.idx] === CHAR_MINUS) {
+            negative = true;
+            this.idx++;
+        }
+        let n = 0;
+        for (;;) {
+            const byte = this.buf[this.idx++];
+            if (byte === CHAR_e) {
+                return negative ? -n : n;
+            }
+            n = n * 10 + (byte - CHAR_0);
         }
-        return result;
     }
     nextList() {
-        this.assertByte('l');
+        this.idx++; // skip 'l'
         const result = [];
-        while (this.peekByte() !== 'e') {
+        while (this.buf[this.idx] !== CHAR_e) {
             result.push(this.next());
         }
-        this.assertByte('e');
+        this.idx++; // skip 'e'
         return result;
     }
+    // Latin1 (1 byte → 1 code point) is lossless for arbitrary binary keys.
+    // BEP-52 piece layers uses raw SHA-256 hashes as dict keys, which
+    // would be corrupted by UTF-8 decoding.
+    nextKeyLatin1() {
+        const length = this.readLength();
+        const start = this.idx;
+        this.idx += length;
+        let key = '';
+        for (let i = start; i < this.idx; i++) {
+            key += String.fromCharCode(this.buf[i]);
+        }
+        return key;
+    }
     nextDictionary() {
-        this.assertByte('d');
+        this.idx++; // skip 'd'
         const result = {};
-        while (this.peekByte() !== 'e') {
-            result[this.nextString()] = this.next();
+        while (this.buf[this.idx] !== CHAR_e) {
+            result[this.nextKeyLatin1()] = this.next();
         }
-        this.assertByte('e');
+        this.idx++; // skip 'e'
         return result;
     }
 }
 export const decode = (payload) => {
     let buf;
     if (typeof payload === 'string') {
-        buf = stringToUint8Array(payload);
+        buf = te.encode(payload);
     }
     else if (payload instanceof ArrayBuffer) {
         buf = new Uint8Array(payload);
     }
+    else if (payload instanceof Uint8Array) {
+        buf =
+            payload.constructor === Uint8Array
+                ? payload
+                : new Uint8Array(payload.buffer, payload.byteOffset, payload.byteLength);
+    }
     else if ('buffer' in payload) {
         buf = new Uint8Array(payload.buffer);
     }

package/dist/src/bencode/encode.d.ts

@@ -2,4 +2,3 @@ export type bencodeValue = string | Uint8Array | number | {
     [key: string]: bencodeValue;
 } | bencodeValue[];
 export declare const encode: (data: bencodeValue | bencodeValue[]) => Uint8Array;
-export default encode;

package/dist/src/bencode/encode.js

@@ -1,52 +1,77 @@
-import { concatUint8Arrays, stringToUint8Array } from 'uint8array-extras';
 const te = new TextEncoder();
+const COLON = 0x3a;
+const BYTE_d = new Uint8Array([0x64]);
+const BYTE_e = new Uint8Array([0x65]);
+const BYTE_l = new Uint8Array([0x6c]);
+function concat(arrays) {
+    let totalLength = 0;
+    for (const arr of arrays) {
+        totalLength += arr.byteLength;
+    }
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const arr of arrays) {
+        result.set(arr, offset);
+        offset += arr.byteLength;
+    }
+    return result;
+}
 const encodeString = (str) => {
-    const lengthBytes = new TextEncoder().encode(str.length.toString());
     const content = te.encode(str);
-    const result = new Uint8Array(lengthBytes.byteLength + 1 + content.byteLength);
-    result.set(lengthBytes);
-    result.set(te.encode(':'), lengthBytes.byteLength);
-    result.set(content, lengthBytes.byteLength + 1);
+    const lengthStr = content.byteLength.toString();
+    const result = new Uint8Array(lengthStr.length + 1 + content.byteLength);
+    te.encodeInto(lengthStr, result);
+    result[lengthStr.length] = COLON;
+    result.set(content, lengthStr.length + 1);
     return result;
 };
 const encodeBuf = (buf) => {
-    const lengthBytes = new TextEncoder().encode(buf.byteLength.toString());
-    const result = new Uint8Array(lengthBytes.byteLength + 1 + buf.byteLength);
-    result.set(lengthBytes);
-    result.set(te.encode(':'), lengthBytes.byteLength);
-    result.set(buf, lengthBytes.byteLength + 1);
+    const lengthStr = buf.byteLength.toString();
+    const result = new Uint8Array(lengthStr.length + 1 + buf.byteLength);
+    te.encodeInto(lengthStr, result);
+    result[lengthStr.length] = COLON;
+    result.set(buf, lengthStr.length + 1);
     return result;
 };
 const encodeNumber = (num) => {
-    // NOTE: only support integers
     const int = Math.floor(num);
     if (int !== num) {
         throw new Error(`bencode only support integers, got ${num}`);
     }
-    return concatUint8Arrays([
-        stringToUint8Array('i'),
-        stringToUint8Array(int.toString()),
-        stringToUint8Array('e'),
-    ]);
+    return te.encode(`i${int}e`);
+};
+// Inverse of Decoder.nextKeyLatin1 — see decode.ts for rationale.
+const encodeKeyLatin1 = (key) => {
+    const lengthStr = key.length.toString();
+    const result = new Uint8Array(lengthStr.length + 1 + key.length);
+    te.encodeInto(lengthStr, result);
+    result[lengthStr.length] = COLON;
+    const offset = lengthStr.length + 1;
+    for (let i = 0; i < key.length; i++) {
+        result[offset + i] = key.charCodeAt(i) & 0xff; // eslint-disable-line no-bitwise
+    }
+    return result;
 };
 const encodeDictionary = (obj) => {
-    const results = [];
-    Object.keys(obj)
-        .sort()
-        .forEach(key => {
-        results.push(encodeString(key));
-        results.push(new Uint8Array(encode(obj[key])));
-    });
-    const d = stringToUint8Array('d');
-    const e = stringToUint8Array('e');
-    return concatUint8Arrays([d, ...results, e]);
+    const keys = Object.keys(obj).sort();
+    const parts = new Array(keys.length * 2 + 2); // eslint-disable-line unicorn/no-new-array
+    parts[0] = BYTE_d;
+    let i = 1;
+    for (const key of keys) {
+        parts[i++] = encodeKeyLatin1(key);
+        parts[i++] = encode(obj[key]);
+    }
+    parts[i] = BYTE_e;
+    return concat(parts);
 };
 const encodeArray = (arr) => {
-    const prefixSuffix = te.encode('le'); // Combined prefix and suffix
-    const encodedElements = arr.map(encode); // Encode each element
-    // Concatenate the encoded elements directly into a Uint8Array
-    const result = concatUint8Arrays([prefixSuffix, ...encodedElements.flat()]);
-    return result;
+    const parts = new Array(arr.length + 2); // eslint-disable-line unicorn/no-new-array
+    parts[0] = BYTE_l;
+    for (let i = 0; i < arr.length; i++) {
+        parts[i + 1] = encode(arr[i]);
+    }
+    parts[arr.length + 1] = BYTE_e;
+    return concat(parts);
 };
 export const encode = (data) => {
     if (Array.isArray(data)) {
@@ -70,4 +95,3 @@ export const encode = (data) => {
         }
     }
 };
-export default encode;

package/dist/src/torrentFile.d.ts

@@ -1,8 +1,22 @@
 export declare const sha1: (input: Uint8Array) => string;
+export declare const sha256: (input: Uint8Array) => string;
+export type TorrentVersion = 'v1' | 'v2' | 'hybrid';
 /**
  * sha1 of torrent file info. This hash is commonly used by torrent clients as the ID of the torrent.
  */
 export declare function hash(file: Uint8Array): string;
+/**
+ * sha256 of torrent file info dict. Used as the info hash for v2/hybrid torrents.
+ */
+export declare function hashV2(file: Uint8Array): string;
+/**
+ * Returns both v1 and v2 info hashes along with the detected torrent version.
+ */
+export declare function hashes(file: Uint8Array): {
+    infoHash: string;
+    infoHashV2?: string;
+    version: TorrentVersion;
+};
 export interface TorrentFileData {
     length: number;
     files: Array<{
@@ -16,13 +30,25 @@ export interface TorrentFileData {
          */
         length: number;
         offset: number;
+        /**
+         * hex-encoded SHA-256 pieces root for this file (v2/hybrid only)
+         */
+        piecesRoot?: string;
     }>;
     /**
      * number of bytes in each piece
      */
     pieceLength: number;
     lastPieceLength: number;
-    pieces: string[];
+    /**
+     * hex-encoded SHA-1 piece hashes (v1/hybrid). Undefined for v2-only torrents.
+     */
+    pieces?: string[];
+    /**
+     * Maps hex-encoded pieces root to array of hex-encoded SHA-256 piece hashes (v2/hybrid only).
+     */
+    pieceLayers?: Record<string, string[]>;
+    version: TorrentVersion;
 }
 /**
  * data about the files the torrent contains
@@ -51,8 +77,23 @@ export interface TorrentInfo {
      * weburls to download torrent files
      */
     urlList: string[];
+    version: TorrentVersion;
 }
 /**
  * torrent file info
  */
 export declare function info(file: Uint8Array): TorrentInfo;
+export interface TorrentFileEncodeInput {
+    info: any;
+    announce?: string[];
+    urlList?: string[];
+    private?: boolean;
+    created?: Date;
+    createdBy?: string;
+    comment?: string;
+    pieceLayers?: Record<string, Uint8Array>;
+}
+/**
+ * Convert a parsed torrent object back into a .torrent file buffer.
+ */
+export declare function toTorrentFile(parsed: TorrentFileEncodeInput): Uint8Array;

package/dist/src/torrentFile.js

@@ -1,20 +1,91 @@
 import { createHash } from 'node:crypto';
-import { join, sep } from 'node:path';
-import { isUint8Array, uint8ArrayToHex, uint8ArrayToString } from 'uint8array-extras';
+import { sep } from 'node:path';
 import { decode, encode } from './bencode/index.js';
-// Helper function to convert Uint8Array to string for display
+const td = new TextDecoder();
+const hexLookup = new Array(256); // eslint-disable-line unicorn/no-new-array
+for (let i = 0; i < 256; i++) {
+    hexLookup[i] = (i < 16 ? '0' : '') + i.toString(16);
+}
+function toHex(buf) {
+    let hex = '';
+    // eslint-disable-next-line typescript-eslint/prefer-for-of
+    for (let i = 0; i < buf.length; i++) {
+        hex += hexLookup[buf[i]];
+    }
+    return hex;
+}
 const toString = (value) => {
     if (value instanceof Uint8Array) {
-        return uint8ArrayToString(value);
+        return td.decode(value);
     }
     return value.toString();
 };
 export const sha1 = (input) => {
     const hash = createHash('sha1');
-    // Update the hash object with the data
     hash.update(input);
     return hash.digest('hex');
 };
+export const sha256 = (input) => {
+    const hash = createHash('sha256');
+    hash.update(input);
+    return hash.digest('hex');
+};
+function detectVersion(infoDict) {
+    const hasV1 = !!(infoDict.pieces || infoDict.files || typeof infoDict.length === 'number');
+    const hasV2 = !!infoDict['file tree'];
+    let version;
+    if (hasV1 && hasV2) {
+        version = 'hybrid';
+    }
+    else if (hasV2) {
+        version = 'v2';
+    }
+    else {
+        version = 'v1';
+    }
+    return { version, hasV1, hasV2 };
+}
+// BEP-52 file tree: directories are nested dicts, files are identified
+// by an empty-string '' key whose value contains { length, 'pieces root' }.
+function flattenFileTree(tree, currentPath) {
+    const result = [];
+    for (const key of Object.keys(tree)) {
+        const node = tree[key];
+        if (key === '') {
+            // This is a file entry
+            result.push({
+                length: node.length,
+                path: currentPath,
+                'pieces root': node['pieces root'],
+            });
+        }
+        else {
+            // This is a directory, recurse
+            result.push(...flattenFileTree(node, [...currentPath, key]));
+        }
+    }
+    return result;
+}
+function splitPieces(buf, chunkSize) {
+    const hex = toHex(buf);
+    const hexChunkSize = chunkSize * 2;
+    const count = Math.ceil(hex.length / hexChunkSize);
+    const pieces = new Array(count); // eslint-disable-line unicorn/no-new-array
+    for (let i = 0; i < count; i++) {
+        pieces[i] = hex.slice(i * hexChunkSize, (i + 1) * hexChunkSize);
+    }
+    return pieces;
+}
+/**
+ * Convert a latin1-encoded string key to hex.
+ */
+function latin1KeyToHex(key) {
+    let hex = '';
+    for (let i = 0; i < key.length; i++) {
+        hex += hexLookup[key.charCodeAt(i) & 0xff]; // eslint-disable-line no-bitwise
+    }
+    return hex;
+}
 /**
  * sha1 of torrent file info. This hash is commonly used by torrent clients as the ID of the torrent.
  */
@@ -22,55 +93,131 @@ export function hash(file) {
     const torrent = decode(file);
     return sha1(encode(torrent.info));
 }
+/**
+ * sha256 of torrent file info dict. Used as the info hash for v2/hybrid torrents.
+ */
+export function hashV2(file) {
+    const torrent = decode(file);
+    return sha256(encode(torrent.info));
+}
+/**
+ * Returns both v1 and v2 info hashes along with the detected torrent version.
+ */
+export function hashes(file) {
+    const torrent = decode(file);
+    const { version, hasV2 } = detectVersion(torrent.info);
+    const encodedInfo = encode(torrent.info);
+    const result = {
+        infoHash: sha1(encodedInfo),
+        version,
+    };
+    if (hasV2) {
+        result.infoHashV2 = sha256(encodedInfo);
+    }
+    return result;
+}
 /**
  * data about the files the torrent contains
  */
 export function files(file) {
     const torrent = decode(file);
+    const { version, hasV1, hasV2 } = detectVersion(torrent.info);
     const result = {
         files: [],
         length: 0,
         lastPieceLength: 0,
         pieceLength: torrent.info['piece length'],
-        pieces: [],
+        version,
     };
-    const files = torrent.info.files || [torrent.info];
     const name = toString(torrent.info['name.utf-8'] || torrent.info.name);
-    result.files = files.map((file, i) => {
-        const parts = [name, ...(file['path.utf-8'] || file.path || [])].map(p => toString(p));
-        return {
-            path: join(sep, ...parts).slice(1),
-            name: parts[parts.length - 1],
-            length: file.length,
-            offset: files.slice(0, i).reduce(sumLength, 0),
-        };
-    });
-    result.length = files.reduce(sumLength, 0);
+    if (hasV2 && !hasV1) {
+        // v2-only: file tree is the only source of file info
+        const flatFiles = flattenFileTree(torrent.info['file tree'], []);
+        let offset = 0;
+        result.files = flatFiles.map(f => {
+            const parts = [name, ...f.path];
+            const entry = {
+                path: parts.join(sep),
+                name: parts[parts.length - 1],
+                length: f.length,
+                offset,
+                piecesRoot: f['pieces root'] ? toHex(f['pieces root']) : undefined,
+            };
+            offset += f.length;
+            return entry;
+        });
+    }
+    else {
+        // v1 or hybrid: use traditional file list
+        const fileList = torrent.info.files || [torrent.info];
+        let offset = 0;
+        result.files = fileList.map((f) => {
+            const parts = [name, ...(f['path.utf-8'] || f.path || [])].map(p => toString(p));
+            const entry = {
+                path: parts.join(sep),
+                name: parts[parts.length - 1],
+                length: f.length,
+                offset,
+            };
+            offset += f.length;
+            return entry;
+        });
+        // For hybrid: attach piecesRoot from the file tree, matched by path.
+        // Can't match by index because v1 may contain padding files that v2 doesn't.
+        if (hasV2 && torrent.info['file tree']) {
+            const flatFiles = flattenFileTree(torrent.info['file tree'], []);
+            const v2ByPath = new Map();
+            for (const ff of flatFiles) {
+                if (ff['pieces root']) {
+                    v2ByPath.set(ff.path.join(sep), ff['pieces root']);
+                }
+            }
+            const prefix = name + sep;
+            for (const file of result.files) {
+                // v1 paths include the torrent name prefix; v2 file tree paths don't
+                const relativePath = file.path.startsWith(prefix)
+                    ? file.path.slice(prefix.length)
+                    : file.path;
+                const root = v2ByPath.get(relativePath);
+                if (root) {
+                    file.piecesRoot = toHex(root);
+                }
+            }
+        }
+        result.pieces = splitPieces(torrent.info.pieces, 20);
+    }
+    result.length = result.files.reduce(sumLength, 0);
     const lastFile = result.files[result.files.length - 1];
     result.lastPieceLength =
         (lastFile && (lastFile.offset + lastFile.length) % result.pieceLength) || result.pieceLength;
-    result.pieces = splitPieces(torrent.info.pieces);
+    // Parse piece layers (v2/hybrid)
+    if (hasV2 && torrent['piece layers']) {
+        const pieceLayers = {};
+        for (const key of Object.keys(torrent['piece layers'])) {
+            const hexKey = latin1KeyToHex(key);
+            const value = torrent['piece layers'][key];
+            if (value instanceof Uint8Array) {
+                pieceLayers[hexKey] = splitPieces(value, 32);
+            }
+        }
+        result.pieceLayers = pieceLayers;
+    }
     return result;
 }
 function sumLength(sum, file) {
     return sum + file.length;
 }
-function splitPieces(buf) {
-    const pieces = [];
-    for (let i = 0; i < buf.length; i += 20) {
-        pieces.push(uint8ArrayToHex(buf.slice(i, i + 20)));
-    }
-    return pieces;
-}
 /**
  * torrent file info
  */
 export function info(file) {
     const torrent = decode(file);
+    const { version } = detectVersion(torrent.info);
     const result = {
         name: toString(torrent.info['name.utf-8'] || torrent.info.name),
         announce: [],
         urlList: [],
+        version,
     };
     if (torrent.info.private !== undefined) {
         result.private = Boolean(torrent.info.private);
@@ -97,17 +244,57 @@ export function info(file) {
     else if (torrent.announce) {
         result.announce.push(toString(torrent.announce));
     }
-    if (result.announce.length) {
-        result.announce = Array.from(new Set(result.announce));
+    if (result.announce.length > 0) {
+        result.announce = [...new Set(result.announce)];
     }
     // web seeds
-    if (isUint8Array(torrent['url-list'])) {
+    if (torrent['url-list'] instanceof Uint8Array) {
         // some clients set url-list to empty string
         torrent['url-list'] = torrent['url-list'].length > 0 ? [torrent['url-list']] : [];
     }
     result.urlList = (torrent['url-list'] || []).map((url) => toString(url));
-    if (result.urlList.length) {
-        result.urlList = Array.from(new Set(result.urlList));
+    if (result.urlList.length > 0) {
+        result.urlList = [...new Set(result.urlList)];
     }
     return result;
 }
+/**
+ * Convert a parsed torrent object back into a .torrent file buffer.
+ */
+export function toTorrentFile(parsed) {
+    const torrent = {
+        info: parsed.info,
+    };
+    // announce list (BEP-12)
+    const announce = parsed.announce || [];
+    if (announce.length > 0) {
+        torrent['announce-list'] = announce.map(url => {
+            if (!torrent.announce) {
+                torrent.announce = url;
+            }
+            return [url];
+        });
+    }
+    // piece layers (BEP-52)
+    if (parsed.pieceLayers && Object.keys(parsed.pieceLayers).length > 0) {
+        torrent['piece layers'] = parsed.pieceLayers;
+    }
+    // url-list (BEP-19 / web seeds)
+    if (parsed.urlList && parsed.urlList.length > 0) {
+        torrent['url-list'] = [...parsed.urlList];
+    }
+    // Private flag lives inside info dict
+    if (parsed.private !== undefined) {
+        torrent.info = { ...torrent.info, private: Number(parsed.private) };
+    }
+    if (parsed.created) {
+        torrent['creation date'] = Math.floor(parsed.created.getTime() / 1000);
+    }
+    if (parsed.createdBy) {
+        torrent['created by'] = parsed.createdBy;
+    }
+    if (parsed.comment) {
+        torrent.comment = parsed.comment;
+    }
+    return encode(torrent);
+}

package/package.json

@@ -1,69 +1,48 @@
 {
   "name": "@ctrl/torrent-file",
-  "version": "4.4.0",
+  "version": "4.5.0",
   "description": "Parse a torrent file (name, hash, files, pieces)",
-  "author": "Scott Cooper <scttcper@gmail.com>",
+  "keywords": [],
+  "homepage": "https://torrent-file.pages.dev",
   "license": "MIT",
+  "author": "Scott Cooper <scttcper@gmail.com>",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/scttcper/torrent-file.git"
   },
-  "type": "module",
-  "exports": "./dist/src/index.js",
-  "types": "./dist/src/index.d.ts",
   "files": [
     "dist/src"
   ],
+  "type": "module",
   "sideEffects": false,
-  "keywords": [],
+  "types": "./dist/src/index.d.ts",
+  "exports": "./dist/src/index.js",
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
   "scripts": {
-    "lint": "oxlint . && prettier --check . --experimental-cli",
-    "lint:fix": "oxlint . --fix && prettier --write . --log-level=error --experimental-cli",
-    "prepare": "npm run build",
+    "lint": "oxlint . && oxfmt --check",
+    "lint:fix": "oxlint . --fix && oxfmt",
+    "prepare": "pnpm run build",
     "build": "tsc",
     "test": "vitest run",
     "test:watch": "vitest",
-    "test:ci": "vitest run --coverage --reporter=default --reporter=junit --outputFile=./junit.xml"
-  },
-  "dependencies": {
-    "uint8array-extras": "^1.5.0"
+    "bench": "vitest bench ./bench/index.bench.ts",
+    "demo:watch": "pnpm -C demo dev",
+    "demo:build": "pnpm -C demo build"
   },
+  "dependencies": {},
   "devDependencies": {
-    "@ctrl/oxlint-config": "1.2.7",
-    "@sindresorhus/tsconfig": "8.0.1",
-    "@trivago/prettier-plugin-sort-imports": "5.2.2",
-    "@types/node": "24.6.2",
-    "@vitest/coverage-v8": "3.2.4",
-    "oxlint": "1.19.0",
-    "parse-torrent": "11.0.18",
-    "prettier": "3.6.2",
+    "@ctrl/oxlint-config": "1.4.0",
+    "@sindresorhus/tsconfig": "8.1.0",
+    "@types/node": "25.2.3",
+    "oxfmt": "0.33.0",
+    "oxlint": "1.48.0",
+    "parse-torrent": "11.0.19",
     "typescript": "5.9.3",
-    "vitest": "3.2.4"
-  },
-  "prettier": {
-    "singleQuote": true,
-    "trailingComma": "all",
-    "arrowParens": "avoid",
-    "semi": true,
-    "printWidth": 100,
-    "plugins": [
-      "@trivago/prettier-plugin-sort-imports"
-    ],
-    "importOrder": [
-      "^node:.*$",
-      "<THIRD_PARTY_MODULES>",
-      "^(@ctrl)(/.*|$)",
-      "^\\.\\./(?!.*\\.css$)",
-      "^\\./(?!.*\\.css$)(?=.*/)",
-      "^\\./(?!.*\\.css$)(?!.*/)"
-    ],
-    "importOrderSeparation": true,
-    "importOrderSortSpecifiers": false
-  },
-  "packageManager": "pnpm@10.18.0",
-  "publishConfig": {
-    "access": "public",
-    "provenance": true
+    "uint8array-extras": "^1.5.0",
+    "vitest": "4.0.18"
   },
   "release": {
     "branches": [
@@ -71,6 +50,7 @@
     ]
   },
   "engines": {
-    "node": ">=18"
-  }
+    "node": ">20"
+  },
+  "packageManager": "pnpm@10.29.3"
 }