@push.rocks/smartarchive 5.2.3 → 5.3.0

package/ts_shared/classes.ziptools.ts

@@ -1,50 +1,488 @@
-import * as plugins from './plugins.js';
-import type { IArchiveEntry, TCompressionLevel } from './interfaces.js';
+import * as plugins from './plugins.ziptools.js';
+import { ZIP_ERROR_CODES, ZipError } from './errors.js';
+import type {
+  IArchiveEntry,
+  IExtractedZipEntry,
+  ISelectiveZipExtractionOptions,
+  IZipEntryInfo,
+  TCompressionLevel,
+} from './interfaces.js';
 
-/**
- * Transform stream for ZIP decompression using fflate
- * Emits StreamFile objects for each file in the archive
- */
-export class ZipDecompressionTransform extends plugins.smartstream.SmartDuplex<Uint8Array, plugins.smartfile.StreamFile> {
-  private streamtools!: plugins.smartstream.IStreamTools;
-  private unzipper = new plugins.fflate.Unzip(async (fileArg) => {
-    let resultBuffer: Uint8Array;
-    fileArg.ondata = async (_flateError, dat, final) => {
-      if (resultBuffer) {
-        const combined = new Uint8Array(resultBuffer.length + dat.length);
-        combined.set(resultBuffer);
-        combined.set(dat, resultBuffer.length);
-        resultBuffer = combined;
-      } else {
-        resultBuffer = new Uint8Array(dat);
+const ZIP_LOCAL_FILE_HEADER_SIGNATURE = 0x04034b50;
+const ZIP_CENTRAL_DIRECTORY_SIGNATURE = 0x02014b50;
+const ZIP_END_OF_CENTRAL_DIRECTORY_SIGNATURE = 0x06054b50;
+const ZIP64_END_OF_CENTRAL_DIRECTORY_LOCATOR_SIGNATURE = 0x07064b50;
+const ZIP_DATA_DESCRIPTOR_SIGNATURE = 0x08074b50;
+const ZIP64_EXTRA_FIELD_ID = 0x0001;
+const ZIP_UNICODE_PATH_EXTRA_FIELD_ID = 0x7075;
+const ZIP_ALLOWED_GENERAL_PURPOSE_FLAGS = 0x080e;
+const PAKO_INPUT_CHUNK_BYTES = 16 * 1024;
+const PAKO_OUTPUT_CHUNK_BYTES = 16 * 1024;
+
+interface IParsedZipEntry {
+  path: string;
+  rawPath: Uint8Array;
+  flags: number;
+  compressionMethod: number;
+  crc32: number;
+  compressedSize: number;
+  uncompressedSize: number;
+  localHeaderOffset: number;
+  dataStart: number;
+  dataEnd: number;
+  localRecordEnd: number;
+  isDirectory: boolean;
+}
+
+interface IZipEndRecord {
+  offset: number;
+  entryCount: number;
+  centralDirectoryOffset: number;
+  centralDirectorySize: number;
+}
+
+const crc32Table = (() => {
+  const table = new Uint32Array(256);
+  for (let index = 0; index < table.length; index++) {
+    let value = index;
+    for (let bit = 0; bit < 8; bit++) {
+      value = value & 1 ? 0xedb88320 ^ (value >>> 1) : value >>> 1;
+    }
+    table[index] = value >>> 0;
+  }
+  return table;
+})();
+
+function throwInvalidZip(message: string): never {
+  throw new ZipError(message, ZIP_ERROR_CODES.INVALID_ARCHIVE);
+}
+
+function throwUnsupportedZip(message: string): never {
+  throw new ZipError(message, ZIP_ERROR_CODES.UNSUPPORTED_FEATURE);
+}
+
+function checkedEnd(data: Uint8Array, offset: number, length: number): number {
+  const end = offset + length;
+  if (
+    !Number.isSafeInteger(offset) ||
+    !Number.isSafeInteger(length) ||
+    offset < 0 ||
+    length < 0 ||
+    !Number.isSafeInteger(end) ||
+    end > data.length
+  ) {
+    throwInvalidZip('ZIP record extends beyond the archive');
+  }
+  return end;
+}
+
+function readUint16(data: Uint8Array, offset: number): number {
+  checkedEnd(data, offset, 2);
+  return data[offset] | (data[offset + 1] << 8);
+}
+
+function readUint32(data: Uint8Array, offset: number): number {
+  checkedEnd(data, offset, 4);
+  return (
+    data[offset] |
+    (data[offset + 1] << 8) |
+    (data[offset + 2] << 16) |
+    (data[offset + 3] << 24)
+  ) >>> 0;
+}
+
+function equalBytes(first: Uint8Array, second: Uint8Array): boolean {
+  if (first.length !== second.length) return false;
+  for (let index = 0; index < first.length; index++) {
+    if (first[index] !== second[index]) return false;
+  }
+  return true;
+}
+
+function validateExtraFields(data: Uint8Array, offset: number, length: number): void {
+  const end = checkedEnd(data, offset, length);
+  let cursor = offset;
+  while (cursor < end) {
+    if (cursor + 4 > end) {
+      throwInvalidZip('ZIP extra field header is truncated');
+    }
+    const fieldId = readUint16(data, cursor);
+    const fieldLength = readUint16(data, cursor + 2);
+    cursor += 4;
+    if (cursor + fieldLength > end) {
+      throwInvalidZip('ZIP extra field data is truncated');
+    }
+    if (fieldId === ZIP64_EXTRA_FIELD_ID) {
+      throwUnsupportedZip('ZIP64 entries are not supported by bounded extraction');
+    }
+    if (fieldId === ZIP_UNICODE_PATH_EXTRA_FIELD_ID) {
+      throwUnsupportedZip('ZIP Unicode path extra fields are not supported by bounded extraction');
+    }
+    cursor += fieldLength;
+  }
+}
+
+function decodeZipPath(rawPath: Uint8Array, flags: number): string {
+  if (!rawPath.length) {
+    throwInvalidZip('ZIP entry path is empty');
+  }
+
+  let path: string;
+  if (flags & 0x0800) {
+    try {
+      path = new TextDecoder('utf-8', { fatal: true }).decode(rawPath);
+    } catch {
+      throwInvalidZip('ZIP entry path is not valid UTF-8');
+    }
+  } else {
+    if (rawPath.some(byte => byte > 0x7f)) {
+      throwUnsupportedZip('ZIP entry paths without the UTF-8 flag must be ASCII');
+    }
+    path = new TextDecoder().decode(rawPath);
+  }
+
+  if (path.includes('\0')) {
+    throwInvalidZip('ZIP entry path contains a NUL byte');
+  }
+  if (path.includes('\\') || path.startsWith('/') || /^[A-Za-z]:/.test(path)) {
+    throwInvalidZip('ZIP entry path is not relative');
+  }
+
+  const isDirectory = path.endsWith('/');
+  const pathSegments = path.split('/');
+  if (isDirectory) pathSegments.pop();
+  if (
+    !pathSegments.length ||
+    pathSegments.some(segment => !segment || segment === '.' || segment === '..')
+  ) {
+    throwInvalidZip('ZIP entry path contains an invalid segment');
+  }
+
+  return path;
+}
+
+function findZipEndRecord(data: Uint8Array, maxEntries: number): IZipEndRecord {
+  if (data.length < 22) {
+    throwInvalidZip('ZIP end record is missing');
+  }
+
+  const candidates: number[] = [];
+  const earliestOffset = Math.max(0, data.length - 22 - 0xffff);
+  for (let offset = data.length - 22; offset >= earliestOffset; offset--) {
+    if (readUint32(data, offset) !== ZIP_END_OF_CENTRAL_DIRECTORY_SIGNATURE) continue;
+    const commentLength = readUint16(data, offset + 20);
+    if (offset + 22 + commentLength === data.length) {
+      candidates.push(offset);
+    }
+  }
+
+  if (candidates.length !== 1) {
+    throwInvalidZip(
+      candidates.length ? 'ZIP end record is ambiguous' : 'ZIP end record is missing',
+    );
+  }
+
+  const offset = candidates[0];
+  const diskNumber = readUint16(data, offset + 4);
+  const centralDirectoryDisk = readUint16(data, offset + 6);
+  const entriesOnDisk = readUint16(data, offset + 8);
+  const entryCount = readUint16(data, offset + 10);
+  const centralDirectorySize = readUint32(data, offset + 12);
+  const centralDirectoryOffset = readUint32(data, offset + 16);
+
+  if (
+    diskNumber === 0xffff ||
+    centralDirectoryDisk === 0xffff ||
+    entriesOnDisk === 0xffff ||
+    entryCount === 0xffff ||
+    centralDirectorySize === 0xffffffff ||
+    centralDirectoryOffset === 0xffffffff
+  ) {
+    throwUnsupportedZip('ZIP64 archives are not supported by bounded extraction');
+  }
+  if (diskNumber !== 0 || centralDirectoryDisk !== 0 || entriesOnDisk !== entryCount) {
+    throwUnsupportedZip('Split ZIP archives are not supported by bounded extraction');
+  }
+  if (
+    offset >= 20 &&
+    readUint32(data, offset - 20) === ZIP64_END_OF_CENTRAL_DIRECTORY_LOCATOR_SIGNATURE
+  ) {
+    throwUnsupportedZip('ZIP64 archives are not supported by bounded extraction');
+  }
+  if (entryCount > maxEntries) {
+    throw new ZipError(
+      `ZIP contains ${entryCount} entries, exceeding the configured limit`,
+      ZIP_ERROR_CODES.ENTRY_COUNT_LIMIT,
+    );
+  }
+
+  const centralDirectoryEnd = checkedEnd(
+    data,
+    centralDirectoryOffset,
+    centralDirectorySize,
+  );
+  if (centralDirectoryEnd !== offset) {
+    throwInvalidZip('ZIP central directory range is inconsistent');
+  }
+
+  return {
+    offset,
+    entryCount,
+    centralDirectoryOffset,
+    centralDirectorySize,
+  };
+}
+
+function validateGeneralPurposeFlags(flags: number, compressionMethod: number): void {
+  if (flags & ~ZIP_ALLOWED_GENERAL_PURPOSE_FLAGS) {
+    throwUnsupportedZip('ZIP entry uses unsupported general-purpose flags');
+  }
+  if (compressionMethod !== 8 && flags & 0x0006) {
+    throwUnsupportedZip('ZIP compression flags are only supported for DEFLATE entries');
+  }
+}
+
+function parseDataDescriptor(
+  data: Uint8Array,
+  dataEnd: number,
+  centralDirectoryOffset: number,
+  entry: Pick<IParsedZipEntry, 'crc32' | 'compressedSize' | 'uncompressedSize'>,
+): number {
+  const candidates: number[] = [];
+
+  const matchesDescriptorAt = (offset: number): number | null => {
+    if (offset + 12 > centralDirectoryOffset) return null;
+    if (
+      readUint32(data, offset) !== entry.crc32 ||
+      readUint32(data, offset + 4) !== entry.compressedSize ||
+      readUint32(data, offset + 8) !== entry.uncompressedSize
+    ) {
+      return null;
+    }
+    return offset + 12;
+  };
+
+  const unsignedEnd = matchesDescriptorAt(dataEnd);
+  if (unsignedEnd !== null) candidates.push(unsignedEnd);
+
+  if (
+    dataEnd + 4 <= centralDirectoryOffset &&
+    readUint32(data, dataEnd) === ZIP_DATA_DESCRIPTOR_SIGNATURE
+  ) {
+    const signedEnd = matchesDescriptorAt(dataEnd + 4);
+    if (signedEnd !== null) candidates.push(signedEnd);
+  }
+
+  if (candidates.length !== 1) {
+    throwInvalidZip(
+      candidates.length
+        ? 'ZIP data descriptor is ambiguous'
+        : 'ZIP data descriptor does not match the central directory',
+    );
+  }
+  return candidates[0];
+}
+
+function parseZipEntries(data: Uint8Array, maxEntries: number): IParsedZipEntry[] {
+  const endRecord = findZipEndRecord(data, maxEntries);
+  const centralDirectoryEnd =
+    endRecord.centralDirectoryOffset + endRecord.centralDirectorySize;
+  const entries: IParsedZipEntry[] = [];
+  const localOffsets = new Set<number>();
+  let cursor = endRecord.centralDirectoryOffset;
+
+  for (let entryIndex = 0; entryIndex < endRecord.entryCount; entryIndex++) {
+    if (readUint32(data, cursor) !== ZIP_CENTRAL_DIRECTORY_SIGNATURE) {
+      throwInvalidZip('ZIP central directory entry signature is invalid');
+    }
+    checkedEnd(data, cursor, 46);
+
+    const versionNeeded = readUint16(data, cursor + 6);
+    const flags = readUint16(data, cursor + 8);
+    const compressionMethod = readUint16(data, cursor + 10);
+    const modificationTime = readUint16(data, cursor + 12);
+    const modificationDate = readUint16(data, cursor + 14);
+    const crc32 = readUint32(data, cursor + 16);
+    const compressedSize = readUint32(data, cursor + 20);
+    const uncompressedSize = readUint32(data, cursor + 24);
+    const pathLength = readUint16(data, cursor + 28);
+    const extraLength = readUint16(data, cursor + 30);
+    const commentLength = readUint16(data, cursor + 32);
+    const diskNumberStart = readUint16(data, cursor + 34);
+    const localHeaderOffset = readUint32(data, cursor + 42);
+
+    if (
+      compressedSize === 0xffffffff ||
+      uncompressedSize === 0xffffffff ||
+      diskNumberStart === 0xffff ||
+      localHeaderOffset === 0xffffffff
+    ) {
+      throwUnsupportedZip('ZIP64 entries are not supported by bounded extraction');
+    }
+    if (diskNumberStart !== 0) {
+      throwUnsupportedZip('Split ZIP entries are not supported by bounded extraction');
+    }
+    validateGeneralPurposeFlags(flags, compressionMethod);
+    if (compressionMethod === 0 || compressionMethod === 8) {
+      const minimumVersion = compressionMethod === 8 || (flags & 0x0008) !== 0 ? 20 : 10;
+      if (versionNeeded < minimumVersion) {
+        throwInvalidZip('ZIP entry declares an insufficient extraction version');
       }
-      if (final) {
-        const streamFile = plugins.smartfile.StreamFile.fromBuffer(Buffer.from(resultBuffer));
-        streamFile.relativeFilePath = fileArg.name;
-        this.streamtools.push(streamFile);
+      if (versionNeeded > 20) {
+        throwUnsupportedZip('ZIP entry requires features outside the bounded subset');
       }
-    };
-    fileArg.start();
-  });
-
-  constructor() {
-    super({
-      objectMode: true,
-      writeFunction: async (chunkArg, streamtoolsArg) => {
-        this.streamtools ? null : (this.streamtools = streamtoolsArg);
-        const chunk = chunkArg instanceof Uint8Array ? chunkArg : new Uint8Array(chunkArg);
-        this.unzipper.push(chunk, false);
-        return null;
-      },
-      finalFunction: async () => {
-        this.unzipper.push(new Uint8Array(0), true);
-        await plugins.smartdelay.delayFor(0);
-        await this.streamtools.push(null);
-        return null;
-      },
+    }
+    if (compressionMethod === 0 && compressedSize !== uncompressedSize) {
+      throwInvalidZip('ZIP stored entry has inconsistent sizes');
+    }
+
+    const pathOffset = cursor + 46;
+    const extraOffset = checkedEnd(data, pathOffset, pathLength);
+    const commentOffset = checkedEnd(data, extraOffset, extraLength);
+    const nextCursor = checkedEnd(data, commentOffset, commentLength);
+    if (nextCursor > centralDirectoryEnd) {
+      throwInvalidZip('ZIP central directory entry exceeds the central directory');
+    }
+
+    const rawPath = data.subarray(pathOffset, extraOffset);
+    const path = decodeZipPath(rawPath, flags);
+    validateExtraFields(data, extraOffset, extraLength);
+
+    if (localOffsets.has(localHeaderOffset)) {
+      throwInvalidZip('ZIP entries reference the same local header');
+    }
+    localOffsets.add(localHeaderOffset);
+    if (localHeaderOffset >= endRecord.centralDirectoryOffset) {
+      throwInvalidZip('ZIP local header intersects the central directory');
+    }
+    if (readUint32(data, localHeaderOffset) !== ZIP_LOCAL_FILE_HEADER_SIGNATURE) {
+      throwInvalidZip('ZIP local file header signature is invalid');
+    }
+    checkedEnd(data, localHeaderOffset, 30);
+
+    const localVersionNeeded = readUint16(data, localHeaderOffset + 4);
+    const localFlags = readUint16(data, localHeaderOffset + 6);
+    const localCompressionMethod = readUint16(data, localHeaderOffset + 8);
+    const localModificationTime = readUint16(data, localHeaderOffset + 10);
+    const localModificationDate = readUint16(data, localHeaderOffset + 12);
+    const localCrc32 = readUint32(data, localHeaderOffset + 14);
+    const localCompressedSize = readUint32(data, localHeaderOffset + 18);
+    const localUncompressedSize = readUint32(data, localHeaderOffset + 22);
+    const localPathLength = readUint16(data, localHeaderOffset + 26);
+    const localExtraLength = readUint16(data, localHeaderOffset + 28);
+    const localPathOffset = localHeaderOffset + 30;
+    const localExtraOffset = checkedEnd(data, localPathOffset, localPathLength);
+    const dataStart = checkedEnd(data, localExtraOffset, localExtraLength);
+    const dataEnd = checkedEnd(data, dataStart, compressedSize);
+
+    if (dataEnd > endRecord.centralDirectoryOffset) {
+      throwInvalidZip('ZIP local file data intersects the central directory');
+    }
+    if (
+      localVersionNeeded !== versionNeeded ||
+      localFlags !== flags ||
+      localCompressionMethod !== compressionMethod ||
+      localModificationTime !== modificationTime ||
+      localModificationDate !== modificationDate
+    ) {
+      throwInvalidZip('ZIP local and central entry metadata differ');
+    }
+    const localRawPath = data.subarray(localPathOffset, localExtraOffset);
+    if (!equalBytes(localRawPath, rawPath)) {
+      throwInvalidZip('ZIP local and central entry paths differ');
+    }
+    validateExtraFields(data, localExtraOffset, localExtraLength);
+
+    let localRecordEnd = dataEnd;
+    if (flags & 0x0008) {
+      if (localCrc32 !== 0 || localCompressedSize !== 0 || localUncompressedSize !== 0) {
+        throwInvalidZip('ZIP data-descriptor entry has non-zero local size metadata');
+      }
+      localRecordEnd = parseDataDescriptor(data, dataEnd, endRecord.centralDirectoryOffset, {
+        crc32,
+        compressedSize,
+        uncompressedSize,
+      });
+    } else if (
+      localCrc32 !== crc32 ||
+      localCompressedSize !== compressedSize ||
+      localUncompressedSize !== uncompressedSize
+    ) {
+      throwInvalidZip('ZIP local sizes or CRC differ from the central directory');
+    }
+
+    entries.push({
+      path,
+      rawPath,
+      flags,
+      compressionMethod,
+      crc32,
+      compressedSize,
+      uncompressedSize,
+      localHeaderOffset,
+      dataStart,
+      dataEnd,
+      localRecordEnd,
+      isDirectory: path.endsWith('/'),
     });
-    this.unzipper.register(plugins.fflate.UnzipInflate);
+    cursor = nextCursor;
+  }
+
+  if (cursor !== centralDirectoryEnd) {
+    throwUnsupportedZip('ZIP central directory signatures are not supported by bounded extraction');
+  }
+
+  const entriesByLocalOffset = [...entries].sort(
+    (first, second) => first.localHeaderOffset - second.localHeaderOffset,
+  );
+  for (let index = 1; index < entriesByLocalOffset.length; index++) {
+    if (
+      entriesByLocalOffset[index - 1].localRecordEnd >
+      entriesByLocalOffset[index].localHeaderOffset
+    ) {
+      throwInvalidZip('ZIP local file records overlap');
+    }
+  }
+
+  return entries;
+}
+
+function validateSelectiveOptions(options: ISelectiveZipExtractionOptions): void {
+  if (!options || typeof options.filter !== 'function') {
+    throw new ZipError('ZIP extraction filter must be a function', ZIP_ERROR_CODES.INVALID_LIMIT);
+  }
+  const limits = [
+    options.maxArchiveBytes,
+    options.maxEntries,
+    options.maxSelectedEntries,
+    options.maxCompressedEntryBytes,
+    options.maxUncompressedEntryBytes,
+    options.maxTotalUncompressedBytes,
+  ];
+  if (limits.some(limit => !Number.isSafeInteger(limit) || limit < 1)) {
+    throw new ZipError(
+      'ZIP extraction limits must be positive safe integers',
+      ZIP_ERROR_CODES.INVALID_LIMIT,
+    );
+  }
+}
+
+function updateCrc32(crc: number, data: Uint8Array): number {
+  let nextCrc = crc;
+  for (const byte of data) {
+    nextCrc = crc32Table[(nextCrc ^ byte) & 0xff] ^ (nextCrc >>> 8);
+  }
+  return nextCrc >>> 0;
+}
+
+function combineChunks(chunks: Uint8Array[], byteLength: number): Uint8Array {
+  const result = new Uint8Array(byteLength);
+  let offset = 0;
+  for (const chunk of chunks) {
+    result.set(chunk, offset);
+    offset += chunk.length;
   }
+  return result;
 }
 
 /**
@@ -52,10 +490,216 @@ export class ZipDecompressionTransform extends plugins.smartstream.SmartDuplex<U
  */
 export class ZipTools {
   /**
-   * Get a streaming decompression transform for extracting ZIP archives
+   * Extract selected entries from a strict, bounded ZIP subset.
+   *
+   * This security-focused API accepts single-disk, non-ZIP64 archives and
+   * decompresses only entries selected from validated central-directory metadata.
    */
-  public getDecompressionStream(): ZipDecompressionTransform {
-    return new ZipDecompressionTransform();
+  public async extractSelectedZipEntries(
+    data: Uint8Array,
+    options: ISelectiveZipExtractionOptions,
+  ): Promise<IExtractedZipEntry[]> {
+    validateSelectiveOptions(options);
+    if (!(data instanceof Uint8Array)) {
+      throw new ZipError('ZIP archive must be a Uint8Array', ZIP_ERROR_CODES.INVALID_ARCHIVE);
+    }
+    if (data.length > options.maxArchiveBytes) {
+      throw new ZipError(
+        `ZIP archive has ${data.length} bytes, exceeding the configured limit`,
+        ZIP_ERROR_CODES.ARCHIVE_SIZE_LIMIT,
+      );
+    }
+
+    const entries = parseZipEntries(data, options.maxEntries);
+    const selectedEntries: IParsedZipEntry[] = [];
+    const selectedPaths = new Set<string>();
+    let declaredTotalUncompressedBytes = 0;
+
+    for (const entry of entries) {
+      const entryInfo: IZipEntryInfo = {
+        path: entry.path,
+        size: entry.uncompressedSize,
+        compressedSize: entry.compressedSize,
+        compressionMethod: entry.compressionMethod,
+        isDirectory: entry.isDirectory,
+        isFile: !entry.isDirectory,
+      };
+      if (!options.filter(entryInfo)) continue;
+
+      if (selectedPaths.has(entry.path)) {
+        throw new ZipError(
+          `ZIP contains duplicate selected path: ${entry.path}`,
+          ZIP_ERROR_CODES.DUPLICATE_SELECTED_PATH,
+        );
+      }
+      selectedPaths.add(entry.path);
+      if (selectedEntries.length >= options.maxSelectedEntries) {
+        throw new ZipError(
+          'ZIP selected entry count exceeds the configured limit',
+          ZIP_ERROR_CODES.SELECTED_ENTRY_COUNT_LIMIT,
+        );
+      }
+      if (entry.compressedSize > options.maxCompressedEntryBytes) {
+        throw new ZipError(
+          `ZIP selected entry ${entry.path} exceeds the compressed-size limit`,
+          ZIP_ERROR_CODES.COMPRESSED_SIZE_LIMIT,
+        );
+      }
+      if (entry.uncompressedSize > options.maxUncompressedEntryBytes) {
+        throw new ZipError(
+          `ZIP selected entry ${entry.path} exceeds the uncompressed-size limit`,
+          ZIP_ERROR_CODES.UNCOMPRESSED_SIZE_LIMIT,
+        );
+      }
+      if (
+        entry.uncompressedSize >
+        options.maxTotalUncompressedBytes - declaredTotalUncompressedBytes
+      ) {
+        throw new ZipError(
+          'ZIP selected entries exceed the total uncompressed-size limit',
+          ZIP_ERROR_CODES.TOTAL_UNCOMPRESSED_SIZE_LIMIT,
+        );
+      }
+      if (entry.compressionMethod !== 0 && entry.compressionMethod !== 8) {
+        throw new ZipError(
+          `ZIP selected entry ${entry.path} uses unsupported compression method ${entry.compressionMethod}`,
+          ZIP_ERROR_CODES.UNSUPPORTED_FEATURE,
+        );
+      }
+
+      declaredTotalUncompressedBytes += entry.uncompressedSize;
+      selectedEntries.push(entry);
+    }
+
+    const extractedEntries: IExtractedZipEntry[] = [];
+    let actualTotalUncompressedBytes = 0;
+
+    for (const entry of selectedEntries) {
+      const compressedData = data.subarray(entry.dataStart, entry.dataEnd);
+      let content: Uint8Array;
+      let crcState = 0xffffffff;
+
+      if (entry.compressionMethod === 0) {
+        if (entry.compressedSize !== entry.uncompressedSize) {
+          throw new ZipError(
+            `ZIP stored entry ${entry.path} has inconsistent sizes`,
+            ZIP_ERROR_CODES.UNCOMPRESSED_SIZE_MISMATCH,
+          );
+        }
+        if (
+          entry.uncompressedSize >
+          options.maxTotalUncompressedBytes - actualTotalUncompressedBytes
+        ) {
+          throw new ZipError(
+            'ZIP selected entries exceed the total uncompressed-size limit',
+            ZIP_ERROR_CODES.TOTAL_UNCOMPRESSED_SIZE_LIMIT,
+          );
+        }
+        content = new Uint8Array(compressedData);
+        crcState = updateCrc32(crcState, content);
+        actualTotalUncompressedBytes += content.length;
+      } else {
+        const chunks: Uint8Array[] = [];
+        let actualEntryBytes = 0;
+        let zstream: plugins.pako.ZStream | undefined;
+        const inflater = new plugins.pako.Inflate({
+          raw: true,
+          chunkSize: PAKO_OUTPUT_CHUNK_BYTES,
+        });
+        inflater.onStart = (stream) => {
+          zstream = stream;
+        };
+        inflater.onData = (chunk) => {
+          if (chunk.length > entry.uncompressedSize - actualEntryBytes) {
+            throw new ZipError(
+              `ZIP selected entry ${entry.path} expands beyond its declared size`,
+              ZIP_ERROR_CODES.UNCOMPRESSED_SIZE_MISMATCH,
+            );
+          }
+          if (chunk.length > options.maxUncompressedEntryBytes - actualEntryBytes) {
+            throw new ZipError(
+              `ZIP selected entry ${entry.path} exceeds the uncompressed-size limit`,
+              ZIP_ERROR_CODES.UNCOMPRESSED_SIZE_LIMIT,
+            );
+          }
+          if (
+            chunk.length >
+            options.maxTotalUncompressedBytes - actualTotalUncompressedBytes
+          ) {
+            throw new ZipError(
+              'ZIP selected entries exceed the total uncompressed-size limit',
+              ZIP_ERROR_CODES.TOTAL_UNCOMPRESSED_SIZE_LIMIT,
+            );
+          }
+
+          const retainedChunk = chunk.slice();
+          chunks.push(retainedChunk);
+          crcState = updateCrc32(crcState, retainedChunk);
+          actualEntryBytes += retainedChunk.length;
+          actualTotalUncompressedBytes += retainedChunk.length;
+        };
+
+        let pushSucceeded = true;
+        let inputOffset = 0;
+        try {
+          do {
+            const inputEnd = Math.min(
+              inputOffset + PAKO_INPUT_CHUNK_BYTES,
+              compressedData.length,
+            );
+            pushSucceeded = inflater.push(
+              compressedData.subarray(inputOffset, inputEnd),
+              inputEnd === compressedData.length,
+            );
+            inputOffset = inputEnd;
+            if (!pushSucceeded) break;
+            if (inflater.ended && inputOffset < compressedData.length) {
+              throw new ZipError(
+                `ZIP selected entry ${entry.path} ended before consuming its compressed data`,
+                ZIP_ERROR_CODES.COMPRESSED_SIZE_MISMATCH,
+              );
+            }
+          } while (inputOffset < compressedData.length);
+        } catch (error) {
+          if (error instanceof ZipError) throw error;
+          throw new ZipError(
+            `ZIP selected entry ${entry.path} contains invalid DEFLATE data`,
+            ZIP_ERROR_CODES.INVALID_ARCHIVE,
+          );
+        }
+
+        if (!pushSucceeded || inflater.err || !inflater.ended || !zstream) {
+          throw new ZipError(
+            `ZIP selected entry ${entry.path} contains invalid or truncated DEFLATE data`,
+            ZIP_ERROR_CODES.INVALID_ARCHIVE,
+          );
+        }
+        if (zstream.avail_in !== 0 || zstream.total_in !== compressedData.length) {
+          throw new ZipError(
+            `ZIP selected entry ${entry.path} did not consume its exact compressed data`,
+            ZIP_ERROR_CODES.COMPRESSED_SIZE_MISMATCH,
+          );
+        }
+        if (actualEntryBytes !== entry.uncompressedSize) {
+          throw new ZipError(
+            `ZIP selected entry ${entry.path} did not produce its declared size`,
+            ZIP_ERROR_CODES.UNCOMPRESSED_SIZE_MISMATCH,
+          );
+        }
+        content = combineChunks(chunks, actualEntryBytes);
+      }
+
+      const actualCrc32 = (crcState ^ 0xffffffff) >>> 0;
+      if (actualCrc32 !== entry.crc32) {
+        throw new ZipError(
+          `ZIP selected entry ${entry.path} failed its CRC check`,
+          ZIP_ERROR_CODES.CRC_MISMATCH,
+        );
+      }
+      extractedEntries.push({ path: entry.path, content });
+    }
+
+    return extractedEntries;
   }
 
   /**
@@ -71,13 +715,8 @@ export class ZipTools {
         data = new TextEncoder().encode(entry.content);
       } else if (entry.content instanceof Uint8Array) {
         data = entry.content;
-      } else if (entry.content instanceof plugins.smartfile.SmartFile) {
-        data = new Uint8Array(entry.content.contents);
-      } else if (entry.content instanceof plugins.smartfile.StreamFile) {
-        const buffer = await entry.content.getContentAsBuffer();
-        data = new Uint8Array(buffer);
       } else {
-        throw new Error('Unsupported content type for ZIP entry');
+        throw new Error('Shared ZIP creation accepts string or Uint8Array content');
       }
 
       if (compressionLevel !== undefined) {