@fulmenhq/tsfulmen 0.3.2 → 0.4.0

package/dist/chunk-P3DNOZOG.js

@@ -0,0 +1,1488 @@
+import { __require } from './chunk-UP2VWCW5.js';
+import { existsSync, mkdirSync, statSync, createReadStream, createWriteStream, readdirSync, lstatSync } from 'fs';
+import { dirname, basename, join } from 'path';
+import { pipeline } from 'stream';
+import { createGunzip, createGzip } from 'zlib';
+import { TarArchive, ZipArchive } from 'archiver';
+
+// src/fulpack/errors.ts
+function createFulpackError(code, message, operation, context) {
+  return {
+    code,
+    message,
+    operation,
+    ...context?.path && { path: context.path },
+    ...context?.archive && { archive: context.archive },
+    ...context?.details && { details: context.details }
+  };
+}
+var ERROR_CODES = {
+  // Validation Errors
+  INVALID_ARCHIVE_FORMAT: "INVALID_ARCHIVE_FORMAT",
+  INVALID_PATH: "INVALID_PATH",
+  INVALID_OPTIONS: "INVALID_OPTIONS",
+  // Security Errors
+  PATH_TRAVERSAL: "PATH_TRAVERSAL",
+  ABSOLUTE_PATH: "ABSOLUTE_PATH",
+  SYMLINK_ESCAPE: "SYMLINK_ESCAPE",
+  DECOMPRESSION_BOMB: "DECOMPRESSION_BOMB",
+  CHECKSUM_MISMATCH: "CHECKSUM_MISMATCH",
+  // Runtime Errors
+  ARCHIVE_NOT_FOUND: "ARCHIVE_NOT_FOUND",
+  ARCHIVE_CORRUPT: "ARCHIVE_CORRUPT",
+  EXTRACTION_FAILED: "EXTRACTION_FAILED",
+  PERMISSION_DENIED: "PERMISSION_DENIED",
+  DISK_FULL: "DISK_FULL",
+  SOURCE_NOT_FOUND: "SOURCE_NOT_FOUND"
+};
+var FulpackOperationError = class extends Error {
+  code;
+  operation;
+  path;
+  archive;
+  details;
+  constructor(error) {
+    super(error.message);
+    this.name = "FulpackOperationError";
+    this.code = error.code;
+    this.operation = error.operation;
+    this.path = error.path;
+    this.archive = error.archive;
+    this.details = error.details;
+  }
+  /**
+   * Convert back to canonical error format
+   */
+  toCanonical() {
+    return {
+      code: this.code,
+      message: this.message,
+      operation: this.operation,
+      ...this.path && { path: this.path },
+      ...this.archive && { archive: this.archive },
+      ...this.details && { details: this.details }
+    };
+  }
+};
+function hasPathTraversal(path) {
+  return path.includes("..") || path.includes("\\..");
+}
+function isAbsolutePath(path) {
+  return path.startsWith("/") || /^[a-zA-Z]:/.test(path);
+}
+function validatePath(path, operation, allowAbsolute = false) {
+  if (!allowAbsolute && isAbsolutePath(path)) {
+    return createFulpackError(
+      ERROR_CODES.ABSOLUTE_PATH,
+      `Absolute path not allowed: ${path}`,
+      operation,
+      { path }
+    );
+  }
+  if (hasPathTraversal(path)) {
+    return createFulpackError(
+      ERROR_CODES.PATH_TRAVERSAL,
+      `Path traversal detected: ${path}`,
+      operation,
+      { path }
+    );
+  }
+  return null;
+}
+function checkDecompressionBomb(uncompressedSize, compressedSize, maxSize, maxEntries, currentEntries) {
+  if (uncompressedSize > maxSize) {
+    return createFulpackError(
+      ERROR_CODES.DECOMPRESSION_BOMB,
+      `Archive exceeds maximum size limit`,
+      "extract" /* EXTRACT */,
+      {
+        details: {
+          actual_size: uncompressedSize,
+          max_size: maxSize
+        }
+      }
+    );
+  }
+  if (currentEntries > maxEntries) {
+    return createFulpackError(
+      ERROR_CODES.DECOMPRESSION_BOMB,
+      `Archive exceeds maximum entry limit`,
+      "extract" /* EXTRACT */,
+      {
+        details: {
+          actual_size: currentEntries,
+          max_size: maxEntries
+        }
+      }
+    );
+  }
+  if (compressedSize > 0 && uncompressedSize / compressedSize > 100) {
+    return createFulpackError(
+      ERROR_CODES.DECOMPRESSION_BOMB,
+      `Suspicious compression ratio detected`,
+      "extract" /* EXTRACT */,
+      {
+        details: {
+          compression_ratio: uncompressedSize / compressedSize
+        }
+      }
+    );
+  }
+  return null;
+}
+
+// src/fulpack/core.ts
+var DEFAULTS = {
+  CREATE: {
+    compression_level: 6,
+    checksum_algorithm: "sha256",
+    preserve_permissions: true,
+    follow_symlinks: false
+  },
+  EXTRACT: {
+    overwrite: "error",
+    verify_checksums: true,
+    preserve_permissions: true,
+    max_size: 1024 * 1024 * 1024,
+    // 1GB
+    max_entries: 1e5
+  },
+  SCAN: {
+    include_metadata: true,
+    max_entries: 1e5
+  }
+};
+async function create(source, output, format, options) {
+  const opts = { ...DEFAULTS.CREATE, ...options };
+  const sources = Array.isArray(source) ? source : [source];
+  if (format !== "tar" /* TAR */ && format !== "tar.gz" /* TAR_GZ */ && format !== "zip" /* ZIP */ && format !== "gzip" /* GZIP */) {
+    throw new FulpackOperationError(
+      createFulpackError(
+        ERROR_CODES.INVALID_ARCHIVE_FORMAT,
+        `Format ${format} not yet supported`,
+        "create" /* CREATE */
+      )
+    );
+  }
+  const outputDir = dirname(output);
+  if (!existsSync(outputDir)) {
+    mkdirSync(outputDir, { recursive: true });
+  }
+  if (format === "zip" /* ZIP */) {
+    return await createZipArchive(sources, output, opts);
+  } else if (format === "tar.gz" /* TAR_GZ */) {
+    return await createTarGzArchive(sources, output, opts);
+  } else if (format === "tar" /* TAR */) {
+    return await createTarArchive(sources, output, opts);
+  } else if (format === "gzip" /* GZIP */) {
+    return await createGzipFile(sources, output, opts);
+  } else {
+    throw new FulpackOperationError(
+      createFulpackError(
+        ERROR_CODES.INVALID_ARCHIVE_FORMAT,
+        `Unsupported format for creation: ${format}`,
+        "create" /* CREATE */
+      )
+    );
+  }
+}
+async function extract(archive, destination, options) {
+  const opts = { ...DEFAULTS.EXTRACT, ...options };
+  if (!existsSync(archive)) {
+    throw new FulpackOperationError(
+      createFulpackError(
+        ERROR_CODES.ARCHIVE_NOT_FOUND,
+        `Archive not found: ${archive}`,
+        "extract" /* EXTRACT */,
+        { archive }
+      )
+    );
+  }
+  if (!existsSync(destination)) {
+    mkdirSync(destination, { recursive: true });
+  }
+  if (archive.endsWith(".tar.gz") || archive.endsWith(".tgz")) {
+    return await extractTarGz(archive, destination, opts);
+  } else if (archive.endsWith(".tar")) {
+    return await extractTar(archive, destination, opts);
+  } else if (archive.endsWith(".zip")) {
+    return await extractZip(archive, destination, opts);
+  } else if (archive.endsWith(".gz")) {
+    return await extractGzipFile(archive, destination, opts);
+  } else {
+    throw new FulpackOperationError(
+      createFulpackError(
+        ERROR_CODES.INVALID_ARCHIVE_FORMAT,
+        `Unsupported archive format for extraction: ${archive}`,
+        "extract" /* EXTRACT */,
+        { archive }
+      )
+    );
+  }
+}
+async function scan(archive, options) {
+  const opts = { ...DEFAULTS.SCAN, ...options };
+  if (!existsSync(archive)) {
+    throw new FulpackOperationError(
+      createFulpackError(
+        ERROR_CODES.ARCHIVE_NOT_FOUND,
+        `Archive not found: ${archive}`,
+        "scan" /* SCAN */,
+        { archive }
+      )
+    );
+  }
+  const filename = basename(archive);
+  if (filename.endsWith(".tar.gz") || filename.endsWith(".tgz")) {
+    return await scanTarGz(archive, opts);
+  } else if (filename.endsWith(".tar")) {
+    return await scanTar(archive, opts);
+  } else if (filename.endsWith(".zip")) {
+    return await scanZip(archive, opts);
+  } else if (filename.endsWith(".gz")) {
+    return await scanGzipFile(archive, opts);
+  } else {
+    throw new FulpackOperationError(
+      createFulpackError(
+        ERROR_CODES.INVALID_ARCHIVE_FORMAT,
+        `Unsupported archive format: ${filename}`,
+        "scan" /* SCAN */,
+        { archive }
+      )
+    );
+  }
+}
+async function verify(archive, _options) {
+  if (!existsSync(archive)) {
+    throw new FulpackOperationError(
+      createFulpackError(
+        ERROR_CODES.ARCHIVE_NOT_FOUND,
+        `Archive not found: ${archive}`,
+        "verify" /* VERIFY */,
+        { archive }
+      )
+    );
+  }
+  const stats = statSync(archive);
+  const errors = [];
+  const warnings = [];
+  const checks_performed = [];
+  let entry_count = 0;
+  let checksums_verified = 0;
+  checks_performed.push("structure_valid");
+  if (stats.size === 0) {
+    errors.push(
+      createFulpackError(ERROR_CODES.ARCHIVE_CORRUPT, "Archive file is empty", "verify" /* VERIFY */, {
+        archive
+      })
+    );
+    return {
+      valid: false,
+      errors,
+      warnings,
+      entry_count: 0,
+      checksums_verified: 0,
+      checks_performed
+    };
+  }
+  let entries;
+  try {
+    entries = await scan(archive, { include_metadata: true });
+    entry_count = entries.length;
+  } catch (error) {
+    errors.push(
+      createFulpackError(
+        ERROR_CODES.ARCHIVE_CORRUPT,
+        `Failed to scan archive: ${error instanceof Error ? error.message : String(error)}`,
+        "verify" /* VERIFY */,
+        { archive, details: { original_error: error } }
+      )
+    );
+    return {
+      valid: false,
+      errors,
+      warnings,
+      entry_count: 0,
+      checksums_verified: 0,
+      checks_performed
+    };
+  }
+  checks_performed.push("no_path_traversal");
+  for (const entry of entries) {
+    const pathError = validatePath(entry.path, "verify" /* VERIFY */, true);
+    if (pathError) {
+      errors.push({ ...pathError, archive });
+    }
+  }
+  const symlinks = entries.filter((e) => e.type === "symlink");
+  if (symlinks.length > 0) {
+    checks_performed.push("symlinks_safe");
+    for (const symlink of symlinks) {
+      if (symlink.symlink_target) {
+        const targetError = validatePath(symlink.symlink_target, "verify" /* VERIFY */, true);
+        if (targetError) {
+          errors.push(
+            createFulpackError(
+              ERROR_CODES.ARCHIVE_CORRUPT,
+              `Symlink '${symlink.path}' targets unsafe location: ${symlink.symlink_target}`,
+              "verify" /* VERIFY */,
+              { archive, path: symlink.path, details: { symlink_target: symlink.symlink_target } }
+            )
+          );
+        }
+      }
+    }
+  }
+  checks_performed.push("no_decompression_bomb");
+  const total_size = entries.reduce((sum, entry) => sum + (entry.size || 0), 0);
+  const compressed_size = stats.size;
+  const compression_ratio = total_size > 0 && compressed_size > 0 ? total_size / compressed_size : 1;
+  if (compression_ratio > 100) {
+    warnings.push(
+      `High compression ratio detected: ${compression_ratio.toFixed(1)}:1 (threshold: 100:1)`
+    );
+  }
+  const MAX_SIZE = 1024 * 1024 * 1024;
+  if (total_size > MAX_SIZE) {
+    warnings.push(
+      `Total uncompressed size (${(total_size / (1024 * 1024)).toFixed(1)}MB) exceeds recommended limit (1GB)`
+    );
+  }
+  const MAX_ENTRIES = 1e5;
+  if (entry_count > MAX_ENTRIES) {
+    warnings.push(`Entry count (${entry_count}) exceeds recommended limit (${MAX_ENTRIES})`);
+  }
+  const entriesWithChecksums = entries.filter((e) => e.checksum !== void 0);
+  if (entriesWithChecksums.length > 0) {
+    checks_performed.push("checksums_verified");
+    checksums_verified = entriesWithChecksums.length;
+  } else if (entry_count > 0) {
+    warnings.push("Archive does not contain checksums for integrity verification");
+  }
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings,
+    entry_count,
+    checksums_verified,
+    checks_performed
+  };
+}
+async function info(archive) {
+  if (!existsSync(archive)) {
+    throw new FulpackOperationError(
+      createFulpackError(
+        ERROR_CODES.ARCHIVE_NOT_FOUND,
+        `Archive not found: ${archive}`,
+        "info" /* INFO */,
+        { archive }
+      )
+    );
+  }
+  const stats = statSync(archive);
+  const filename = basename(archive);
+  let format;
+  let compression = "none";
+  if (filename.endsWith(".tar.gz") || filename.endsWith(".tgz")) {
+    format = "tar.gz" /* TAR_GZ */;
+    compression = "gzip";
+  } else if (filename.endsWith(".zip")) {
+    format = "zip" /* ZIP */;
+    compression = "deflate";
+  } else if (filename.endsWith(".gz")) {
+    format = "gzip" /* GZIP */;
+    compression = "gzip";
+  } else if (filename.endsWith(".tar")) {
+    format = "tar" /* TAR */;
+    compression = "none";
+  } else {
+    throw new FulpackOperationError(
+      createFulpackError(
+        ERROR_CODES.INVALID_ARCHIVE_FORMAT,
+        `Unsupported archive format: ${filename}`,
+        "info" /* INFO */,
+        { archive }
+      )
+    );
+  }
+  const entries = await scan(archive, { include_metadata: true });
+  const entry_count = entries.length;
+  const total_size = entries.reduce((sum, entry) => sum + (entry.size || 0), 0);
+  const compressed_size = stats.size;
+  const compression_ratio = total_size > 0 ? compressed_size / total_size : 1;
+  const has_checksums = entries.some((entry) => entry.checksum !== void 0);
+  return {
+    format,
+    compression,
+    entry_count,
+    total_size,
+    compressed_size,
+    compression_ratio,
+    has_checksums,
+    created: stats.mtime.toISOString()
+  };
+}
+async function extractGzipFile(archive, destination, options) {
+  const filename = basename(archive, ".gz");
+  const outputPath = join(destination, filename);
+  if (existsSync(outputPath)) {
+    if (options.overwrite === "error") {
+      throw new FulpackOperationError(
+        createFulpackError(
+          ERROR_CODES.EXTRACTION_FAILED,
+          `Output file already exists: ${outputPath}`,
+          "extract" /* EXTRACT */,
+          { path: outputPath, archive }
+        )
+      );
+    } else if (options.overwrite === "skip") {
+      return {
+        extracted_count: 0,
+        skipped_count: 1,
+        error_count: 0,
+        errors: [],
+        warnings: [`Skipped existing file: ${outputPath}`]
+      };
+    }
+  }
+  try {
+    const readStream = createReadStream(archive);
+    const writeStream = createWriteStream(outputPath);
+    const gunzip = createGunzip();
+    await new Promise((resolve, reject) => {
+      pipeline(readStream, gunzip, writeStream, (error) => {
+        if (error) {
+          reject(error);
+        } else {
+          resolve(void 0);
+        }
+      });
+    });
+    return {
+      extracted_count: 1,
+      skipped_count: 0,
+      error_count: 0,
+      errors: [],
+      warnings: []
+    };
+  } catch (error) {
+    throw new FulpackOperationError(
+      createFulpackError(
+        ERROR_CODES.EXTRACTION_FAILED,
+        `Failed to extract gzip file: ${error instanceof Error ? error.message : "Unknown error"}`,
+        "extract" /* EXTRACT */,
+        { archive, details: { original_error: error } }
+      )
+    );
+  }
+}
+async function scanGzipFile(archive, options) {
+  const filename = basename(archive, ".gz");
+  const stats = statSync(archive);
+  const entry = {
+    path: filename,
+    type: "file" /* FILE */,
+    size: 0,
+    // Would need to decompress to get actual size
+    compressed_size: stats.size,
+    modified: stats.mtime.toISOString(),
+    ...options.include_metadata && { mode: "0644" }
+    // Default for gzip files
+  };
+  return [entry];
+}
+async function createTarGzArchive(sources, output, options) {
+  const writeStream = createWriteStream(output);
+  const archive = new TarArchive({
+    gzip: true,
+    gzipOptions: {
+      level: options.compression_level
+    }
+  });
+  let entryCount = 0;
+  let totalSize = 0;
+  const writePromise = new Promise((resolve, reject) => {
+    writeStream.on("close", () => resolve());
+    writeStream.on("error", reject);
+    archive.on(
+      "error",
+      (error) => reject(
+        new FulpackOperationError(
+          createFulpackError(
+            ERROR_CODES.EXTRACTION_FAILED,
+            `TAR.GZ creation failed: ${error.message}`,
+            "create" /* CREATE */,
+            { details: { original_error: error } }
+          )
+        )
+      )
+    );
+  });
+  archive.pipe(writeStream);
+  for (const sourcePath of sources) {
+    if (!existsSync(sourcePath)) {
+      throw new FulpackOperationError(
+        createFulpackError(
+          ERROR_CODES.SOURCE_NOT_FOUND,
+          `Source not found: ${sourcePath}`,
+          "create" /* CREATE */,
+          { details: { source: sourcePath } }
+        )
+      );
+    }
+    const stats = statSync(sourcePath);
+    if (stats.isDirectory()) {
+      await addDirectoryToTarGzArchive(archive, sourcePath, "", options);
+    } else {
+      const entryName = basename(sourcePath);
+      archive.file(sourcePath, {
+        name: entryName,
+        mode: options.preserve_permissions ? stats.mode : 420
+      });
+      entryCount++;
+      totalSize += stats.size;
+    }
+  }
+  archive.finalize().catch(() => {
+  });
+  await writePromise;
+  const outputStats = statSync(output);
+  return {
+    format: "tar.gz" /* TAR_GZ */,
+    compression: "gzip",
+    entry_count: entryCount,
+    total_size: totalSize,
+    compressed_size: outputStats.size,
+    compression_ratio: totalSize > 0 ? outputStats.size / totalSize : 0,
+    has_checksums: false,
+    // TODO: Add fulhash checksum integration
+    created: outputStats.mtime.toISOString()
+  };
+}
+async function createZipArchive(sources, output, options) {
+  const writeStream = createWriteStream(output);
+  const archive = new ZipArchive({
+    zlib: { level: options.compression_level }
+  });
+  let entryCount = 0;
+  let totalSize = 0;
+  const writePromise = new Promise((resolve, reject) => {
+    writeStream.on("close", () => resolve());
+    writeStream.on("error", reject);
+    archive.on(
+      "error",
+      (error) => reject(
+        new FulpackOperationError(
+          createFulpackError(
+            ERROR_CODES.EXTRACTION_FAILED,
+            `ZIP creation failed: ${error.message}`,
+            "create" /* CREATE */,
+            { details: { original_error: error } }
+          )
+        )
+      )
+    );
+  });
+  archive.pipe(writeStream);
+  for (const sourcePath of sources) {
+    if (!existsSync(sourcePath)) {
+      throw new FulpackOperationError(
+        createFulpackError(
+          ERROR_CODES.SOURCE_NOT_FOUND,
+          `Source not found: ${sourcePath}`,
+          "create" /* CREATE */,
+          { details: { source: sourcePath } }
+        )
+      );
+    }
+    const stats = statSync(sourcePath);
+    if (stats.isDirectory()) {
+      await addDirectoryToZipArchive(archive, sourcePath, "", options);
+    } else {
+      const entryName = basename(sourcePath);
+      archive.file(sourcePath, {
+        name: entryName,
+        mode: options.preserve_permissions ? stats.mode : 420
+      });
+      entryCount++;
+      totalSize += stats.size;
+    }
+  }
+  archive.finalize().catch(() => {
+  });
+  await writePromise;
+  const outputStats = statSync(output);
+  return {
+    format: "zip" /* ZIP */,
+    compression: "deflate",
+    entry_count: entryCount,
+    total_size: totalSize,
+    compressed_size: outputStats.size,
+    compression_ratio: totalSize > 0 ? outputStats.size / totalSize : 0,
+    has_checksums: false,
+    created: outputStats.mtime.toISOString()
+  };
+}
+async function addDirectoryToTarGzArchive(archive, dirPath, archivePrefix, options) {
+  const entries = readdirSync(dirPath);
+  for (const entry of entries) {
+    const fullPath = join(dirPath, entry);
+    const archivePath = join(archivePrefix, entry);
+    const stats = lstatSync(fullPath);
+    if (stats.isSymbolicLink()) {
+      if (!options.follow_symlinks) {
+        continue;
+      }
+      const targetStats = statSync(fullPath);
+      if (targetStats.isDirectory()) {
+        await addDirectoryToTarGzArchive(archive, fullPath, archivePath, options);
+      } else {
+        archive.file(fullPath, {
+          name: archivePath,
+          mode: options.preserve_permissions ? targetStats.mode : 420
+        });
+      }
+    } else if (stats.isDirectory()) {
+      await addDirectoryToTarGzArchive(archive, fullPath, archivePath, options);
+    } else {
+      archive.file(fullPath, {
+        name: archivePath,
+        mode: options.preserve_permissions ? stats.mode : 420
+      });
+    }
+  }
+}
+async function createTarArchive(sources, output, options) {
+  const writeStream = createWriteStream(output);
+  const archive = new TarArchive({
+    gzip: false
+    // Uncompressed
+  });
+  let entryCount = 0;
+  let totalSize = 0;
+  const writePromise = new Promise((resolve, reject) => {
+    writeStream.on("close", () => resolve());
+    writeStream.on("error", reject);
+    archive.on(
+      "error",
+      (error) => reject(
+        new FulpackOperationError(
+          createFulpackError(
+            ERROR_CODES.EXTRACTION_FAILED,
+            `TAR creation failed: ${error.message}`,
+            "create" /* CREATE */,
+            { details: { original_error: error } }
+          )
+        )
+      )
+    );
+  });
+  archive.pipe(writeStream);
+  for (const sourcePath of sources) {
+    if (!existsSync(sourcePath)) {
+      throw new FulpackOperationError(
+        createFulpackError(
+          ERROR_CODES.SOURCE_NOT_FOUND,
+          `Source not found: ${sourcePath}`,
+          "create" /* CREATE */,
+          { details: { source: sourcePath } }
+        )
+      );
+    }
+    const stats = statSync(sourcePath);
+    if (stats.isDirectory()) {
+      await addDirectoryToTarArchive(archive, sourcePath, "", options);
+    } else {
+      const entryName = basename(sourcePath);
+      archive.file(sourcePath, {
+        name: entryName,
+        mode: options.preserve_permissions ? stats.mode : 420
+      });
+      entryCount++;
+      totalSize += stats.size;
+    }
+  }
+  archive.finalize().catch(() => {
+  });
+  await writePromise;
+  const outputStats = statSync(output);
+  return {
+    format: "tar" /* TAR */,
+    compression: "none",
+    entry_count: entryCount,
+    total_size: totalSize,
+    compressed_size: outputStats.size,
+    compression_ratio: 1,
+    // Uncompressed
+    has_checksums: false,
+    // TODO: Add fulhash checksum integration
+    created: outputStats.mtime.toISOString()
+  };
+}
+async function addDirectoryToTarArchive(archive, dirPath, archivePrefix, options) {
+  const entries = readdirSync(dirPath);
+  for (const entry of entries) {
+    const fullPath = join(dirPath, entry);
+    const archivePath = join(archivePrefix, entry);
+    const stats = lstatSync(fullPath);
+    if (stats.isSymbolicLink()) {
+      if (!options.follow_symlinks) {
+        continue;
+      }
+      const targetStats = statSync(fullPath);
+      if (targetStats.isDirectory()) {
+        await addDirectoryToTarArchive(archive, fullPath, archivePath, options);
+      } else {
+        archive.file(fullPath, {
+          name: archivePath,
+          mode: options.preserve_permissions ? targetStats.mode : 420
+        });
+      }
+    } else if (stats.isDirectory()) {
+      await addDirectoryToTarArchive(archive, fullPath, archivePath, options);
+    } else {
+      archive.file(fullPath, {
+        name: archivePath,
+        mode: options.preserve_permissions ? stats.mode : 420
+      });
+    }
+  }
+}
+async function createGzipFile(sources, output, options) {
+  if (sources.length !== 1) {
+    throw new FulpackOperationError(
+      createFulpackError(
+        ERROR_CODES.INVALID_OPTIONS,
+        `GZIP format requires exactly one source file, got ${sources.length}`,
+        "create" /* CREATE */
+      )
+    );
+  }
+  const sourcePath = sources[0];
+  if (!existsSync(sourcePath)) {
+    throw new FulpackOperationError(
+      createFulpackError(
+        ERROR_CODES.SOURCE_NOT_FOUND,
+        `Source not found: ${sourcePath}`,
+        "create" /* CREATE */,
+        { details: { source: sourcePath } }
+      )
+    );
+  }
+  const stats = statSync(sourcePath);
+  if (stats.isDirectory()) {
+    throw new FulpackOperationError(
+      createFulpackError(
+        ERROR_CODES.INVALID_OPTIONS,
+        "GZIP format does not support directories",
+        "create" /* CREATE */,
+        { details: { source: sourcePath } }
+      )
+    );
+  }
+  const readStream = createReadStream(sourcePath);
+  const writeStream = createWriteStream(output);
+  const gzip = createGzip({ level: options.compression_level });
+  await new Promise((resolve, reject) => {
+    pipeline(readStream, gzip, writeStream, (error) => {
+      if (error) {
+        reject(error);
+      } else {
+        resolve(void 0);
+      }
+    });
+  });
+  const outputStats = statSync(output);
+  return {
+    format: "gzip" /* GZIP */,
+    compression: "gzip",
+    entry_count: 1,
+    total_size: stats.size,
+    compressed_size: outputStats.size,
+    compression_ratio: stats.size > 0 ? outputStats.size / stats.size : 0,
+    has_checksums: false,
+    created: outputStats.mtime.toISOString()
+  };
+}
+async function addDirectoryToZipArchive(archive, dirPath, archivePrefix, options) {
+  const entries = readdirSync(dirPath);
+  for (const entry of entries) {
+    const fullPath = join(dirPath, entry);
+    const archivePath = join(archivePrefix, entry);
+    const stats = lstatSync(fullPath);
+    if (stats.isSymbolicLink()) {
+      if (!options.follow_symlinks) {
+        continue;
+      }
+      const targetStats = statSync(fullPath);
+      if (targetStats.isDirectory()) {
+        await addDirectoryToZipArchive(archive, fullPath, archivePath, options);
+      } else {
+        archive.file(fullPath, {
+          name: archivePath,
+          mode: options.preserve_permissions ? targetStats.mode : 420
+        });
+      }
+    } else if (stats.isDirectory()) {
+      await addDirectoryToZipArchive(archive, fullPath, archivePath, options);
+    } else {
+      archive.file(fullPath, {
+        name: archivePath,
+        mode: options.preserve_permissions ? stats.mode : 420
+      });
+    }
+  }
+}
+async function extractTarGz(archive, destination, options) {
+  const tarStream = await import('tar-stream');
+  const extract2 = tarStream.extract();
+  let extractedCount = 0;
+  let skippedCount = 0;
+  let errorCount = 0;
+  const errors = [];
+  const warnings = [];
+  let totalExtractedSize = 0;
+  let entryCount = 0;
+  extract2.on("entry", async (header, stream, next) => {
+    entryCount++;
+    try {
+      if (options.max_entries && entryCount > options.max_entries) {
+        errors.push(
+          createFulpackError(
+            ERROR_CODES.DECOMPRESSION_BOMB,
+            `Entry count exceeds maximum (${options.max_entries})`,
+            "extract" /* EXTRACT */,
+            {
+              archive,
+              details: { entry_count: entryCount, max_entries: options.max_entries }
+            }
+          )
+        );
+        stream.resume();
+        next();
+        return;
+      }
+      const pathError = validatePath(header.name, "extract" /* EXTRACT */, false);
+      if (pathError) {
+        errors.push({ ...pathError, archive });
+        errorCount++;
+        stream.resume();
+        next();
+        return;
+      }
+      const outputPath = join(destination, header.name);
+      if (header.type === "directory") {
+        if (!existsSync(outputPath)) {
+          mkdirSync(outputPath, { recursive: true });
+        }
+        extractedCount++;
+        stream.resume();
+        next();
+      } else if (header.type === "file") {
+        if (existsSync(outputPath)) {
+          if (options.overwrite === "error") {
+            errors.push(
+              createFulpackError(
+                ERROR_CODES.EXTRACTION_FAILED,
+                `Output file already exists: ${outputPath}`,
+                "extract" /* EXTRACT */,
+                { path: header.name, archive }
+              )
+            );
+            errorCount++;
+            stream.resume();
+            next();
+            return;
+          } else if (options.overwrite === "skip") {
+            warnings.push(`Skipped existing file: ${outputPath}`);
+            skippedCount++;
+            stream.resume();
+            next();
+            return;
+          }
+        }
+        const parentDir = dirname(outputPath);
+        if (!existsSync(parentDir)) {
+          mkdirSync(parentDir, { recursive: true });
+        }
+        const writeStream = createWriteStream(outputPath);
+        stream.on("data", (chunk) => {
+          totalExtractedSize += chunk.length;
+          if (options.max_size && totalExtractedSize > options.max_size) {
+            stream.destroy();
+            writeStream.destroy();
+            errors.push(
+              createFulpackError(
+                ERROR_CODES.DECOMPRESSION_BOMB,
+                `Total extracted size exceeds maximum (${options.max_size} bytes)`,
+                "extract" /* EXTRACT */,
+                {
+                  archive,
+                  path: header.name,
+                  details: { actual_size: totalExtractedSize, max_size: options.max_size }
+                }
+              )
+            );
+            errorCount++;
+            next();
+            return;
+          }
+        });
+        stream.pipe(writeStream);
+        writeStream.on("finish", () => {
+          if (options.preserve_permissions && header.mode) {
+            try {
+              const { chmodSync } = __require("fs");
+              chmodSync(outputPath, header.mode);
+            } catch {
+            }
+          }
+          extractedCount++;
+          next();
+        });
+        writeStream.on("error", (error) => {
+          errors.push(
+            createFulpackError(
+              ERROR_CODES.EXTRACTION_FAILED,
+              `Failed to write file: ${error.message}`,
+              "extract" /* EXTRACT */,
+              { path: header.name, archive, details: { original_error: error } }
+            )
+          );
+          errorCount++;
+          next();
+        });
+      } else {
+        warnings.push(`Skipped entry type ${header.type}: ${header.name}`);
+        stream.resume();
+        next();
+      }
+    } catch (error) {
+      errors.push(
+        createFulpackError(
+          ERROR_CODES.EXTRACTION_FAILED,
+          `Error processing entry: ${error instanceof Error ? error.message : "Unknown error"}`,
+          "extract" /* EXTRACT */,
+          { path: header.name, archive, details: { original_error: error } }
+        )
+      );
+      errorCount++;
+      stream.resume();
+      next();
+    }
+  });
+  const readStream = createReadStream(archive);
+  const gunzip = createGunzip();
+  return new Promise((resolve, reject) => {
+    extract2.on("finish", () => {
+      resolve({
+        extracted_count: extractedCount,
+        skipped_count: skippedCount,
+        error_count: errorCount,
+        errors: errors.length > 0 ? errors : void 0,
+        warnings: warnings.length > 0 ? warnings : void 0,
+        total_bytes: totalExtractedSize
+      });
+    });
+    extract2.on("error", (error) => {
+      reject(
+        new FulpackOperationError(
+          createFulpackError(
+            ERROR_CODES.EXTRACTION_FAILED,
+            `TAR.GZ extraction failed: ${error.message}`,
+            "extract" /* EXTRACT */,
+            { archive, details: { original_error: error } }
+          )
+        )
+      );
+    });
+    readStream.pipe(gunzip).pipe(extract2);
+  });
+}
+async function extractTar(archive, destination, options) {
+  const tarStream = await import('tar-stream');
+  const extract2 = tarStream.extract();
+  let extractedCount = 0;
+  let skippedCount = 0;
+  let errorCount = 0;
+  const errors = [];
+  const warnings = [];
+  let totalExtractedSize = 0;
+  let entryCount = 0;
+  extract2.on("entry", async (header, stream, next) => {
+    entryCount++;
+    try {
+      if (options.max_entries && entryCount > options.max_entries) {
+        errors.push(
+          createFulpackError(
+            ERROR_CODES.DECOMPRESSION_BOMB,
+            `Entry count exceeds maximum (${options.max_entries})`,
+            "extract" /* EXTRACT */,
+            {
+              archive,
+              details: { entry_count: entryCount, max_entries: options.max_entries }
+            }
+          )
+        );
+        stream.resume();
+        next();
+        return;
+      }
+      const pathError = validatePath(header.name, "extract" /* EXTRACT */, false);
+      if (pathError) {
+        errors.push({ ...pathError, archive });
+        errorCount++;
+        stream.resume();
+        next();
+        return;
+      }
+      const outputPath = join(destination, header.name);
+      if (header.type === "directory") {
+        if (!existsSync(outputPath)) {
+          mkdirSync(outputPath, { recursive: true });
+        }
+        extractedCount++;
+        stream.resume();
+        next();
+      } else if (header.type === "file") {
+        if (existsSync(outputPath)) {
+          if (options.overwrite === "error") {
+            errors.push(
+              createFulpackError(
+                ERROR_CODES.EXTRACTION_FAILED,
+                `Output file already exists: ${outputPath}`,
+                "extract" /* EXTRACT */,
+                { path: header.name, archive }
+              )
+            );
+            errorCount++;
+            stream.resume();
+            next();
+            return;
+          } else if (options.overwrite === "skip") {
+            warnings.push(`Skipped existing file: ${outputPath}`);
+            skippedCount++;
+            stream.resume();
+            next();
+            return;
+          }
+        }
+        const parentDir = dirname(outputPath);
+        if (!existsSync(parentDir)) {
+          mkdirSync(parentDir, { recursive: true });
+        }
+        const writeStream = createWriteStream(outputPath);
+        stream.on("data", (chunk) => {
+          totalExtractedSize += chunk.length;
+          if (options.max_size && totalExtractedSize > options.max_size) {
+            stream.destroy();
+            writeStream.destroy();
+            errors.push(
+              createFulpackError(
+                ERROR_CODES.DECOMPRESSION_BOMB,
+                `Total extracted size exceeds maximum (${options.max_size} bytes)`,
+                "extract" /* EXTRACT */,
+                {
+                  archive,
+                  path: header.name,
+                  details: { actual_size: totalExtractedSize, max_size: options.max_size }
+                }
+              )
+            );
+            errorCount++;
+            next();
+            return;
+          }
+        });
+        stream.pipe(writeStream);
+        writeStream.on("finish", () => {
+          if (options.preserve_permissions && header.mode) {
+            try {
+              const { chmodSync } = __require("fs");
+              chmodSync(outputPath, header.mode);
+            } catch {
+            }
+          }
+          extractedCount++;
+          next();
+        });
+        writeStream.on("error", (error) => {
+          errors.push(
+            createFulpackError(
+              ERROR_CODES.EXTRACTION_FAILED,
+              `Failed to write file: ${error.message}`,
+              "extract" /* EXTRACT */,
+              { path: header.name, archive, details: { original_error: error } }
+            )
+          );
+          errorCount++;
+          next();
+        });
+      } else {
+        warnings.push(`Skipped entry type ${header.type}: ${header.name}`);
+        stream.resume();
+        next();
+      }
+    } catch (error) {
+      errors.push(
+        createFulpackError(
+          ERROR_CODES.EXTRACTION_FAILED,
+          `Error processing entry: ${error instanceof Error ? error.message : "Unknown error"}`,
+          "extract" /* EXTRACT */,
+          { path: header.name, archive, details: { original_error: error } }
+        )
+      );
+      errorCount++;
+      stream.resume();
+      next();
+    }
+  });
+  const readStream = createReadStream(archive);
+  return new Promise((resolve, reject) => {
+    extract2.on("finish", () => {
+      resolve({
+        extracted_count: extractedCount,
+        skipped_count: skippedCount,
+        error_count: errorCount,
+        errors: errors.length > 0 ? errors : void 0,
+        warnings: warnings.length > 0 ? warnings : void 0,
+        total_bytes: totalExtractedSize
+      });
+    });
+    extract2.on("error", (error) => {
+      reject(
+        new FulpackOperationError(
+          createFulpackError(
+            ERROR_CODES.EXTRACTION_FAILED,
+            `TAR extraction failed: ${error.message}`,
+            "extract" /* EXTRACT */,
+            { archive, details: { original_error: error } }
+          )
+        )
+      );
+    });
+    readStream.pipe(extract2);
+  });
+}
+async function extractZip(archive, destination, options) {
+  const unzipper = await import('unzipper');
+  let extractedCount = 0;
+  let skippedCount = 0;
+  let errorCount = 0;
+  const errors = [];
+  const warnings = [];
+  let totalExtractedSize = 0;
+  let entryCount = 0;
+  return new Promise((resolve, reject) => {
+    const readStream = createReadStream(archive);
+    readStream.pipe(unzipper.Parse()).on("entry", async (entry) => {
+      entryCount++;
+      try {
+        if (options.max_entries && entryCount > options.max_entries) {
+          errors.push(
+            createFulpackError(
+              ERROR_CODES.DECOMPRESSION_BOMB,
+              `Entry count exceeds maximum (${options.max_entries})`,
+              "extract" /* EXTRACT */,
+              {
+                archive,
+                details: { entry_count: entryCount, max_entries: options.max_entries }
+              }
+            )
+          );
+          entry.autodrain();
+          return;
+        }
+        const pathError = validatePath(entry.path, "extract" /* EXTRACT */, false);
+        if (pathError) {
+          errors.push({ ...pathError, archive });
+          errorCount++;
+          entry.autodrain();
+          return;
+        }
+        const outputPath = join(destination, entry.path);
+        if (entry.type === "Directory") {
+          if (!existsSync(outputPath)) {
+            mkdirSync(outputPath, { recursive: true });
+          }
+          extractedCount++;
+          entry.autodrain();
+        } else if (entry.type === "File") {
+          if (existsSync(outputPath)) {
+            if (options.overwrite === "error") {
+              errors.push(
+                createFulpackError(
+                  ERROR_CODES.EXTRACTION_FAILED,
+                  `Output file already exists: ${outputPath}`,
+                  "extract" /* EXTRACT */,
+                  { path: entry.path, archive }
+                )
+              );
+              errorCount++;
+              entry.autodrain();
+              return;
+            } else if (options.overwrite === "skip") {
+              warnings.push(`Skipped existing file: ${outputPath}`);
+              skippedCount++;
+              entry.autodrain();
+              return;
+            }
+          }
+          const parentDir = dirname(outputPath);
+          if (!existsSync(parentDir)) {
+            mkdirSync(parentDir, { recursive: true });
+          }
+          const writeStream = createWriteStream(outputPath);
+          entry.on("data", (chunk) => {
+            totalExtractedSize += chunk.length;
+            if (options.max_size && totalExtractedSize > options.max_size) {
+              entry.destroy();
+              writeStream.destroy();
+              errors.push(
+                createFulpackError(
+                  ERROR_CODES.DECOMPRESSION_BOMB,
+                  `Total extracted size exceeds maximum (${options.max_size} bytes)`,
+                  "extract" /* EXTRACT */,
+                  {
+                    archive,
+                    path: entry.path,
+                    details: { actual_size: totalExtractedSize, max_size: options.max_size }
+                  }
+                )
+              );
+              errorCount++;
+              return;
+            }
+          });
+          entry.pipe(writeStream);
+          writeStream.on("finish", () => {
+            extractedCount++;
+          });
+          writeStream.on("error", (error) => {
+            errors.push(
+              createFulpackError(
+                ERROR_CODES.EXTRACTION_FAILED,
+                `Failed to write file: ${error.message}`,
+                "extract" /* EXTRACT */,
+                { path: entry.path, archive, details: { original_error: error } }
+              )
+            );
+            errorCount++;
+          });
+        } else {
+          warnings.push(`Skipped entry type ${entry.type}: ${entry.path}`);
+          entry.autodrain();
+        }
+      } catch (error) {
+        errors.push(
+          createFulpackError(
+            ERROR_CODES.EXTRACTION_FAILED,
+            `Error processing entry: ${error instanceof Error ? error.message : "Unknown error"}`,
+            "extract" /* EXTRACT */,
+            { path: entry.path, archive, details: { original_error: error } }
+          )
+        );
+        errorCount++;
+        entry.autodrain();
+      }
+    }).on("close", () => {
+      resolve({
+        extracted_count: extractedCount,
+        skipped_count: skippedCount,
+        error_count: errorCount,
+        errors: errors.length > 0 ? errors : void 0,
+        warnings: warnings.length > 0 ? warnings : void 0,
+        total_bytes: totalExtractedSize
+      });
+    }).on("error", (error) => {
+      reject(
+        new FulpackOperationError(
+          createFulpackError(
+            ERROR_CODES.EXTRACTION_FAILED,
+            `ZIP extraction failed: ${error.message}`,
+            "extract" /* EXTRACT */,
+            { archive, details: { original_error: error } }
+          )
+        )
+      );
+    });
+  });
+}
+async function scanTar(archive, options) {
+  const tarStream = await import('tar-stream');
+  const extract2 = tarStream.extract();
+  const entries = [];
+  let entryCount = 0;
+  return new Promise((resolve, reject) => {
+    extract2.on("entry", async (header, stream, next) => {
+      entryCount++;
+      if (options.max_entries && entryCount > options.max_entries) {
+        stream.resume();
+        next();
+        reject(
+          new FulpackOperationError(
+            createFulpackError(
+              ERROR_CODES.DECOMPRESSION_BOMB,
+              `Entry count exceeds maximum (${options.max_entries})`,
+              "scan" /* SCAN */,
+              {
+                archive,
+                details: { entry_count: entryCount, max_entries: options.max_entries }
+              }
+            )
+          )
+        );
+        return;
+      }
+      const entry = {
+        path: header.name,
+        type: header.type === "directory" ? "directory" /* DIRECTORY */ : header.type === "symlink" ? "symlink" /* SYMLINK */ : "file" /* FILE */,
+        size: header.size || 0,
+        modified: header.mtime ? header.mtime.toISOString() : (/* @__PURE__ */ new Date()).toISOString(),
+        ...options.include_metadata && header.mode !== void 0 && header.mode !== null ? { mode: `0${(header.mode & 511).toString(8)}` } : {},
+        ...options.include_metadata && header.type === "symlink" && header.linkname ? { symlink_target: header.linkname } : {}
+      };
+      entries.push(entry);
+      stream.resume();
+      next();
+    });
+    extract2.on("finish", () => {
+      resolve(entries);
+    });
+    extract2.on("error", (error) => {
+      reject(
+        new FulpackOperationError(
+          createFulpackError(
+            ERROR_CODES.ARCHIVE_CORRUPT,
+            `TAR scanning failed: ${error.message}`,
+            "scan" /* SCAN */,
+            { archive, details: { original_error: error } }
+          )
+        )
+      );
+    });
+    const readStream = createReadStream(archive);
+    readStream.pipe(extract2);
+  });
+}
+async function scanTarGz(archive, options) {
+  const tarStream = await import('tar-stream');
+  const extract2 = tarStream.extract();
+  const entries = [];
+  let entryCount = 0;
+  return new Promise((resolve, reject) => {
+    extract2.on("entry", async (header, stream, next) => {
+      entryCount++;
+      if (options.max_entries && entryCount > options.max_entries) {
+        stream.resume();
+        next();
+        reject(
+          new FulpackOperationError(
+            createFulpackError(
+              ERROR_CODES.DECOMPRESSION_BOMB,
+              `Entry count exceeds maximum (${options.max_entries})`,
+              "scan" /* SCAN */,
+              {
+                archive,
+                details: { entry_count: entryCount, max_entries: options.max_entries }
+              }
+            )
+          )
+        );
+        return;
+      }
+      const entry = {
+        path: header.name,
+        type: header.type === "directory" ? "directory" /* DIRECTORY */ : header.type === "symlink" ? "symlink" /* SYMLINK */ : "file" /* FILE */,
+        size: header.size || 0,
+        modified: header.mtime ? header.mtime.toISOString() : (/* @__PURE__ */ new Date()).toISOString(),
+        ...options.include_metadata && header.mode !== void 0 && header.mode !== null ? { mode: `0${(header.mode & 511).toString(8)}` } : {},
+        ...options.include_metadata && header.type === "symlink" && header.linkname ? { symlink_target: header.linkname } : {}
+      };
+      entries.push(entry);
+      stream.resume();
+      next();
+    });
+    extract2.on("finish", () => {
+      resolve(entries);
+    });
+    extract2.on("error", (error) => {
+      reject(
+        new FulpackOperationError(
+          createFulpackError(
+            ERROR_CODES.ARCHIVE_CORRUPT,
+            `TAR.GZ scanning failed: ${error.message}`,
+            "scan" /* SCAN */,
+            { archive, details: { original_error: error } }
+          )
+        )
+      );
+    });
+    const readStream = createReadStream(archive);
+    const gunzip = createGunzip();
+    readStream.pipe(gunzip).pipe(extract2);
+  });
+}
+async function scanZip(archive, options) {
+  const unzipper = await import('unzipper');
+  const entries = [];
+  let entryCount = 0;
+  return new Promise((resolve, reject) => {
+    createReadStream(archive).pipe(unzipper.Parse()).on("entry", (entry) => {
+      const typedEntry = entry;
+      entryCount++;
+      if (options.max_entries && entryCount > options.max_entries) {
+        typedEntry.autodrain();
+        reject(
+          new FulpackOperationError(
+            createFulpackError(
+              ERROR_CODES.DECOMPRESSION_BOMB,
+              `Entry count exceeds maximum (${options.max_entries})`,
+              "scan" /* SCAN */,
+              {
+                archive,
+                details: { entry_count: entryCount, max_entries: options.max_entries }
+              }
+            )
+          )
+        );
+        return;
+      }
+      const uncompressedSize = typedEntry.vars?.uncompressedSize || typedEntry.props?.size || 0;
+      const compressedSize = typedEntry.vars?.compressedSize || typedEntry.props?.compressedSize || 0;
+      const archiveEntry = {
+        path: typedEntry.path,
+        type: typedEntry.type === "Directory" ? "directory" /* DIRECTORY */ : "file" /* FILE */,
+        size: uncompressedSize,
+        modified: typedEntry.vars?.lastModifiedTime ? new Date(typedEntry.vars.lastModifiedTime).toISOString() : (/* @__PURE__ */ new Date()).toISOString(),
+        ...options.include_metadata ? {
+          compressed_size: compressedSize,
+          mode: "0644"
+          // ZIP format doesn't preserve Unix permissions consistently
+        } : {}
+      };
+      entries.push(archiveEntry);
+      typedEntry.autodrain();
+    }).on("error", (error) => {
+      reject(
+        new FulpackOperationError(
+          createFulpackError(
+            ERROR_CODES.ARCHIVE_CORRUPT,
+            `ZIP scanning failed: ${error.message}`,
+            "scan" /* SCAN */,
+            { archive, details: { original_error: error } }
+          )
+        )
+      );
+    }).on("finish", () => {
+      resolve(entries);
+    });
+  });
+}
+
+// src/fulpack/index.ts
+var FULPACK_VERSION = "1.0.0";
+
+export { ERROR_CODES, FULPACK_VERSION, FulpackOperationError, checkDecompressionBomb, create, createFulpackError, extract, hasPathTraversal, info, isAbsolutePath, scan, validatePath, verify };
+//# sourceMappingURL=chunk-P3DNOZOG.js.map
+//# sourceMappingURL=chunk-P3DNOZOG.js.map