neozipkit 1.0.5 → 1.5.1

package/src/browser/zstd-browser-shim.ts

@@ -1,63 +1,143 @@
 /**
- * Browser stub for ZSTD — native zlib streaming is Node-only.
- * Browser builds alias `ZstdNode` to this module so the bad WASM codec is never shipped.
+ * Browser zstd codec for in-memory buffers.
+ * Uses CompressionStream / DecompressionStream ('zstd') so the old WASM codec stays out.
+ * Node builds use src/node/ZstdNode.ts (native zlib) instead of this file.
  */
 
-const ZSTD_BROWSER_UNSUPPORTED =
-  'ZSTD requires Node.js with native zlib support (Node.js >= 22.15 or >= 23.8). ' +
-  'Browser builds do not include a zstd codec; use Deflate or process zstd archives in Node.';
+import { Buffer } from 'buffer';
 
-function unsupported(): never {
-  throw new Error(ZSTD_BROWSER_UNSUPPORTED);
+/** Bytes accepted by the buffer zstd codec. */
+export type ZstdInput = Buffer | Uint8Array | ArrayBuffer;
+
+const ZSTD_UNAVAILABLE =
+  'This browser does not expose CompressionStream zstd. ' +
+  'Use a current Chromium or Safari, or inflate the archive in Node.';
+
+function asBytes(data: ZstdInput): Uint8Array {
+  if (data instanceof ArrayBuffer) return new Uint8Array(data);
+  return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+}
+
+function toBuffer(bytes: Uint8Array): Buffer {
+  return Buffer.from(bytes);
 }
 
 export function isNativeZstdAvailable(): boolean {
-  return false;
+  try {
+    if (typeof CompressionStream === 'undefined' || typeof DecompressionStream === 'undefined') {
+      return false;
+    }
+    // 'zstd' is not in the older CompressionFormat union.
+    new CompressionStream('zstd' as CompressionFormat);
+    new DecompressionStream('zstd' as CompressionFormat);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function mapCompressionLevel(level: number): number {
+  return Math.min(Math.max(1, Math.floor(level * 2.1)), 19);
 }
 
-export function mapCompressionLevel(_level: number): number {
-  return unsupported();
+function assertZstd(): void {
+  if (!isNativeZstdAvailable()) {
+    throw new Error(ZSTD_UNAVAILABLE);
+  }
+}
+
+async function transformZstd(data: Uint8Array, mode: 'compress' | 'decompress'): Promise<Uint8Array> {
+  assertZstd();
+  const Stream = mode === 'compress' ? CompressionStream : DecompressionStream;
+  const stream = new Stream('zstd' as CompressionFormat);
+  const copy = new Uint8Array(data.byteLength);
+  copy.set(data);
+  const writer = stream.writable.getWriter();
+  await writer.write(copy);
+  await writer.close();
+  const reader = stream.readable.getReader();
+  const chunks: Uint8Array[] = [];
+  let total = 0;
+  for (;;) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    if (value) {
+      chunks.push(value);
+      total += value.byteLength;
+    }
+  }
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    out.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return out;
 }
 
 export function createCompressTransform(_level?: number): never {
-  return unsupported();
+  throw new Error('Browser zstd uses buffer compress(); Node zlib transforms are not available.');
 }
 
 export function createDecompressTransform(): never {
-  return unsupported();
+  throw new Error('Browser zstd uses buffer decompress(); Node zlib transforms are not available.');
+}
+
+export async function compress(data: ZstdInput, _level?: number): Promise<Buffer> {
+  return toBuffer(await transformZstd(asBytes(data), 'compress'));
+}
+
+export async function decompress(data: ZstdInput): Promise<Buffer> {
+  return toBuffer(await transformZstd(asBytes(data), 'decompress'));
 }
 
-export async function compress(_data: Buffer, _level?: number): Promise<Buffer> {
-  return unsupported();
+export function compressSync(_data: ZstdInput, _level?: number): Buffer {
+  throw new Error('Browser zstd compress is async. Use compress().');
 }
 
-export async function decompress(_data: Buffer): Promise<Buffer> {
-  return unsupported();
+export function compressSyncAtLevel(data: ZstdInput, _zstdLevel?: number): Buffer {
+  return compressSync(data);
 }
 
-export function compressSync(_data: Buffer, _level?: number): Buffer {
-  return unsupported();
+export function decompressSync(_data: ZstdInput): Buffer {
+  throw new Error('Browser zstd decompress is async. Use decompress().');
 }
 
-export function decompressSync(_data: Buffer): Buffer {
-  return unsupported();
+export function asZstdBuffer(data: ZstdInput): Buffer {
+  return toBuffer(asBytes(data));
 }
 
 export async function compressChunks(
-  _readChunk: (position: number, size: number) => Buffer,
-  _totalSize: number,
-  _chunkSize: number,
-  _level: number,
+  readChunk: (position: number, size: number) => Buffer,
+  totalSize: number,
+  chunkSize: number,
+  level: number,
   _onPlainChunk?: (chunk: Buffer) => void,
-  _onCompressedChunk?: (chunk: Buffer) => void | Promise<void>
+  onCompressedChunk?: (chunk: Buffer) => void | Promise<void>
 ): Promise<number> {
-  return unsupported();
+  const parts: Buffer[] = [];
+  let position = 0;
+  while (position < totalSize) {
+    const size = Math.min(chunkSize, totalSize - position);
+    const chunk = readChunk(position, size);
+    parts.push(Buffer.from(chunk));
+    position += chunk.length;
+  }
+  const compressed = await compress(Buffer.concat(parts), level);
+  if (onCompressedChunk) {
+    await onCompressedChunk(compressed);
+  }
+  return compressed.length;
 }
 
 export async function* decompressStream(
-  _compressedStream: AsyncIterable<Buffer>
+  compressedStream: AsyncIterable<Buffer>
 ): AsyncGenerator<Buffer> {
-  unsupported();
+  const parts: Buffer[] = [];
+  for await (const chunk of compressedStream) {
+    parts.push(Buffer.from(chunk));
+  }
+  yield await decompress(Buffer.concat(parts));
 }
 
 export const ZstdNode = {
@@ -68,7 +148,9 @@ export const ZstdNode = {
   compress,
   decompress,
   compressSync,
+  compressSyncAtLevel,
   decompressSync,
+  asZstdBuffer,
   compressChunks,
   decompressStream,
 };

package/src/core/ZipCompress.ts

@@ -35,6 +35,12 @@ export interface CompressOptions {
   useSHA256?: boolean;        // Whether to calculate SHA256 hash default is false
   useZstd?: boolean;          // Use Zstandard (method 93); default false (Deflate). Node ≥ 22.15 required when true.
   bufferSize?: number;        // Override default buffer size
+  /**
+   * Force APPNOTE Zip64 Version 1 even when sizes/offsets/counts fit classic fields.
+   * Useful for testing Zip64 read/list/integrity without multi-GiB payloads.
+   * Node streaming writers emit Zip64 EOCD + locator and per-member Extra `0x0001`.
+   */
+  forceZip64?: boolean;
 }
 
 /**

package/src/core/ZipCopy.ts

@@ -10,7 +10,14 @@
 
 import ZipEntry from './ZipEntry';
 import Zipkit from './Zipkit';
-import { LOCAL_HDR, CENTRAL_END, GP_FLAG } from './constants/Headers';
+import { LOCAL_HDR, GP_FLAG } from './constants/Headers';
+import {
+  assertBufferAllowsEntryZip64,
+  buildEndRecords,
+  dataDescriptorByteLength,
+  needsZip64SizeOrOffset,
+  ZIP64_BUFFER_SIZE_OFFSET_ERROR,
+} from './zip64/Zip64';
 
 /**
  * Options for copying ZIP files
@@ -174,9 +181,19 @@ export class ZipCopy {
     const localHeaderSize = this.calculateLocalHeaderSize(sourceBuffer, entry);
     
     // Determine total entry size
-    // For data descriptor entries, add 16 bytes for the data descriptor
+    // For data descriptor entries, add Zip64 (24) or classic (16) descriptor bytes
     const hasDataDescriptor = (entry.bitFlags & GP_FLAG.DATA_DESC) !== 0;
-    const totalEntrySize = localHeaderSize + entry.compressedSize + (hasDataDescriptor ? 16 : 0);
+    const descLen = hasDataDescriptor
+      ? dataDescriptorByteLength(entry.usesZip64Extra)
+      : 0;
+    const totalEntrySize = localHeaderSize + entry.compressedSize + descLen;
+
+    // Buffer copy must remain memory-feasible
+    assertBufferAllowsEntryZip64(
+      entry.uncompressedSize,
+      entry.compressedSize,
+      entry.localHdrOffset
+    );
 
     // Verify we have enough data in the buffer
     if (entry.localHdrOffset + totalEntrySize > sourceBuffer.length) {
@@ -264,6 +281,17 @@ export class ZipCopy {
     cloned.originalEntry = entry.originalEntry;
     cloned.inode = entry.inode;
 
+    cloned.usesZip64Extra = entry.usesZip64Extra;
+    if (entry.additionalExtra) {
+      cloned.additionalExtra = Buffer.from(entry.additionalExtra);
+    }
+    cloned.aesVersion = entry.aesVersion;
+    cloned.aesStrength = entry.aesStrength;
+    cloned.realCmpMethod = entry.realCmpMethod;
+    cloned.neoCryptoPayloadVersion = entry.neoCryptoPayloadVersion;
+    cloned.neoCryptoAlgorithm = entry.neoCryptoAlgorithm;
+    cloned.neoCryptoFlags = entry.neoCryptoFlags;
+
     return cloned;
   }
 
@@ -276,6 +304,19 @@ export class ZipCopy {
     zipComment: string,
     centralDirOffset: number
   ): Buffer {
+    if (
+      needsZip64SizeOrOffset(0, 0, 0, 0, centralDirOffset) ||
+      entries.some((e) =>
+        needsZip64SizeOrOffset(
+          e.uncompressedSize,
+          e.compressedSize,
+          e.localHdrOffset
+        )
+      )
+    ) {
+      throw new Error(ZIP64_BUFFER_SIZE_OFFSET_ERROR);
+    }
+
     const centralDirChunks: Buffer[] = [];
     for (const entry of entries) {
       centralDirChunks.push(entry.centralDirEntry());
@@ -283,32 +324,20 @@ export class ZipCopy {
     const centralDirBuffer = Buffer.concat(centralDirChunks);
     const centralDirSize = centralDirBuffer.length;
 
-    const commentBytes = Buffer.from(zipComment, 'utf8');
-    const commentLength = Math.min(commentBytes.length, 0xffff);
-
-    const eocdBuffer = Buffer.alloc(22 + commentLength);
-    let pos = 0;
-    eocdBuffer.writeUInt32LE(CENTRAL_END.SIGNATURE, pos);
-    pos += 4;
-    eocdBuffer.writeUInt16LE(0, pos);
-    pos += 2;
-    eocdBuffer.writeUInt16LE(0, pos);
-    pos += 2;
-    eocdBuffer.writeUInt16LE(entries.length, pos);
-    pos += 2;
-    eocdBuffer.writeUInt16LE(entries.length, pos);
-    pos += 2;
-    eocdBuffer.writeUInt32LE(centralDirSize, pos);
-    pos += 4;
-    eocdBuffer.writeUInt32LE(centralDirOffset, pos);
-    pos += 4;
-    eocdBuffer.writeUInt16LE(commentLength, pos);
-    pos += 2;
-    if (commentLength > 0) {
-      commentBytes.copy(eocdBuffer, pos, 0, commentLength);
+    if (needsZip64SizeOrOffset(0, 0, 0, centralDirSize, centralDirOffset)) {
+      throw new Error(ZIP64_BUFFER_SIZE_OFFSET_ERROR);
     }
 
-    return Buffer.concat([centralDirBuffer, eocdBuffer]);
+    const endRecords = buildEndRecords({
+      totalEntries: entries.length,
+      centralDirSize,
+      centralDirOffset,
+      zip64EocdOffset: centralDirOffset + centralDirSize,
+      archiveComment: zipComment,
+      allowSizeOffsetZip64: false,
+    });
+
+    return Buffer.concat([centralDirBuffer, endRecords]);
   }
 
   /**

package/src/core/ZipEntry.ts

@@ -24,6 +24,17 @@ import {
 import { ZipFileEntry, FileData } from '../types';
 import { Logger } from './components/Logger';
 import { crc32 } from './encryption/ZipCrypto';
+import {
+  ZIP64_U16,
+  ZIP64_U32,
+  ZIP64_VERSION_NEEDED,
+  buildZip64Extra,
+  exceedsU16,
+  exceedsU32,
+  needsZip64Entry,
+  parseZip64Extra,
+  stripZip64FromExtra,
+} from './zip64/Zip64';
 
 const VER_ENCODING = 30;
 const VER_EXTRACT = 10;                             // Version needed to extract (1.0)
@@ -49,6 +60,15 @@ export default class ZipEntry implements ZipFileEntry {
   localHdrOffset: number = 0;   // Relative offset to local header from File/Disk start
   filename: string = '';       // File name
   extraField: Buffer | null = null; // Extra field
+  /**
+   * Caller-supplied extra-field records (complete header id + size + payload).
+   * Written on the local header and the central-directory header beside 0x014E.
+   * Unknown ids parsed from an existing header (including ZipWiki 0x014F) are kept here
+   * so a later header rebuild does not drop them.
+   */
+  additionalExtra: Buffer | null = null;
+  /** When false, local/central headers omit the Info-ZIP Unicode Path extra. */
+  emitUnicodePath = true;
   comment: string | null = null;    // Entry comment
 
   // File Data
@@ -100,6 +120,14 @@ export default class ZipEntry implements ZipFileEntry {
   originalEntry: string | null = null; // Original entry name for hard links
   inode: number | null = null;      // Inode number for hard links
 
+  /** True when Zip64 extra (0x0001) was applied or will be emitted (8-byte data descriptors). */
+  usesZip64Extra: boolean = false;
+  /**
+   * When true, emit Zip64 Extra Field `0x0001` and version-needed 45 even if
+   * sizes/offsets fit classic u16/u32 fields (APPNOTE MAY; for testing).
+   */
+  forceZip64: boolean = false;
+
   fileData?: FileData;
 
   /**
@@ -306,6 +334,31 @@ export default class ZipEntry implements ZipFileEntry {
               this.neoCryptoFlags = _data.readUInt16LE(7);
             }
           }
+        } else if (_id === HDR_ID.ZIP64) {
+          const z64 = parseZip64Extra(_data, {
+            uncompressedSize: this.uncompressedSize,
+            compressedSize: this.compressedSize,
+            localHdrOffset: this.localHdrOffset,
+            diskStart: this.volNumber,
+          });
+          this.usesZip64Extra = true;
+          if (z64.uncompressedSize !== undefined) {
+            this.uncompressedSize = z64.uncompressedSize;
+          }
+          if (z64.compressedSize !== undefined) {
+            this.compressedSize = z64.compressedSize;
+          }
+          if (z64.localHdrOffset !== undefined) {
+            this.localHdrOffset = z64.localHdrOffset;
+          }
+          if (z64.diskStart !== undefined) {
+            this.volNumber = z64.diskStart;
+          }
+        } else if (_id !== HDR_ID.UNICODE_PATH) {
+          const rec = Buffer.from(this.extraField.subarray(i, i + 4 + _len));
+          this.additionalExtra = this.additionalExtra
+            ? Buffer.concat([this.additionalExtra, rec])
+            : rec;
         }
         // Skip Unicode Path here as we already processed it
         i += 4 + _len;
@@ -330,10 +383,30 @@ export default class ZipEntry implements ZipFileEntry {
    * @returns true if the filename contains non-ASCII characters or special characters
    */
   needsUnicodeHandling(): boolean {
+    if (!this.emitUnicodePath) return false;
     // Check if filename contains non-ASCII characters or special characters like apostrophes
     return /[^\x00-\x7E]|['"]/.test(this.filename);
   }
 
+  /** Version needed to extract. Method 93 (zstd) is 6.3; Zip64 is 4.5. */
+  private versionNeededToExtract(): number {
+    let ver = VER_EXTRACT;
+    if (this.cmpMethod === CMP_METHOD.AES_ENCRYPT) ver = VER_AES_EXTRACT;
+    else if (this.cmpMethod === CMP_METHOD.ZSTD) ver = 63;
+    if (
+      this.forceZip64 ||
+      needsZip64Entry(
+        this.uncompressedSize,
+        this.compressedSize,
+        this.localHdrOffset,
+        this.volNumber
+      )
+    ) {
+      ver = Math.max(ver, ZIP64_VERSION_NEEDED);
+    }
+    return ver;
+  }
+
   /**
    * Adds UTF-8 Unicode Path field to a buffer
    * @param buffer - The buffer to write to
@@ -389,13 +462,38 @@ export default class ZipEntry implements ZipFileEntry {
     if (isNeoEncrypt) {
       extraFieldLen += NEO_CRYPTO_EXTRA_FIELD_SIZE;
     }
+
+    const sha256Local = this.sha256 ? Buffer.from(this.sha256, 'hex') : null;
+    const sha256LocalLen = sha256Local && sha256Local.length > 0 ? 4 + sha256Local.length : 0;
+    const callerExtra = stripZip64FromExtra(this.additionalExtra);
+    const callerExtraLen = callerExtra?.length ?? 0;
+
+    const useZip64Sizes =
+      this.forceZip64 ||
+      exceedsU32(this.uncompressedSize) ||
+      exceedsU32(this.compressedSize);
+    if (useZip64Sizes) {
+      this.usesZip64Extra = true;
+    }
+    const zip64LocalExtra = useZip64Sizes
+      ? buildZip64Extra(
+          {
+            uncompressedSize: this.uncompressedSize,
+            compressedSize: this.compressedSize,
+          },
+          { forLocal: true }
+        )
+      : null;
+    const zip64LocalLen = zip64LocalExtra?.length ?? 0;
+
+    extraFieldLen += sha256LocalLen + callerExtraLen + zip64LocalLen;
     
     const data = Buffer.alloc(LOCAL_HDR.SIZE + this.filename.length + extraFieldLen);
     
     // "PK\003\004"
     data.writeUInt32LE(LOCAL_HDR.SIGNATURE, 0);
     // version needed to extract (NeoEncrypt keeps standard ZIP method — use normal extract version)
-    const verExtract = this.cmpMethod === CMP_METHOD.AES_ENCRYPT ? VER_AES_EXTRACT : VER_EXTRACT;
+    const verExtract = this.versionNeededToExtract();
     data.writeUInt16LE(verExtract, LOCAL_HDR.VER_EXTRACT);
     // general purpose bit flag
     data.writeUInt16LE(this.bitFlags >>> 0, LOCAL_HDR.FLAGS);
@@ -405,10 +503,15 @@ export default class ZipEntry implements ZipFileEntry {
     data.writeUInt32LE(this.timeDateDOS >>> 0, LOCAL_HDR.TIMEDATE_DOS);
     // uncompressed file crc-32 value (AE-2 stores 0)
     data.writeUInt32LE(this.aesVersion === 2 ? 0 : this.crc, LOCAL_HDR.CRC);
-    // compressed size
-    data.writeUInt32LE(this.compressedSize, LOCAL_HDR.CMP_SIZE);
-    // uncompressed size
-    data.writeUInt32LE(this.uncompressedSize, LOCAL_HDR.UNCMP_SIZE);
+    // compressed / uncompressed sizes (Zip64 sentinels when needed)
+    data.writeUInt32LE(
+      useZip64Sizes ? ZIP64_U32 : this.compressedSize,
+      LOCAL_HDR.CMP_SIZE
+    );
+    data.writeUInt32LE(
+      useZip64Sizes ? ZIP64_U32 : this.uncompressedSize,
+      LOCAL_HDR.UNCMP_SIZE
+    );
     // filename length
     data.writeUInt16LE(this.filename.length, LOCAL_HDR.FNAME_LEN);
     // extra field length
@@ -427,6 +530,12 @@ export default class ZipEntry implements ZipFileEntry {
       extraOffset = this.addUnicodePathField(data, extraOffset);
     }
 
+    // Zip64 sizes first among optional extras so Node can patch them by scanning
+    if (zip64LocalExtra) {
+      zip64LocalExtra.copy(data, extraOffset);
+      extraOffset += zip64LocalLen;
+    }
+
     // Add AES extra field
     if (isAes) {
       data.writeUInt16LE(HDR_ID.AES, extraOffset);
@@ -452,6 +561,17 @@ export default class ZipEntry implements ZipFileEntry {
       extraOffset += NEO_CRYPTO_EXTRA_FIELD_SIZE;
     }
 
+    if (sha256Local && sha256LocalLen > 0) {
+      data.writeUInt16LE(HDR_ID.SHA256, extraOffset);
+      data.writeUInt16LE(sha256Local.length, extraOffset + 2);
+      sha256Local.copy(data, extraOffset + 4);
+      extraOffset += sha256LocalLen;
+    }
+
+    if (callerExtra && callerExtraLen > 0) {
+      callerExtra.copy(data, extraOffset);
+    }
+
     return data;
   }
 
@@ -492,7 +612,45 @@ export default class ZipEntry implements ZipFileEntry {
     const isNeoEncrypt = this.neoCryptoAlgorithm > 0;
     const neoLen = isNeoEncrypt ? NEO_CRYPTO_EXTRA_FIELD_SIZE : 0;
 
-    const extraLen = utfLen + sha256Len + uidgidLen + symlinkLen + hardlinkLen + (needsUnicode ? unicodePathLen : 0) + aesLen + neoLen;
+    const callerExtra = stripZip64FromExtra(this.additionalExtra);
+    const callerExtraLen = callerExtra?.length ?? 0;
+
+    const zip64Fields: {
+      uncompressedSize?: number;
+      compressedSize?: number;
+      localHdrOffset?: number;
+      diskStart?: number;
+    } = {};
+    if (this.forceZip64 || exceedsU32(this.uncompressedSize)) {
+      zip64Fields.uncompressedSize = this.uncompressedSize;
+    }
+    if (this.forceZip64 || exceedsU32(this.compressedSize)) {
+      zip64Fields.compressedSize = this.compressedSize;
+    }
+    if (this.forceZip64 || exceedsU32(this.localHdrOffset)) {
+      zip64Fields.localHdrOffset = this.localHdrOffset;
+    }
+    if (exceedsU16(this.volNumber)) {
+      zip64Fields.diskStart = this.volNumber;
+    }
+    const zip64CentralExtra =
+      Object.keys(zip64Fields).length > 0 ? buildZip64Extra(zip64Fields) : null;
+    if (zip64CentralExtra) {
+      this.usesZip64Extra = true;
+    }
+    const zip64CentralLen = zip64CentralExtra?.length ?? 0;
+
+    const extraLen =
+      utfLen +
+      sha256Len +
+      uidgidLen +
+      symlinkLen +
+      hardlinkLen +
+      (needsUnicode ? unicodePathLen : 0) +
+      aesLen +
+      neoLen +
+      callerExtraLen +
+      zip64CentralLen;
 
     // Calculate actual filename length (ASCII conversion may change length)
     const asciiName = this.filename.replace(/[^\x00-\x7E]/g, '?');
@@ -506,7 +664,7 @@ export default class ZipEntry implements ZipFileEntry {
     // Version made by - Needs to be set for NeoZip 
     data.writeUInt16LE(this.isUpdated ? this.VER_MADE_BY : this.verMadeBy, CENTRAL_DIR.VER_MADE);
     // Version needed to extract
-    const centralVerExtract = this.cmpMethod === CMP_METHOD.AES_ENCRYPT ? VER_AES_EXTRACT : VER_EXTRACT;
+    const centralVerExtract = this.versionNeededToExtract();
     data.writeInt16LE(this.isUpdated ? centralVerExtract : this.verMadeBy, CENTRAL_DIR.VER_EXT);
     // Encrypt, Decrypt Flags
     data.writeInt16LE(this.bitFlags >>> 0, CENTRAL_DIR.FLAGS);
@@ -516,10 +674,15 @@ export default class ZipEntry implements ZipFileEntry {
     data.writeUInt32LE(this.timeDateDOS >>> 0, CENTRAL_DIR.TIMEDATE_DOS);
     // Uncompressed file CRC-32 value (AE-2 stores 0)
     data.writeUInt32LE(this.aesVersion === 2 ? 0 : this.crc, CENTRAL_DIR.CRC);
-    // Compressed Size
-    data.writeUInt32LE(this.compressedSize, CENTRAL_DIR.CMP_SIZE);
-    // Uncompressed Size
-    data.writeUInt32LE(this.uncompressedSize, CENTRAL_DIR.UNCMP_SIZE);
+    // Compressed / uncompressed sizes and local offset (Zip64 sentinels when needed)
+    data.writeUInt32LE(
+      zip64Fields.compressedSize !== undefined ? ZIP64_U32 : this.compressedSize,
+      CENTRAL_DIR.CMP_SIZE
+    );
+    data.writeUInt32LE(
+      zip64Fields.uncompressedSize !== undefined ? ZIP64_U32 : this.uncompressedSize,
+      CENTRAL_DIR.UNCMP_SIZE
+    );
     // Filename Length
     data.writeUInt16LE(this.filename.length, CENTRAL_DIR.FNAME_LEN);
     // Extra Field Length
@@ -527,13 +690,19 @@ export default class ZipEntry implements ZipFileEntry {
     // File Comment Length
     data.writeUInt16LE(commentLen, CENTRAL_DIR.COMMENT_LEN);
     // Volume Number Start
-    data.writeUInt16LE(0, CENTRAL_DIR.DISK_NUM);
+    data.writeUInt16LE(
+      zip64Fields.diskStart !== undefined ? ZIP64_U16 : this.volNumber,
+      CENTRAL_DIR.DISK_NUM
+    );
     // Internal File Attributes
     data.writeUInt16LE(this.intFileAttr >>> 0, CENTRAL_DIR.INT_FILE_ATTR);
     // External File Attributes
     data.writeUInt32LE(this.extFileAttr >>> 0, CENTRAL_DIR.EXT_FILE_ATTR);
     // Local Header Offset
-    data.writeUInt32LE(this.localHdrOffset, CENTRAL_DIR.LOCAL_HDR_OFFSET);
+    data.writeUInt32LE(
+      zip64Fields.localHdrOffset !== undefined ? ZIP64_U32 : this.localHdrOffset,
+      CENTRAL_DIR.LOCAL_HDR_OFFSET
+    );
 
     // Write filename - use ASCII filename (replacing non-ASCII with ?)
     // This ensures compatibility with older ZIP readers
@@ -551,6 +720,12 @@ export default class ZipEntry implements ZipFileEntry {
     // Add Extra Field data after file comment
     let extraOffset = currentOffset;
 
+    // Zip64 extended information (sizes / offset / disk)
+    if (zip64CentralExtra) {
+      zip64CentralExtra.copy(data, extraOffset);
+      extraOffset += zip64CentralLen;
+    }
+
     // Add Universal Time field
     if (this.universalTime) {
       data.writeUInt16LE(HDR_ID.UNV_TIME, extraOffset);     // 0x5455
@@ -637,6 +812,10 @@ export default class ZipEntry implements ZipFileEntry {
       extraOffset += NEO_CRYPTO_EXTRA_FIELD_SIZE;
     }
 
+    if (callerExtra && callerExtraLen > 0) {
+      callerExtra.copy(data, extraOffset);
+    }
+
     return data;
   }