modern-tar 0.2.2 → 0.3.0

package/README.md

@@ -105,22 +105,52 @@ for await (const entry of decodedStream) {
 #### Compression/Decompression (gzip)
 
 ```typescript
-import { createGzipDecoder, unpackTar } from 'modern-tar';
+import { createGzipEncoder, createTarPacker } from 'modern-tar';
 
-// Fetch a .tar.gz file stream
-const response = await fetch('https://example.com/archive.tar.gz');
+// Create and compress a tar archive
+const { readable, controller } = createTarPacker();
+const compressedStream = readable.pipeThrough(createGzipEncoder());
+
+// Add entries...
+const fileStream = controller.add({ name: "file.txt", size: 5, type: "file" });
+const writer = fileStream.getWriter();
+await writer.write(new TextEncoder().encode("hello"));
+await writer.close();
+controller.finalize();
+
+// Upload compressed .tar.gz
+await fetch('/api/upload', {
+  method: 'POST',
+  body: compressedStream,
+  headers: { 'Content-Type': 'application/gzip' }
+});
+```
+
+```typescript
+import { createGzipDecoder, createTarDecoder, unpackTar } from 'modern-tar';
+
+// Download and process a .tar.gz file
+const response = await fetch('https://api.example.com/archive.tar.gz');
 if (!response.body) throw new Error('No response body');
 
-// Decompress .tar.gz to .tar stream
-const tarStream = response.body.pipeThrough(createGzipDecoder());
+// Buffer entire archive
+const entries = await unpackTar(response.body.pipeThrough(createGzipDecoder()));
 
-// Use `unpackTar` for buffered extraction or `createTarDecoder` for streaming
-const entries = await unpackTar(tarStream);
 for (const entry of entries) {
 	console.log(`Extracted: ${entry.header.name}`);
 	const content = new TextDecoder().decode(entry.data);
 	console.log(`Content: ${content}`);
 }
+
+// Or chain decompression and tar parsing using streams
+const entries = response.body
+  .pipeThrough(createGzipDecoder())
+  .pipeThrough(createTarDecoder());
+
+for await (const entry of entries) {
+  console.log(`Extracted: ${entry.header.name}`);
+  // Process entry.body ReadableStream as needed
+}
 ```
 
 ### Node.js Filesystem Usage
@@ -421,7 +451,7 @@ interface ParsedTarEntry {
 // Output entry from a buffered unpack function
 interface ParsedTarEntryWithData {
 	header: TarHeader;
-	data: Uint8Array<ArrayBuffer>;
+	data: Uint8Array;
 }
 
 // Platform-neutral configuration for unpacking

package/dist/fs/index.d.ts

@@ -1,4 +1,4 @@
-import { TarEntryData, TarHeader, UnpackOptions } from "../index-G8Ie88oV.js";
+import { TarEntryData, TarHeader, UnpackOptions } from "../index-C8X7IkYR.js";
 import { Stats } from "node:fs";
 import { Readable, Writable } from "node:stream";
 
@@ -110,7 +110,7 @@ declare function packTarSources(sources: TarSource[]): Readable;
  *
  * @example
  * ```typescript
- * import { packTar } from '@modern-tar/fs';
+ * import { packTar } from 'modern-tar/fs';
  * import { createWriteStream } from 'node:fs';
  * import { pipeline } from 'node:stream/promises';
  *
@@ -142,7 +142,7 @@ declare function packTar(directoryPath: string, options?: PackOptionsFS): Readab
  *
  * @example
  * ```typescript
- * import { unpackTar } from '@modern-tar/fs';
+ * import { unpackTar } from 'modern-tar/fs';
  * import { createReadStream } from 'node:fs';
  * import { pipeline } from 'node:stream/promises';
  *

package/dist/fs/index.js

@@ -1,4 +1,4 @@
-import { BLOCK_SIZE, createTarDecoder, createTarHeader, createTarOptionsTransformer, createTarPacker } from "../web-DcwR3pag.js";
+import { BLOCK_SIZE, createTarDecoder, createTarHeader, createTarOptionsTransformer, createTarPacker, encoder, generatePax } from "../web-LcCN87Qy.js";
 import { createReadStream, createWriteStream } from "node:fs";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
@@ -6,34 +6,6 @@ import { PassThrough, Readable, Writable } from "node:stream";
 import { pipeline } from "node:stream/promises";
 
 //#region src/fs/archive.ts
-async function addFileToPacker(controller, sourcePath, targetPath) {
-	const stat = await fs.stat(sourcePath);
-	const entryStream = controller.add({
-		name: targetPath,
-		size: stat.size,
-		mode: stat.mode,
-		mtime: stat.mtime,
-		type: "file"
-	});
-	await pipeline(createReadStream(sourcePath), Writable.fromWeb(entryStream));
-}
-async function addDirectoryToPacker(controller, sourcePath, targetPathInArchive) {
-	const sourceStat = await fs.stat(sourcePath);
-	controller.add({
-		name: `${targetPathInArchive}/`,
-		type: "directory",
-		mode: sourceStat.mode,
-		mtime: sourceStat.mtime,
-		size: 0
-	}).close();
-	const dirents = await fs.readdir(sourcePath, { withFileTypes: true });
-	for (const dirent of dirents) {
-		const fullSourcePath = path.join(sourcePath, dirent.name);
-		const archiveEntryPath = path.join(targetPathInArchive, dirent.name).replace(/\\/g, "/");
-		if (dirent.isDirectory()) await addDirectoryToPacker(controller, fullSourcePath, archiveEntryPath);
-		else if (dirent.isFile()) await addFileToPacker(controller, fullSourcePath, archiveEntryPath);
-	}
-}
 /**
 * Packs multiple sources into a tar archive as a Node.js Readable stream from an
 * array of sources (files, directories, or raw content).
@@ -82,7 +54,7 @@ function packTarSources(sources) {
 					}
 					if (content instanceof ReadableStream) {
 						const chunks = [];
-						for await (const chunk of Readable.fromWeb(content)) chunks.push(chunk);
+						for await (const chunk of Readable.fromWeb(content)) chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
 						const buffer = Buffer.concat(chunks);
 						const writer$1 = controller.add({
 							name: targetPath,
@@ -96,9 +68,10 @@ function packTarSources(sources) {
 					}
 					let data;
 					if (content === null || content === void 0) data = new Uint8Array(0);
-					else if (typeof content === "string") data = Buffer.from(content);
+					else if (content instanceof Uint8Array) data = content;
 					else if (content instanceof ArrayBuffer) data = new Uint8Array(content);
-					else data = content;
+					else if (typeof content === "string") data = encoder.encode(content);
+					else throw new TypeError(`Unsupported content type for entry "${targetPath}". Expected string, Uint8Array, ArrayBuffer, Blob, ReadableStream, or undefined.`);
 					const writer = controller.add({
 						name: targetPath,
 						size: data.length,
@@ -114,6 +87,34 @@ function packTarSources(sources) {
 	})().then(() => controller.finalize()).catch((err) => controller.error(err));
 	return Readable.fromWeb(readable);
 }
+async function addFileToPacker(controller, sourcePath, targetPath) {
+	const stat = await fs.stat(sourcePath);
+	const entryStream = controller.add({
+		name: targetPath,
+		size: stat.size,
+		mode: stat.mode,
+		mtime: stat.mtime,
+		type: "file"
+	});
+	await pipeline(createReadStream(sourcePath), Writable.fromWeb(entryStream));
+}
+async function addDirectoryToPacker(controller, sourcePath, targetPathInArchive) {
+	const sourceStat = await fs.stat(sourcePath);
+	controller.add({
+		name: `${targetPathInArchive}/`,
+		type: "directory",
+		mode: sourceStat.mode,
+		mtime: sourceStat.mtime,
+		size: 0
+	}).close();
+	const dirents = await fs.readdir(sourcePath, { withFileTypes: true });
+	for (const dirent of dirents) {
+		const fullSourcePath = path.join(sourcePath, dirent.name);
+		const archiveEntryPath = path.join(targetPathInArchive, dirent.name).replace(/\\/g, "/");
+		if (dirent.isDirectory()) await addDirectoryToPacker(controller, fullSourcePath, archiveEntryPath);
+		else if (dirent.isFile()) await addFileToPacker(controller, fullSourcePath, archiveEntryPath);
+	}
+}
 
 //#endregion
 //#region src/fs/pack.ts
@@ -129,7 +130,7 @@ function packTarSources(sources) {
 *
 * @example
 * ```typescript
-* import { packTar } from '@modern-tar/fs';
+* import { packTar } from 'modern-tar/fs';
 * import { createWriteStream } from 'node:fs';
 * import { pipeline } from 'node:stream/promises';
 *
@@ -177,6 +178,13 @@ function packTar(directoryPath, options = {}) {
 			} else if (stat.isFile()) header.size = stat.size;
 		}
 		const finalHeader = options.map ? options.map(header) : header;
+		const paxData = generatePax(finalHeader);
+		if (paxData) {
+			yield paxData.paxHeader;
+			yield paxData.paxBody;
+			const paxPadding = (BLOCK_SIZE - paxData.paxBody.length % BLOCK_SIZE) % BLOCK_SIZE;
+			if (paxPadding > 0) yield Buffer.alloc(paxPadding);
+		}
 		yield createTarHeader(finalHeader);
 		if (finalHeader.type === "file" && finalHeader.size > 0) {
 			yield* createReadStream(fullPath);
@@ -210,7 +218,7 @@ function packTar(directoryPath, options = {}) {
 *
 * @example
 * ```typescript
-* import { unpackTar } from '@modern-tar/fs';
+* import { unpackTar } from 'modern-tar/fs';
 * import { createReadStream } from 'node:fs';
 * import { pipeline } from 'node:stream/promises';
 *
@@ -315,6 +323,9 @@ function unpackTar(directoryPath, options = {}) {
 						await fs.link(resolvedLinkTarget, outPath);
 						break;
 					}
+					default:
+						await entry.body.cancel();
+						break;
 				}
 				if (header.mtime) try {
 					await (header.type === "symlink" ? fs.lutimes : fs.utimes)(outPath, header.mtime, header.mtime);

package/dist/{index-G8Ie88oV.d.ts → index-C8X7IkYR.d.ts}

@@ -1,12 +1,11 @@
 //#region src/web/compression.d.ts
 /**
- * Creates a gzip compression stream using the native
- * [`CompressionStream`](https://developer.mozilla.org/en-US/docs/Web/API/CompressionStream) API.
+ * Creates a gzip compression stream that is compatible with Uint8Array streams.
  *
- * @returns A [`CompressionStream`](https://developer.mozilla.org/en-US/docs/Web/API/CompressionStream) configured for gzip compression
+ * @returns A {@link ReadableWritablePair} configured for gzip compression.
  * @example
  * ```typescript
- * import { createGzipEncoder, createTarPacker } from '@modern-tar/core';
+ * import { createGzipEncoder, createTarPacker } from 'modern-tar';
  *
  * // Create and compress a tar archive
  * const { readable, controller } = createTarPacker();
@@ -27,46 +26,65 @@
  * });
  * ```
  */
-declare function createGzipEncoder(): CompressionStream;
+declare function createGzipEncoder(): ReadableWritablePair<Uint8Array, Uint8Array>;
 /**
- * Creates a gzip decompression stream using the native
- * [`DecompressionStream`](https://developer.mozilla.org/en-US/docs/Web/API/DecompressionStream) API.
+ * Creates a gzip decompression stream that is compatible with Uint8Array streams.
  *
- * @returns A [`DecompressionStream`](https://developer.mozilla.org/en-US/docs/Web/API/DecompressionStream) configured for gzip decompression
+ * @returns A {@link ReadableWritablePair} configured for gzip decompression.
  * @example
  * ```typescript
- * import { createGzipDecoder, createTarDecoder } from '@modern-tar/core';
+ * import { createGzipDecoder, createTarDecoder } from 'modern-tar';
  *
  * // Download and process a .tar.gz file
  * const response = await fetch('https://api.example.com/archive.tar.gz');
  * if (!response.body) throw new Error('No response body');
  *
- * // Chain decompression and tar parsing
- * const entries = response.body
- *   .pipeThrough(createGzipDecoder())
- *   .pipeThrough(createTarDecoder());
+ * // Buffer entire archive
+ * const entries = await unpackTar(response.body.pipeThrough(createGzipDecoder()));
  *
- * for await (const entry of entries) {
+ * for (const entry of entries) {
  *   console.log(`Extracted: ${entry.header.name}`);
- *   // Process entry.body ReadableStream as needed
+ *   const content = new TextDecoder().decode(entry.data);
+ *   console.log(`Content: ${content}`);
  * }
  * ```
  * @example
  * ```typescript
- * // Decompress local .tar.gz data
- * const gzippedData = new Uint8Array([...]); // your gzipped tar data
- * const stream = new ReadableStream({
- *   start(controller) {
- *     controller.enqueue(gzippedData);
- *     controller.close();
- *   }
- * });
+ * import { createGzipDecoder, createTarDecoder } from 'modern-tar';
+ *
+ * // Download and process a .tar.gz file
+ * const response = await fetch('https://api.example.com/archive.tar.gz');
+ * if (!response.body) throw new Error('No response body');
+ *
+ * // Chain decompression and tar parsing using streams
+ * const entries = response.body
+ *   .pipeThrough(createGzipDecoder())
+ *   .pipeThrough(createTarDecoder());
  *
- * const tarStream = stream.pipeThrough(createGzipDecoder());
- * // Now process tarStream with createTarDecoder()...
+ * for await (const entry of entries) {
+ * console.log(`Extracted: ${entry.header.name}`);
+ *   // Process entry.body ReadableStream as needed
+ * }
  * ```
  */
-declare function createGzipDecoder(): DecompressionStream;
+declare function createGzipDecoder(): ReadableWritablePair<Uint8Array, Uint8Array>;
+//#endregion
+//#region src/web/constants.d.ts
+
+/** Type flag constants for file types. */
+declare const TYPEFLAG: {
+  readonly file: "0";
+  readonly link: "1";
+  readonly symlink: "2";
+  readonly "character-device": "3";
+  readonly "block-device": "4";
+  readonly directory: "5";
+  readonly fifo: "6";
+  readonly "pax-header": "x";
+  readonly "pax-global-header": "g";
+  readonly "gnu-long-name": "L";
+  readonly "gnu-long-link-name": "K";
+};
 //#endregion
 //#region src/web/types.d.ts
 /**
@@ -82,7 +100,7 @@ interface TarHeader {
   /** Unix file permissions as an octal number (e.g., 0o644 for rw-r--r--). Defaults to 0o644 for files and 0o755 for directories. */
   mode?: number;
   /** Entry type. Defaults to "file" if not specified. */
-  type?: "file" | "directory" | "symlink" | "link" | "pax-header" | "pax-global-header";
+  type?: keyof typeof TYPEFLAG;
   /** User ID of the entry owner. */
   uid?: number;
   /** Group ID of the entry owner. */
@@ -98,16 +116,8 @@ interface TarHeader {
 }
 /**
  * Union type for entry body data that can be packed into a tar archive.
- *
- * Supports multiple input types for convenience:
- * - `string` - Text content (encoded as UTF-8)
- * - `Uint8Array` - Binary data
- * - `ArrayBuffer` - Binary data
- * - `ReadableStream<Uint8Array>` - Streaming data
- * - `Blob` - File-like data
- * - `null` - No content (for directories, etc.)
  */
-type TarEntryData = string | Uint8Array | ArrayBuffer | ReadableStream<Uint8Array> | Blob | null;
+type TarEntryData = string | Uint8Array | ArrayBuffer | ReadableStream<Uint8Array> | Blob | null | undefined;
 /**
  * Represents a complete entry to be packed into a tar archive.
  *
@@ -127,11 +137,10 @@ interface ParsedTarEntry {
 }
 /**
  * Represents an extracted entry with fully buffered content.
-
  */
 interface ParsedTarEntryWithData {
   header: TarHeader;
-  data: Uint8Array<ArrayBuffer>;
+  data: Uint8Array;
 }
 /**
  * Platform-neutral configuration options for extracting tar archives.
@@ -158,7 +167,7 @@ interface UnpackOptions {
  * @returns A `Promise` that resolves to the complete tar archive as a Uint8Array
  * @example
  * ```typescript
- * import { packTar } from '@modern-tar/core';
+ * import { packTar } from 'modern-tar';
  *
  * const entries = [
  *   {
@@ -195,7 +204,7 @@ declare function packTar(entries: TarEntry[]): Promise<Uint8Array>;
  * @returns A `Promise` that resolves to an array of entries with buffered data
  * @example
  * ```typescript
- * import { unpackTar } from '@modern-tar/core';
+ * import { unpackTar } from '@modern-tar';
  *
  * // From a file upload or fetch
  * const response = await fetch('/api/archive.tar');
@@ -238,7 +247,7 @@ declare function unpackTar(archive: ArrayBuffer | Uint8Array | ReadableStream<Ui
  *
  * @example
  * ```typescript
- * import { createTarDecoder, createTarOptionsTransformer } from '@modern-tar/core';
+ * import { createTarDecoder, createTarOptionsTransformer } from 'modern-tar';
  *
  * const transformedStream = sourceStream
  *   .pipeThrough(createTarDecoder())
@@ -311,9 +320,8 @@ interface TarPackController {
 /**
  * Create a streaming tar packer.
  *
- * This function provides a controller-based API for creating tar archives, suitable
- * for scenarios where entries are generated dynamically or when you need control over
- * the packing process. The returned [`ReadableStream`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream)
+ * Provides a controller-based API for creating tar archives, suitable for scenarios where entries are
+ * generated dynamically. The returned [`ReadableStream`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream)
  * outputs tar archive bytes as entries are added.
  *
  * @returns Object containing the readable stream and controller
@@ -322,7 +330,7 @@ interface TarPackController {
  *
  * @example
  * ```typescript
- * import { createTarPacker } from '@modern-tar/core';
+ * import { createTarPacker } from 'modern-tar';
  *
  * const { readable, controller } = createTarPacker();
  *
@@ -360,9 +368,22 @@ declare function createTarPacker(): {
   controller: TarPackController;
 };
 //#endregion
-//#region src/web/stream.d.ts
+//#region src/web/unpack.d.ts
 /**
- * Creates a TransformStream that parses a tar archive into ParsedTarEntry objects.
+ * Create a transform stream that parses tar bytes into entries.
+ *
+ * @returns `TransformStream` that converts tar archive bytes to {@link ParsedTarEntry} objects.
+ * @example
+ * ```typescript
+ * import { createTarDecoder } from 'modern-tar';
+ *
+ * const decoder = createTarDecoder();
+ * const entriesStream = tarStream.pipeThrough(decoder);
+ *
+ * for await (const entry of entriesStream) {
+ *  console.log(`Entry: ${entry.header.name}`);
+ *  // Process entry.body stream as needed
+ * }
  */
 declare function createTarDecoder(): TransformStream<Uint8Array, ParsedTarEntry>;
 //#endregion

package/dist/web/index.d.ts

@@ -1,2 +1,2 @@
-import { ParsedTarEntry, ParsedTarEntryWithData, TarEntry, TarEntryData, TarHeader, TarPackController, UnpackOptions, createGzipDecoder, createGzipEncoder, createTarDecoder, createTarOptionsTransformer, createTarPacker, packTar, unpackTar } from "../index-G8Ie88oV.js";
+import { ParsedTarEntry, ParsedTarEntryWithData, TarEntry, TarEntryData, TarHeader, TarPackController, UnpackOptions, createGzipDecoder, createGzipEncoder, createTarDecoder, createTarOptionsTransformer, createTarPacker, packTar, unpackTar } from "../index-C8X7IkYR.js";
 export { ParsedTarEntry, ParsedTarEntryWithData, TarEntry, TarEntryData, TarHeader, TarPackController, UnpackOptions, createGzipDecoder, createGzipEncoder, createTarDecoder, createTarOptionsTransformer, createTarPacker, packTar, unpackTar };

package/dist/web/index.js

@@ -1,3 +1,3 @@
-import { createGzipDecoder, createGzipEncoder, createTarDecoder, createTarOptionsTransformer, createTarPacker, packTar, unpackTar } from "../web-DcwR3pag.js";
+import { createGzipDecoder, createGzipEncoder, createTarDecoder, createTarOptionsTransformer, createTarPacker, packTar, unpackTar } from "../web-LcCN87Qy.js";
 
 export { createGzipDecoder, createGzipEncoder, createTarDecoder, createTarOptionsTransformer, createTarPacker, packTar, unpackTar };

package/dist/{web-DcwR3pag.js → web-LcCN87Qy.js}

@@ -1,12 +1,11 @@
 //#region src/web/compression.ts
 /**
-* Creates a gzip compression stream using the native
-* [`CompressionStream`](https://developer.mozilla.org/en-US/docs/Web/API/CompressionStream) API.
+* Creates a gzip compression stream that is compatible with Uint8Array streams.
 *
-* @returns A [`CompressionStream`](https://developer.mozilla.org/en-US/docs/Web/API/CompressionStream) configured for gzip compression
+* @returns A {@link ReadableWritablePair} configured for gzip compression.
 * @example
 * ```typescript
-* import { createGzipEncoder, createTarPacker } from '@modern-tar/core';
+* import { createGzipEncoder, createTarPacker } from 'modern-tar';
 *
 * // Create and compress a tar archive
 * const { readable, controller } = createTarPacker();
@@ -31,41 +30,43 @@ function createGzipEncoder() {
 	return new CompressionStream("gzip");
 }
 /**
-* Creates a gzip decompression stream using the native
-* [`DecompressionStream`](https://developer.mozilla.org/en-US/docs/Web/API/DecompressionStream) API.
+* Creates a gzip decompression stream that is compatible with Uint8Array streams.
 *
-* @returns A [`DecompressionStream`](https://developer.mozilla.org/en-US/docs/Web/API/DecompressionStream) configured for gzip decompression
+* @returns A {@link ReadableWritablePair} configured for gzip decompression.
 * @example
 * ```typescript
-* import { createGzipDecoder, createTarDecoder } from '@modern-tar/core';
+* import { createGzipDecoder, createTarDecoder } from 'modern-tar';
 *
 * // Download and process a .tar.gz file
 * const response = await fetch('https://api.example.com/archive.tar.gz');
 * if (!response.body) throw new Error('No response body');
 *
-* // Chain decompression and tar parsing
-* const entries = response.body
-*   .pipeThrough(createGzipDecoder())
-*   .pipeThrough(createTarDecoder());
+* // Buffer entire archive
+* const entries = await unpackTar(response.body.pipeThrough(createGzipDecoder()));
 *
-* for await (const entry of entries) {
+* for (const entry of entries) {
 *   console.log(`Extracted: ${entry.header.name}`);
-*   // Process entry.body ReadableStream as needed
+*   const content = new TextDecoder().decode(entry.data);
+*   console.log(`Content: ${content}`);
 * }
 * ```
 * @example
 * ```typescript
-* // Decompress local .tar.gz data
-* const gzippedData = new Uint8Array([...]); // your gzipped tar data
-* const stream = new ReadableStream({
-*   start(controller) {
-*     controller.enqueue(gzippedData);
-*     controller.close();
-*   }
-* });
+* import { createGzipDecoder, createTarDecoder } from 'modern-tar';
+*
+* // Download and process a .tar.gz file
+* const response = await fetch('https://api.example.com/archive.tar.gz');
+* if (!response.body) throw new Error('No response body');
+*
+* // Chain decompression and tar parsing using streams
+* const entries = response.body
+*   .pipeThrough(createGzipDecoder())
+*   .pipeThrough(createTarDecoder());
 *
-* const tarStream = stream.pipeThrough(createGzipDecoder());
-* // Now process tarStream with createTarDecoder()...
+* for await (const entry of entries) {
+* console.log(`Extracted: ${entry.header.name}`);
+*   // Process entry.body ReadableStream as needed
+* }
 * ```
 */
 function createGzipDecoder() {
@@ -82,7 +83,7 @@ function createGzipDecoder() {
 *
 * @example
 * ```typescript
-* import { createTarDecoder, createTarOptionsTransformer } from '@modern-tar/core';
+* import { createTarDecoder, createTarOptionsTransformer } from 'modern-tar';
 *
 * const transformedStream = sourceStream
 *   .pipeThrough(createTarDecoder())
@@ -224,25 +225,37 @@ const USTAR = {
 };
 /** USTAR version ("00"). */
 const USTAR_VERSION = "00";
-/** ASCII code for a space character, used as a placeholder in checksum calculation. */
-const CHECKSUM_SPACE = 32;
+/** USTAR max value in 8-byte octal field. */
+const USTAR_MAX_UID_GID = 2097151;
+/** USTAR max value in 12-byte octal field (~8GB). */
+const USTAR_MAX_SIZE = 8589934591;
 /** Type flag constants for file types. */
 const TYPEFLAG = {
 	file: "0",
 	link: "1",
 	symlink: "2",
+	"character-device": "3",
+	"block-device": "4",
 	directory: "5",
+	fifo: "6",
 	"pax-header": "x",
-	"pax-global-header": "g"
+	"pax-global-header": "g",
+	"gnu-long-name": "L",
+	"gnu-long-link-name": "K"
 };
 /** Reverse mapping from flag characters to type names. */
 const FLAGTYPE = {
-	[TYPEFLAG.file]: "file",
-	[TYPEFLAG.link]: "link",
-	[TYPEFLAG.symlink]: "symlink",
-	[TYPEFLAG.directory]: "directory",
-	[TYPEFLAG["pax-header"]]: "pax-header",
-	[TYPEFLAG["pax-global-header"]]: "pax-global-header"
+	"0": "file",
+	"1": "link",
+	"2": "symlink",
+	"3": "character-device",
+	"4": "block-device",
+	"5": "directory",
+	"6": "fifo",
+	x: "pax-header",
+	g: "pax-global-header",
+	L: "gnu-long-name",
+	K: "gnu-long-link-name"
 };
 
 //#endregion
@@ -280,58 +293,130 @@ function readOctal(view, offset, size) {
 	const octalString = readString(view, offset, size).trim();
 	return octalString ? Number.parseInt(octalString, 8) : 0;
 }
-
-//#endregion
-//#region src/web/pack.ts
 /**
-* Creates a 512-byte USTAR format tar header block from a TarHeader object.
+* Reads a numeric field that can be octal or POSIX base-256.
+* This implementation handles positive integers, such as uid, gid, and size.
 */
-function createTarHeader(header) {
-	const view = new Uint8Array(BLOCK_SIZE);
-	const size = header.type === "directory" || header.type === "symlink" || header.type === "link" ? 0 : header.size ?? 0;
-	let name = header.name;
-	let prefix = "";
-	if (name.length > USTAR.name.size) {
-		let i = name.length;
-		while (i > 0) {
-			const slashIndex = name.lastIndexOf("/", i);
-			if (slashIndex === -1) break;
-			const p = name.slice(0, slashIndex);
-			const n = name.slice(slashIndex + 1);
-			if (p.length <= USTAR.prefix.size && n.length <= USTAR.name.size) {
-				prefix = p;
-				name = n;
-				break;
-			}
-			i = slashIndex - 1;
+function readNumeric(view, offset, size) {
+	if (view[offset] & 128) {
+		let result = view[offset] & 127;
+		for (let i = 1; i < size; i++) result = result << 8 | view[offset + i];
+		return result;
+	}
+	return readOctal(view, offset, size);
+}
+/**
+* Reads an entire ReadableStream of Uint8Arrays into a single, combined Uint8Array.
+*
+* The easy way to do this is `new Response(stream).arrayBuffer()`, but we can be more
+* performant by buffering the chunks directly.
+*/
+async function streamToBuffer(stream) {
+	const chunks = [];
+	const reader = stream.getReader();
+	let totalLength = 0;
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			chunks.push(value);
+			totalLength += value.length;
 		}
+		const result = new Uint8Array(totalLength);
+		let offset = 0;
+		for (const chunk of chunks) {
+			result.set(chunk, offset);
+			offset += chunk.length;
+		}
+		return result;
+	} finally {
+		reader.releaseLock();
 	}
-	writeString(view, USTAR.name.offset, USTAR.name.size, name);
-	writeOctal(view, USTAR.mode.offset, USTAR.mode.size, header.mode ?? (header.type === "directory" ? DEFAULT_DIR_MODE : DEFAULT_FILE_MODE));
-	writeOctal(view, USTAR.uid.offset, USTAR.uid.size, header.uid ?? 0);
-	writeOctal(view, USTAR.gid.offset, USTAR.gid.size, header.gid ?? 0);
-	writeOctal(view, USTAR.size.offset, USTAR.size.size, size);
-	writeOctal(view, USTAR.mtime.offset, USTAR.mtime.size, Math.floor((header.mtime?.getTime() ?? Date.now()) / 1e3));
-	writeString(view, USTAR.typeflag.offset, USTAR.typeflag.size, TYPEFLAG[header.type ?? "file"]);
-	writeString(view, USTAR.linkname.offset, USTAR.linkname.size, header.linkname);
-	writeString(view, USTAR.magic.offset, USTAR.magic.size, "ustar\0");
-	writeString(view, USTAR.version.offset, USTAR.version.size, USTAR_VERSION);
-	writeString(view, USTAR.uname.offset, USTAR.uname.size, header.uname);
-	writeString(view, USTAR.gname.offset, USTAR.gname.size, header.gname);
-	writeString(view, USTAR.prefix.offset, USTAR.prefix.size, prefix);
-	view.fill(CHECKSUM_SPACE, USTAR.checksum.offset, USTAR.checksum.offset + USTAR.checksum.size);
+}
+
+//#endregion
+//#region src/web/checksum.ts
+const CHECKSUM_SPACE = 32;
+/**
+* Validates the checksum of a tar header block.
+*/
+function validateChecksum(block) {
+	const storedChecksum = readOctal(block, USTAR.checksum.offset, USTAR.checksum.size);
+	let unsignedSum = 0;
+	for (let i = 0; i < USTAR.checksum.offset; i++) unsignedSum += block[i];
+	unsignedSum += CHECKSUM_SPACE * USTAR.checksum.size;
+	for (let i = USTAR.checksum.offset + USTAR.checksum.size; i < block.length; i++) unsignedSum += block[i];
+	return storedChecksum === unsignedSum;
+}
+/**
+* Calculates and writes the checksum to a tar header block.
+*/
+function writeChecksum(block) {
+	const checksumEnd = USTAR.checksum.offset + USTAR.checksum.size;
+	block.fill(CHECKSUM_SPACE, USTAR.checksum.offset, checksumEnd);
 	let checksum = 0;
-	for (const byte of view) checksum += byte;
+	for (const byte of block) checksum += byte;
 	const checksumString = `${checksum.toString(8).padStart(6, "0")}\0 `;
-	writeString(view, USTAR.checksum.offset, USTAR.checksum.size, checksumString);
-	return view;
+	const checksumBytes = encoder.encode(checksumString);
+	block.set(checksumBytes, USTAR.checksum.offset);
+}
+
+//#endregion
+//#region src/web/pack-pax.ts
+function generatePax(header) {
+	const paxRecords = {};
+	if (header.name.length > USTAR.name.size) {
+		if (findUstarSplit(header.name) === null) paxRecords.path = header.name;
+	}
+	if (header.linkname && header.linkname.length > USTAR.name.size) paxRecords.linkpath = header.linkname;
+	if (header.uname && header.uname.length > USTAR.uname.size) paxRecords.uname = header.uname;
+	if (header.gname && header.gname.length > USTAR.gname.size) paxRecords.gname = header.gname;
+	if (header.uid != null && header.uid > USTAR_MAX_UID_GID) paxRecords.uid = String(header.uid);
+	if (header.gid != null && header.gid > USTAR_MAX_UID_GID) paxRecords.gid = String(header.gid);
+	if (header.size != null && header.size > USTAR_MAX_SIZE) paxRecords.size = String(header.size);
+	if (header.pax) Object.assign(paxRecords, header.pax);
+	const paxEntries = Object.entries(paxRecords);
+	if (paxEntries.length === 0) return null;
+	const paxBody = encoder.encode(paxEntries.map(([key, value]) => {
+		const record = `${key}=${value}\n`;
+		const partLength = encoder.encode(record).length + 1;
+		let totalLength = partLength + String(partLength).length;
+		totalLength = partLength + String(totalLength).length;
+		return `${totalLength} ${record}`;
+	}).join(""));
+	return {
+		paxHeader: createTarHeader({
+			name: decoder.decode(encoder.encode(`PaxHeader/${header.name}`).slice(0, 100)),
+			size: paxBody.length,
+			type: "pax-header",
+			mode: 420,
+			mtime: header.mtime,
+			uname: header.uname,
+			gname: header.gname,
+			uid: header.uid,
+			gid: header.gid
+		}),
+		paxBody
+	};
 }
+function findUstarSplit(path) {
+	if (path.length <= USTAR.name.size) return null;
+	const minSlashIndex = path.length - USTAR.name.size - 1;
+	const slashIndex = path.lastIndexOf("/", USTAR.prefix.size);
+	if (slashIndex > 0 && slashIndex >= minSlashIndex) return {
+		prefix: path.slice(0, slashIndex),
+		name: path.slice(slashIndex + 1)
+	};
+	return null;
+}
+
+//#endregion
+//#region src/web/pack.ts
 /**
 * Create a streaming tar packer.
 *
-* This function provides a controller-based API for creating tar archives, suitable
-* for scenarios where entries are generated dynamically or when you need control over
-* the packing process. The returned [`ReadableStream`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream)
+* Provides a controller-based API for creating tar archives, suitable for scenarios where entries are
+* generated dynamically. The returned [`ReadableStream`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream)
 * outputs tar archive bytes as entries are added.
 *
 * @returns Object containing the readable stream and controller
@@ -340,7 +425,7 @@ function createTarHeader(header) {
 *
 * @example
 * ```typescript
-* import { createTarPacker } from '@modern-tar/core';
+* import { createTarPacker } from 'modern-tar';
 *
 * const { readable, controller } = createTarPacker();
 *
@@ -382,31 +467,12 @@ function createTarPacker() {
 		controller: {
 			add(header) {
 				const size = header.type === "directory" || header.type === "symlink" || header.type === "link" ? 0 : header.size ?? 0;
-				if (header.pax) {
-					let paxRecords = "";
-					for (const [key, value] of Object.entries(header.pax)) {
-						const record = `${key}=${value}\n`;
-						let length = record.length + 1;
-						const lengthStr = String(length);
-						length += lengthStr.length;
-						const finalLengthStr = String(length);
-						if (finalLengthStr.length !== lengthStr.length) length += finalLengthStr.length - lengthStr.length;
-						paxRecords += `${length} ${record}`;
-					}
-					if (paxRecords) {
-						const paxBytes = encoder.encode(paxRecords);
-						const paxHeader = createTarHeader({
-							name: `PaxHeader/${header.name}`,
-							size: paxBytes.length,
-							type: "pax-header",
-							mode: 420,
-							mtime: header.mtime
-						});
-						streamController.enqueue(paxHeader);
-						streamController.enqueue(paxBytes);
-						const paxPadding = (BLOCK_SIZE - paxBytes.length % BLOCK_SIZE) % BLOCK_SIZE;
-						if (paxPadding > 0) streamController.enqueue(new Uint8Array(paxPadding));
-					}
+				const paxData = generatePax(header);
+				if (paxData) {
+					streamController.enqueue(paxData.paxHeader);
+					streamController.enqueue(paxData.paxBody);
+					const paxPadding = (BLOCK_SIZE - paxData.paxBody.length % BLOCK_SIZE) % BLOCK_SIZE;
+					if (paxPadding > 0) streamController.enqueue(new Uint8Array(paxPadding));
 				}
 				const headerBlock = createTarHeader({
 					...header,
@@ -448,137 +514,140 @@ function createTarPacker() {
 		}
 	};
 }
-
-//#endregion
-//#region src/web/stream.ts
-function parseHeader(block) {
-	let name = readString(block, USTAR.name.offset, USTAR.name.size);
-	if (readString(block, USTAR.magic.offset, USTAR.magic.size) === "ustar") {
-		const prefix = readString(block, USTAR.prefix.offset, USTAR.prefix.size);
-		if (prefix) name = `${prefix}/${name}`;
-	}
-	const typeFlag = readString(block, USTAR.typeflag.offset, USTAR.typeflag.size);
-	return {
-		name,
-		mode: readOctal(block, USTAR.mode.offset, USTAR.mode.size),
-		uid: readOctal(block, USTAR.uid.offset, USTAR.uid.size),
-		gid: readOctal(block, USTAR.gid.offset, USTAR.gid.size),
-		size: readOctal(block, USTAR.size.offset, USTAR.size.size),
-		mtime: /* @__PURE__ */ new Date(readOctal(block, USTAR.mtime.offset, USTAR.mtime.size) * 1e3),
-		type: FLAGTYPE[typeFlag] || "file",
-		linkname: readString(block, USTAR.linkname.offset, USTAR.linkname.size),
-		uname: readString(block, USTAR.uname.offset, USTAR.uname.size),
-		gname: readString(block, USTAR.gname.offset, USTAR.gname.size)
-	};
-}
-function parsePax(buffer) {
-	const pax = {};
-	let offset = 0;
-	while (offset < buffer.length) {
-		const spaceIndex = buffer.indexOf(32, offset);
-		if (spaceIndex === -1) break;
-		const lengthStr = decoder.decode(buffer.subarray(offset, spaceIndex));
-		const length = Number.parseInt(lengthStr, 10);
-		if (!length) break;
-		const recordEnd = offset + length;
-		const [key, value] = decoder.decode(buffer.subarray(spaceIndex + 1, recordEnd - 1)).split("=", 2);
-		if (key && value !== void 0) pax[key] = value;
-		offset = recordEnd;
+/**
+* Creates a 512-byte USTAR format tar header block from a TarHeader object.
+*/
+function createTarHeader(header) {
+	const view = new Uint8Array(BLOCK_SIZE);
+	const size = header.type === "directory" || header.type === "symlink" || header.type === "link" ? 0 : header.size ?? 0;
+	let name = header.name;
+	let prefix = "";
+	if (!header.pax?.path) {
+		const split = findUstarSplit(name);
+		if (split) {
+			name = split.name;
+			prefix = split.prefix;
+		}
 	}
-	return pax;
-}
-function applyPax(header, pax) {
-	header.name = pax.path ?? header.name;
-	header.linkname = pax.linkpath ?? header.linkname;
-	if (pax.size) header.size = Number.parseInt(pax.size, 10);
-	if (pax.mtime) header.mtime = /* @__PURE__ */ new Date(Number.parseFloat(pax.mtime) * 1e3);
-	if (pax.uid) header.uid = Number.parseInt(pax.uid, 10);
-	if (pax.gid) header.gid = Number.parseInt(pax.gid, 10);
-	header.uname = pax.uname ?? header.uname;
-	header.gname = pax.gname ?? header.gname;
-	header.pax = pax;
+	writeString(view, USTAR.name.offset, USTAR.name.size, name);
+	writeOctal(view, USTAR.mode.offset, USTAR.mode.size, header.mode ?? (header.type === "directory" ? DEFAULT_DIR_MODE : DEFAULT_FILE_MODE));
+	writeOctal(view, USTAR.uid.offset, USTAR.uid.size, header.uid ?? 0);
+	writeOctal(view, USTAR.gid.offset, USTAR.gid.size, header.gid ?? 0);
+	writeOctal(view, USTAR.size.offset, USTAR.size.size, size);
+	writeOctal(view, USTAR.mtime.offset, USTAR.mtime.size, Math.floor((header.mtime?.getTime() ?? Date.now()) / 1e3));
+	writeString(view, USTAR.typeflag.offset, USTAR.typeflag.size, TYPEFLAG[header.type ?? "file"]);
+	writeString(view, USTAR.linkname.offset, USTAR.linkname.size, header.linkname);
+	writeString(view, USTAR.magic.offset, USTAR.magic.size, "ustar\0");
+	writeString(view, USTAR.version.offset, USTAR.version.size, USTAR_VERSION);
+	writeString(view, USTAR.uname.offset, USTAR.uname.size, header.uname);
+	writeString(view, USTAR.gname.offset, USTAR.gname.size, header.gname);
+	writeString(view, USTAR.prefix.offset, USTAR.prefix.size, prefix);
+	writeChecksum(view);
+	return view;
 }
+
+//#endregion
+//#region src/web/unpack.ts
+const metaEntryParsers = {
+	"pax-global-header": parsePax,
+	"pax-header": parsePax,
+	"gnu-long-name": (data) => ({ name: readString(data, 0, data.length) }),
+	"gnu-long-link-name": (data) => ({ linkname: readString(data, 0, data.length) })
+};
 /**
-* Creates a TransformStream that parses a tar archive into ParsedTarEntry objects.
+* Create a transform stream that parses tar bytes into entries.
+*
+* @returns `TransformStream` that converts tar archive bytes to {@link ParsedTarEntry} objects.
+* @example
+* ```typescript
+* import { createTarDecoder } from 'modern-tar';
+*
+* const decoder = createTarDecoder();
+* const entriesStream = tarStream.pipeThrough(decoder);
+*
+* for await (const entry of entriesStream) {
+*  console.log(`Entry: ${entry.header.name}`);
+*  // Process entry.body stream as needed
+* }
 */
 function createTarDecoder() {
 	let buffer = new Uint8Array(0);
 	let currentEntry = null;
-	let pax = null;
-	let paxGlobal = {};
-	const closeEntryBody = () => {
-		try {
-			currentEntry?.controller.close();
-		} catch {}
-	};
+	let paxGlobals = {};
+	let nextEntryOverrides = {};
 	return new TransformStream({
 		transform(chunk, controller) {
 			const combined = new Uint8Array(buffer.length + chunk.length);
 			combined.set(buffer);
 			combined.set(chunk, buffer.length);
+			buffer = combined;
 			let offset = 0;
 			while (true) {
-				const remainingBytes = combined.length - offset;
 				if (currentEntry) {
-					const toWrite = combined.subarray(offset, offset + Math.min(remainingBytes, currentEntry.bytesLeft));
+					const toWrite = buffer.subarray(offset, offset + Math.min(buffer.length - offset, currentEntry.bytesLeft));
 					currentEntry.controller.enqueue(toWrite);
 					currentEntry.bytesLeft -= toWrite.length;
 					offset += toWrite.length;
 					if (currentEntry.bytesLeft === 0) {
 						const padding = (BLOCK_SIZE - currentEntry.header.size % BLOCK_SIZE) % BLOCK_SIZE;
-						if (remainingBytes - toWrite.length < padding) break;
-						closeEntryBody();
+						if (buffer.length - offset < padding) break;
+						try {
+							currentEntry?.controller.close();
+						} catch {}
 						offset += padding;
 						currentEntry = null;
 					} else break;
 				}
-				if (remainingBytes < BLOCK_SIZE) break;
-				const headerBlock = combined.subarray(offset, offset + BLOCK_SIZE);
+				if (buffer.length - offset < BLOCK_SIZE) break;
+				const headerBlock = buffer.subarray(offset, offset + BLOCK_SIZE);
 				if (headerBlock.every((b) => b === 0)) {
-					controller.terminate();
-					return;
-				}
-				const header = parseHeader(headerBlock);
-				offset += BLOCK_SIZE;
-				if (header.type === "pax-header" || header.type === "pax-global-header") {
-					const totalPaxSize = header.size + (BLOCK_SIZE - header.size % BLOCK_SIZE) % BLOCK_SIZE;
-					if (combined.length - offset < totalPaxSize) {
-						offset -= BLOCK_SIZE;
-						break;
+					if (buffer.length - offset < BLOCK_SIZE * 2) break;
+					if (buffer.subarray(offset + BLOCK_SIZE, offset + BLOCK_SIZE * 2).every((b) => b === 0)) {
+						controller.terminate();
+						return;
 					}
-					const parsedPax = parsePax(combined.subarray(offset, offset + header.size));
-					if (header.type === "pax-header") pax = parsedPax;
-					else paxGlobal = {
-						...paxGlobal,
-						...parsedPax
+				}
+				const header = parseUstarHeader(headerBlock);
+				const metaParser = metaEntryParsers[header.type];
+				if (metaParser) {
+					const dataSize = header.size;
+					const dataBlocksSize = Math.ceil(dataSize / BLOCK_SIZE) * BLOCK_SIZE;
+					if (buffer.length - offset - BLOCK_SIZE < dataBlocksSize) break;
+					const data = buffer.subarray(offset + BLOCK_SIZE, offset + BLOCK_SIZE + dataSize);
+					const overrides = metaParser(data);
+					if (header.type === "pax-global-header") paxGlobals = {
+						...paxGlobals,
+						...overrides
+					};
+					else nextEntryOverrides = {
+						...nextEntryOverrides,
+						...overrides
 					};
-					offset += totalPaxSize;
+					offset += BLOCK_SIZE + dataBlocksSize;
 					continue;
 				}
-				const combinedPax = {
-					...paxGlobal,
-					...pax
-				};
-				if (pax || Object.keys(paxGlobal).length > 0) {
-					applyPax(header, combinedPax);
-					pax = null;
-				}
+				const finalHeader = header;
+				applyOverrides(finalHeader, paxGlobals);
+				applyOverrides(finalHeader, nextEntryOverrides);
+				if (header.prefix && header.magic === "ustar" && !nextEntryOverrides.name && !paxGlobals.name) finalHeader.name = `${header.prefix}/${finalHeader.name}`;
+				nextEntryOverrides = {};
 				let bodyController;
 				const body = new ReadableStream({ start: (c) => bodyController = c });
 				controller.enqueue({
-					header,
+					header: finalHeader,
 					body
 				});
-				if (header.size > 0) currentEntry = {
-					header,
-					bytesLeft: header.size,
+				offset += BLOCK_SIZE;
+				if (finalHeader.size > 0) currentEntry = {
+					header: finalHeader,
+					bytesLeft: finalHeader.size,
 					controller: bodyController
 				};
 				else try {
 					bodyController.close();
 				} catch {}
 			}
-			buffer = combined.subarray(offset);
+			if (offset > 0) buffer = buffer.slice(offset);
 		},
 		flush(controller) {
 			if (currentEntry) {
@@ -590,6 +659,84 @@ function createTarDecoder() {
 		}
 	});
 }
+function parseUstarHeader(block) {
+	if (!validateChecksum(block)) throw new Error("Invalid tar header checksum.");
+	const typeflag = readString(block, USTAR.typeflag.offset, USTAR.typeflag.size);
+	return {
+		name: readString(block, USTAR.name.offset, USTAR.name.size),
+		mode: readOctal(block, USTAR.mode.offset, USTAR.mode.size),
+		uid: readNumeric(block, USTAR.uid.offset, USTAR.uid.size),
+		gid: readNumeric(block, USTAR.gid.offset, USTAR.gid.size),
+		size: readNumeric(block, USTAR.size.offset, USTAR.size.size),
+		mtime: /* @__PURE__ */ new Date(readNumeric(block, USTAR.mtime.offset, USTAR.mtime.size) * 1e3),
+		checksum: readOctal(block, USTAR.checksum.offset, USTAR.checksum.size),
+		type: FLAGTYPE[typeflag] || "file",
+		linkname: readString(block, USTAR.linkname.offset, USTAR.linkname.size),
+		magic: readString(block, USTAR.magic.offset, USTAR.magic.size),
+		uname: readString(block, USTAR.uname.offset, USTAR.uname.size),
+		gname: readString(block, USTAR.gname.offset, USTAR.gname.size),
+		prefix: readString(block, USTAR.prefix.offset, USTAR.prefix.size)
+	};
+}
+function parsePax(buffer) {
+	const overrides = {};
+	const pax = {};
+	let offset = 0;
+	while (offset < buffer.length) {
+		const spaceIndex = buffer.indexOf(32, offset);
+		if (spaceIndex === -1) break;
+		const length = Number.parseInt(decoder.decode(buffer.subarray(offset, spaceIndex)), 10);
+		if (Number.isNaN(length) || length === 0) break;
+		const recordEnd = offset + length;
+		const [key, value] = decoder.decode(buffer.subarray(spaceIndex + 1, recordEnd - 1)).split("=", 2);
+		if (key && value !== void 0) {
+			pax[key] = value;
+			switch (key) {
+				case "path":
+					overrides.name = value;
+					break;
+				case "linkpath":
+					overrides.linkname = value;
+					break;
+				case "size":
+					overrides.size = Number.parseInt(value, 10);
+					break;
+				case "mtime":
+					overrides.mtime = Number.parseFloat(value);
+					break;
+				case "uid":
+					overrides.uid = Number.parseInt(value, 10);
+					break;
+				case "gid":
+					overrides.gid = Number.parseInt(value, 10);
+					break;
+				case "uname":
+					overrides.uname = value;
+					break;
+				case "gname":
+					overrides.gname = value;
+					break;
+			}
+		}
+		offset = recordEnd;
+	}
+	if (Object.keys(pax).length > 0) overrides.pax = pax;
+	return overrides;
+}
+function applyOverrides(header, overrides) {
+	if (overrides.name !== void 0) header.name = overrides.name;
+	if (overrides.linkname !== void 0) header.linkname = overrides.linkname;
+	if (overrides.size !== void 0) header.size = overrides.size;
+	if (overrides.mtime !== void 0) header.mtime = /* @__PURE__ */ new Date(overrides.mtime * 1e3);
+	if (overrides.uid !== void 0) header.uid = overrides.uid;
+	if (overrides.gid !== void 0) header.gid = overrides.gid;
+	if (overrides.uname !== void 0) header.uname = overrides.uname;
+	if (overrides.gname !== void 0) header.gname = overrides.gname;
+	if (overrides.pax) header.pax = {
+		...header.pax ?? {},
+		...overrides.pax
+	};
+}
 
 //#endregion
 //#region src/web/helpers.ts
@@ -602,7 +749,7 @@ function createTarDecoder() {
 * @returns A `Promise` that resolves to the complete tar archive as a Uint8Array
 * @example
 * ```typescript
-* import { packTar } from '@modern-tar/core';
+* import { packTar } from 'modern-tar';
 *
 * const entries = [
 *   {
@@ -642,16 +789,18 @@ async function packTar(entries) {
 			else if (body instanceof Blob) await body.stream().pipeTo(entryStream);
 			else {
 				let chunk;
-				if (typeof body === "string") chunk = encoder.encode(body);
+				if (body === null || body === void 0) chunk = new Uint8Array(0);
 				else if (body instanceof Uint8Array) chunk = body;
-				else chunk = new Uint8Array(body);
+				else if (body instanceof ArrayBuffer) chunk = new Uint8Array(body);
+				else if (typeof body === "string") chunk = encoder.encode(body);
+				else throw new TypeError(`Unsupported content type for entry "${entry.header.name}". Expected string, Uint8Array, ArrayBuffer, Blob, ReadableStream, or undefined.`);
 				const writer = entryStream.getWriter();
 				await writer.write(chunk);
 				await writer.close();
 			}
 		}
 	})().then(() => controller.finalize()).catch((err) => controller.error(err));
-	const buffer = await new Response(readable).arrayBuffer();
+	const buffer = await streamToBuffer(readable);
 	await packingPromise;
 	return new Uint8Array(buffer);
 }
@@ -665,7 +814,7 @@ async function packTar(entries) {
 * @returns A `Promise` that resolves to an array of entries with buffered data
 * @example
 * ```typescript
-* import { unpackTar } from '@modern-tar/core';
+* import { unpackTar } from '@modern-tar';
 *
 * // From a file upload or fetch
 * const response = await fetch('/api/archive.tar');
@@ -709,7 +858,7 @@ async function unpackTar(archive, options = {}) {
 		while (true) {
 			const { done, value: entry } = await reader.read();
 			if (done) break;
-			const data = new Uint8Array(await new Response(entry.body).arrayBuffer());
+			const data = await streamToBuffer(entry.body);
 			results.push({
 				header: entry.header,
 				data
@@ -722,4 +871,4 @@ async function unpackTar(archive, options = {}) {
 }
 
 //#endregion
-export { BLOCK_SIZE, createGzipDecoder, createGzipEncoder, createTarDecoder, createTarHeader, createTarOptionsTransformer, createTarPacker, packTar, unpackTar };
+export { BLOCK_SIZE, createGzipDecoder, createGzipEncoder, createTarDecoder, createTarHeader, createTarOptionsTransformer, createTarPacker, encoder, generatePax, packTar, unpackTar };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "modern-tar",
-	"version": "0.2.2",
+	"version": "0.3.0",
 	"description": "Zero dependency streaming tar parser and writer for JavaScript.",
 	"author": "Ayuhito <hello@ayuhito.com>",
 	"license": "MIT",
@@ -26,6 +26,7 @@
 	"devDependencies": {
 		"@biomejs/biome": "2.2.4",
 		"@types/node": "^24.5.2",
+		"@vitest/coverage-v8": "^3.2.4",
 		"tsdown": "^0.15.4",
 		"typescript": "^5.9.2",
 		"vitest": "^3.2.4"
@@ -34,6 +35,7 @@
 		"build": "tsdown",
 		"dev": "tsdown --watch",
 		"test": "vitest",
+		"coverage": "vitest run --coverage",
 		"check": "biome check --write",
 		"typecheck": "tsc --noEmit"
 	},