@fulmenhq/tsfulmen 0.3.3 → 0.4.1

package/dist/fulpack/index.js

@@ -1,1517 +1,5 @@
-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';
-
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-
-// src/crucible/fulpack/types.ts
-var ArchiveFormat = /* @__PURE__ */ ((ArchiveFormat2) => {
-  ArchiveFormat2["TAR"] = "tar";
-  ArchiveFormat2["TAR_GZ"] = "tar.gz";
-  ArchiveFormat2["ZIP"] = "zip";
-  ArchiveFormat2["GZIP"] = "gzip";
-  return ArchiveFormat2;
-})(ArchiveFormat || {});
-var EntryType = /* @__PURE__ */ ((EntryType2) => {
-  EntryType2["FILE"] = "file";
-  EntryType2["DIRECTORY"] = "directory";
-  EntryType2["SYMLINK"] = "symlink";
-  return EntryType2;
-})(EntryType || {});
-var Operation = /* @__PURE__ */ ((Operation2) => {
-  Operation2["CREATE"] = "create";
-  Operation2["EXTRACT"] = "extract";
-  Operation2["SCAN"] = "scan";
-  Operation2["VERIFY"] = "verify";
-  Operation2["INFO"] = "info";
-  return Operation2;
-})(Operation || {});
-
-// 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 { ArchiveFormat, ERROR_CODES, EntryType, FULPACK_VERSION, FulpackOperationError, Operation, checkDecompressionBomb, create, createFulpackError, extract, hasPathTraversal, info, isAbsolutePath, scan, validatePath, verify };
+export { ERROR_CODES, FULPACK_VERSION, FulpackOperationError, checkDecompressionBomb, create, createFulpackError, extract, hasPathTraversal, info, isAbsolutePath, scan, validatePath, verify } from '../chunk-P3DNOZOG.js';
+export { ArchiveFormat, EntryType, Operation } from '../chunk-PQ6TKPUN.js';
+import '../chunk-UP2VWCW5.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map