neozip-cli 0.75.0-beta → 0.75.1-beta

package/dist/src/neozip/createZip.js

@@ -0,0 +1,2288 @@
+"use strict";
+/**
+ * ZIP creation functions for NeoZip CLI
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createZip = createZip;
+exports.testArchiveIntegrity = testArchiveIntegrity;
+exports.upgradeZipForTokenization = upgradeZipForTokenization;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const neozipkit_1 = require("neozipkit");
+const node_1 = __importDefault(require("neozipkit/node"));
+const blockchain_1 = require("neozipkit/blockchain");
+const CommentManager_1 = require("./CommentManager");
+const utils_1 = require("./utils");
+const file_operations_1 = require("./file-operations");
+const blockchain_2 = require("./blockchain");
+const user_interaction_1 = require("./user-interaction");
+const exit_codes_1 = require("../exit-codes");
+const version_1 = require("../version");
+/**
+ * BufferOutputWriter: Collects ZIP data in memory (for in-memory mode)
+ */
+class BufferOutputWriter {
+    constructor() {
+        this.chunks = [];
+        this.position = 0;
+        this.headerPositions = new Map(); // Track header positions for updates
+    }
+    async writeHeader(header) {
+        const headerPosition = this.position;
+        this.headerPositions.set(this.chunks.length, headerPosition);
+        this.chunks.push(header);
+        this.position += header.length;
+    }
+    async writeData(data) {
+        this.chunks.push(data);
+        this.position += data.length;
+    }
+    async updateHeader(headerPosition, compressedSize, crc) {
+        // Find the chunk containing this header position
+        let currentPos = 0;
+        for (let i = 0; i < this.chunks.length; i++) {
+            const chunk = this.chunks[i];
+            const chunkStart = currentPos;
+            const chunkEnd = currentPos + chunk.length;
+            if (headerPosition >= chunkStart && headerPosition < chunkEnd) {
+                // This chunk contains the header
+                const offsetInChunk = headerPosition - chunkStart;
+                if (chunk.length >= offsetInChunk + 22 && chunk.readUInt32LE(offsetInChunk) === 0x04034b50) {
+                    // Valid local file header signature
+                    // Update CRC (offset 14) if provided
+                    if (crc !== undefined) {
+                        chunk.writeUInt32LE(crc, offsetInChunk + 14);
+                    }
+                    // Update compressed size (offset 18)
+                    chunk.writeUInt32LE(compressedSize, offsetInChunk + 18);
+                }
+                break;
+            }
+            currentPos = chunkEnd;
+        }
+    }
+    getPosition() {
+        return this.position;
+    }
+    async close() {
+        // Nothing to close for buffer mode
+    }
+    getResult() {
+        return Buffer.concat(this.chunks);
+    }
+}
+/**
+ * FileOutputWriter: Writes ZIP data directly to file (for file-based mode)
+ */
+class FileOutputWriter {
+    constructor(archiveName, outputFd, outputStream, positionRef) {
+        this.stream = outputStream;
+        this.fd = outputFd;
+        this.positionRef = positionRef;
+    }
+    async writeHeader(header) {
+        return new Promise((resolve, reject) => {
+            this.stream.write(header, (error) => {
+                if (error) {
+                    reject(error);
+                }
+                else {
+                    this.positionRef.current += header.length;
+                    resolve();
+                }
+            });
+        });
+    }
+    async writeData(data) {
+        return new Promise((resolve, reject) => {
+            this.stream.write(data, (error) => {
+                if (error) {
+                    reject(error);
+                }
+                else {
+                    this.positionRef.current += data.length;
+                    resolve();
+                }
+            });
+        });
+    }
+    async updateHeader(headerPosition, compressedSize, crc) {
+        // Update CRC (offset 14) if provided
+        if (crc !== undefined) {
+            const crcOffset = headerPosition + 14;
+            const crcBuffer = Buffer.alloc(4);
+            crcBuffer.writeUInt32LE(crc, 0);
+            fs.writeSync(this.fd, crcBuffer, 0, 4, crcOffset);
+        }
+        // Update compressed size (offset 18)
+        const compressedSizeOffset = headerPosition + 18;
+        const sizeBuffer = Buffer.alloc(4);
+        sizeBuffer.writeUInt32LE(compressedSize, 0);
+        fs.writeSync(this.fd, sizeBuffer, 0, 4, compressedSizeOffset);
+    }
+    getPosition() {
+        return this.positionRef.current;
+    }
+    async close() {
+        // Close is handled by ZipCreator.closeOutput()
+        // This method exists for interface compliance
+    }
+    getResult() {
+        return null; // File mode doesn't return buffer
+    }
+}
+/**
+ * Create ZIP archive using the EXACT working code from zip.ts
+ */
+async function createZip(archiveName, files, options = { verbose: false, quiet: false }) {
+    const zipCreator = new ZipCreator(archiveName, files, options);
+    await zipCreator.create();
+}
+/**
+ * ZipCreator class that handles ZIP file creation with modular, reusable methods
+ *
+ * ZIP FILE CREATION PROCEDURE:
+ *
+ * This class follows a sequential, efficient ZIP file creation process:
+ *
+ * 1. FILE ANALYSIS (processFiles):
+ *    - Collects files to be added to the ZIP archive
+ *    - Creates ZipEntry objects using zipkit.createZipEntry() for each file
+ *    - Each entry is automatically added to zip.zipEntries[] (single source of truth)
+ *    - Entries are stored in processing order (files first)
+ *    - Sets file metadata: timestamps, sizes, paths, etc.
+ *    - Marks entries as updated (entry.isUpdated = true) for compression
+ *
+ * 2. ZIP HEADER & COMPRESSION (compressEntries):
+ *    - Loops through zip.zipEntries[] directly (maintains exact processing order)
+ *    - For each entry marked for update (entry.isUpdated):
+ *      a. Reads file data from disk (for in-memory mode) or streams (for file-based mode)
+ *      b. Applies line ending conversion if requested
+ *      c. SEQUENTIAL WRITE PROCESS:
+ *         - Step 1: Get current file position
+ *         - Step 2: Create local file header with placeholder compressed size (0)
+ *         - Step 3: Write local header to output (file or memory buffer)
+ *         - Step 4: Compress file data using ZipCompress.compressFileBuffer()
+ *         - Step 5: Write compressed data to output
+ *         - Step 6: Seek back and update compressed size in local header
+ *      d. Updates entry with compression results: compressedSize, crc, sha256
+ *      e. Accumulates SHA-256 hashes for blockchain metadata (if enabled)
+ *
+ * 3. METADATA ADDITION (handleTokenization):
+ *    - After all files are compressed, calculates blockchain metadata (if enabled)
+ *    - Creates metadata entry using zipkit.createZipEntry() for:
+ *      - META-INF/NZIP.TOKEN (blockchain token metadata)
+ *      - META-INF/TIMESTAMP.METADATA (timestamp metadata)
+ *      - META-INF/TS-SUBMIT.OTS (OpenTimestamp proof)
+ *    - Each metadata entry is automatically added to zip.zipEntries[] (at the end)
+ *    - Writes metadata to ZIP file using same sequential process:
+ *      - Local header (with placeholder) → metadata data → update header
+ *    - Metadata entries use STORED compression (cmpMethod = 0) since they're small
+ *
+ * 4. CENTRAL DIRECTORY GENERATION (finalize):
+ *    - Uses zip.zipEntries[] directly (already in correct order: files first, metadata last)
+ *    - For each entry in zip.zipEntries[]:
+ *      - Updates localHdrOffset with actual file position
+ *      - Generates central directory entry using entry.centralDirEntry()
+ *      - Writes central directory entry to output
+ *    - Calculates central directory size and offset
+ *    - Creates and writes End of Central Directory record
+ *    - Closes output stream/file
+ *
+ * KEY PRINCIPLES:
+ * - zip.zipEntries[] is the SINGLE SOURCE OF TRUTH for entry order
+ * - Entries are added to zip.zipEntries[] in processing order (files first, metadata last)
+ * - No reordering or separation logic needed - natural order is correct
+ * - Sequential write ensures efficient processing: header → data → update header
+ * - Local header management handled in neozipkit (ZipCompress)
+ * - Zipkit is used for loading existing ZIPs (buffer-based mode)
+ */
+class ZipCreator {
+    constructor(archiveName, files, options) {
+        this.archiveName = archiveName;
+        this.files = files;
+        this.options = options;
+        this.tempArchiveName = '';
+        this.inputFiles = [];
+        this.entryToPath = new Map();
+        this.entryToDisplay = new Map();
+        this.entryToStats = new Map();
+        this.hashAccumulator = null; // Accumulate SHA-256 hashes as entries are added
+        this.zipWriter = null; // ZIP file writer (replaces outputStream/outputFd)
+        this.currentPosition = 0;
+        this.totalIn = 0;
+        this.totalOut = 0;
+        this.filesCount = 0;
+        this.fdCache = new Map();
+        this.compressionOffset = 0;
+        this.centralDirOffset = 0;
+        this.zip = new node_1.default(); // Use ZipkitNode for ZIP operations
+        // Initialize HashAccumulator if blockchain features are enabled
+        if (this.options.blockchain || this.options.blockchainOts) {
+            this.hashAccumulator = new neozipkit_1.HashCalculator({ enableAccumulation: true });
+        }
+    }
+    /**
+     * Initialize the output file stream for direct writing
+     * Uses ZipkitNode's initializeZipFile() method
+     * Always writes to temporary file first for atomic operations
+     */
+    async initializeOutput() {
+        // Ensure temp file name is set (should be set in initialize())
+        if (!this.tempArchiveName) {
+            throw new Error('Temp archive name not initialized. Call initialize() first.');
+        }
+        // For all modes (file-based or in-memory blockchain), create temp file first
+        // For in-memory blockchain mode, compression will write directly to temp file
+        // For file-based mode, compression will also write to temp file
+        // Final file will be moved atomically after successful completion
+        this.zipWriter = await this.zip.initializeZipFile(this.tempArchiveName);
+        this.currentPosition = 0;
+        if (this.options.verbose) {
+            (0, utils_1.log)(`📊 Created temporary output file: ${this.tempArchiveName}`, this.options);
+        }
+    }
+    /**
+     * Write a chunk of data directly to the output file stream or buffer
+     * Used for in-memory mode and metadata entries
+     */
+    async writeChunk(data) {
+        // For in-memory non-blockchain mode, write to buffer
+        if (this.options.inMemory && !this.options.blockchain && !this.options.blockchainOts) {
+            const bufferWriter = this.zip.bufferWriter;
+            if (bufferWriter) {
+                // Determine if this is a header or data by checking signature
+                if (data.length >= 4 && data.readUInt32LE(0) === 0x04034b50) {
+                    // This is a local file header
+                    await bufferWriter.writeHeader(data);
+                }
+                else {
+                    // This is data
+                    await bufferWriter.writeData(data);
+                }
+                this.currentPosition = bufferWriter.getPosition();
+                return;
+            }
+        }
+        // For file-based mode or in-memory blockchain mode, write to file stream
+        if (!this.zipWriter) {
+            throw new Error('ZIP writer not initialized');
+        }
+        return new Promise((resolve, reject) => {
+            this.zipWriter.outputStream.write(data, (error) => {
+                if (error) {
+                    reject(error);
+                }
+                else {
+                    this.zipWriter.currentPosition += data.length;
+                    this.currentPosition = this.zipWriter.currentPosition;
+                    resolve();
+                }
+            });
+        });
+    }
+    /**
+     * Close the output stream and file descriptor
+     * Uses ZipkitNode's finalizeZipFile() method
+     */
+    async closeOutput() {
+        if (this.zipWriter) {
+            await this.zip.finalizeZipFile(this.zipWriter);
+            this.zipWriter = null;
+        }
+    }
+    async create() {
+        try {
+            await this.initialize();
+            // Initialize output stream for file-based mode OR in-memory blockchain mode
+            // For in-memory blockchain mode, we need to write directly to file during compression
+            // For in-memory non-blockchain mode, output is written directly during compression
+            if (!this.options.inMemory || (this.options.blockchain || this.options.blockchainOts)) {
+                await this.initializeOutput();
+            }
+            await this.processFiles();
+            await this.setupCompression();
+            await this.handleComments();
+            await this.handleCompression();
+            await this.handleTokenization();
+            // Finalize ZIP file (write central directory and end record)
+            // For all modes (including in-memory non-blockchain), finalize after metadata is added
+            // This ensures metadata is included in the ZIP before central directory is written
+            await this.finalize();
+            // Test integrity AFTER finalization (so it includes metadata)
+            if (this.options.testIntegrity) {
+                const integrityPassed = await testArchiveIntegrity(this.archiveName, this.options);
+                if (!integrityPassed) {
+                    (0, utils_1.logError)(`❌ Archive integrity test failed for: ${this.archiveName}`);
+                    throw new Error('Archive integrity test failed');
+                }
+            }
+            // Display final statistics
+            this.displayStatistics();
+        }
+        catch (error) {
+            // On error, ensure temp file is cleaned up
+            if (this.tempArchiveName && fs.existsSync(this.tempArchiveName)) {
+                try {
+                    fs.unlinkSync(this.tempArchiveName);
+                    if (this.options.verbose) {
+                        (0, utils_1.log)(`🧹 Cleaned up temporary file after error`, this.options);
+                    }
+                }
+                catch (cleanupError) {
+                    // Ignore cleanup errors
+                    if (this.options.verbose) {
+                        (0, utils_1.log)(`⚠️  Warning: Could not clean up temp file: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}`, this.options);
+                    }
+                }
+            }
+            // Re-throw error after cleanup
+            throw error;
+        }
+    }
+    displayStatistics() {
+        (0, utils_1.log)(`\n✅ ZIP archive created: ${this.archiveName}`, this.options);
+        (0, utils_1.log)(`   Files: ${this.filesCount}`, this.options);
+        (0, utils_1.log)(`   Total size: ${(0, utils_1.formatBytes)(this.totalIn)}`, this.options);
+        (0, utils_1.log)(`   Compressed size: ${(0, utils_1.formatBytes)(this.totalOut)}`, this.options);
+        (0, utils_1.log)(`   Compression ratio: ${this.totalIn > 0 ? Math.round((1 - this.totalOut / this.totalIn) * 100) : 0}%`, this.options);
+        if (this.options.debug) {
+            (0, utils_1.logDebug)(`  Input files processed: ${this.filesCount}`, this.options);
+            (0, utils_1.logDebug)(`  Total uncompressed size: ${this.totalIn} bytes`, this.options);
+            (0, utils_1.logDebug)(`  Total compressed size: ${this.totalOut} bytes`, this.options);
+            (0, utils_1.logDebug)(`  Compression ratio: ${this.totalIn > 0 ? Math.round((1 - this.totalOut / this.totalIn) * 100) : 0}%`, this.options);
+            (0, utils_1.logDebug)(`  Archive file: ${this.archiveName}`, this.options);
+            if (fs.existsSync(this.archiveName)) {
+                (0, utils_1.logDebug)(`  Archive file size: ${fs.statSync(this.archiveName).size} bytes`, this.options);
+            }
+        }
+    }
+    async initialize() {
+        // Display application information
+        (0, utils_1.log)(`🚀 NEOZIP v${version_1.APP_VERSION} (${version_1.APP_RELEASE_DATE})`, this.options);
+        (0, utils_1.log)(`📦 Creating: ${this.archiveName}`, this.options);
+        (0, utils_1.log)(`📁 Files: ${this.files.length} file(s)`, this.options);
+        const compressionDesc = this.options.level === 0 ? 'store (no compression)' : `${this.options.compression} (level ${this.options.level})`;
+        (0, utils_1.log)(`🔧 Compression: ${compressionDesc}`, this.options);
+        (0, utils_1.log)(`📊 Block size: ${(0, utils_1.formatBytes)(this.options.blockSize || 64 * 1024)}`, this.options);
+        (0, utils_1.log)(`🔗 Tokenization: ${this.options.blockchain ? 'enabled' : 'disabled'}`, this.options);
+        const encryptionMethod = this.options.encryptionMethod || 'pkzip';
+        (0, utils_1.log)(`🔐 Encryption: ${this.options.encrypt ? `${encryptionMethod.toUpperCase()} enabled` : 'disabled'}`, this.options);
+        (0, utils_1.log)('', this.options);
+        if (this.options.debug) {
+            (0, utils_1.logDebug)('Debug mode enabled', this.options);
+            (0, utils_1.logDebug)(`Command line arguments: ${process.argv.join(' ')}`, this.options);
+            (0, utils_1.logDebug)(`Working directory: ${process.cwd()}`, this.options);
+            (0, utils_1.logDebug)(`Node.js version: ${process.version}`, this.options);
+            (0, utils_1.logDebug)(`Platform: ${process.platform} ${process.arch}`, this.options);
+            (0, utils_1.log)('', this.options);
+        }
+        if (this.options.verbose) {
+            (0, utils_1.log)(`Creating ZIP archive: ${this.archiveName}`, this.options);
+            (0, utils_1.log)(`Files to compress: ${this.files.join(', ')}`, this.options);
+            if (this.options.blockchain) {
+                if (this.options.blockchainDefault) {
+                    (0, utils_1.log)(`Blockchain: enabled (auto-select default)`, this.options);
+                }
+                else if (this.options.blockchainMint) {
+                    (0, utils_1.log)(`Blockchain: enabled (force mint new)`, this.options);
+                }
+                else {
+                    (0, utils_1.log)(`Blockchain: enabled (default)`, this.options);
+                }
+                (0, utils_1.log)(`Tokenization: enabled`, this.options);
+                (0, utils_1.log)(`Network: ${this.options.network || 'base-sepolia'}`, this.options);
+            }
+            else if (this.options.blockchainOts) {
+                (0, utils_1.log)(`Blockchain: enabled (OpenTimestamp)`, this.options);
+                (0, utils_1.log)(`Bitcoin blockchain: enabled`, this.options);
+            }
+            else {
+                (0, utils_1.log)(`Blockchain: disabled`, this.options);
+                (0, utils_1.log)(`Tokenization: disabled`, this.options);
+            }
+            if (this.options.toCrlf) {
+                (0, utils_1.log)(`Line ending conversion: LF to CRLF (Windows style)`, this.options);
+            }
+            if (this.options.fromCrlf) {
+                (0, utils_1.log)(`Line ending conversion: CRLF to LF (Unix style)`, this.options);
+            }
+        }
+        // Ensure parent directory exists
+        const parentDir = path.dirname(this.archiveName);
+        if (parentDir && parentDir !== '.' && !fs.existsSync(parentDir)) {
+            fs.mkdirSync(parentDir, { recursive: true });
+            if (this.options.verbose)
+                (0, utils_1.log)(`Created directory: ${parentDir}`, this.options);
+        }
+        // Create temporary ZIP file name
+        const tempDir = (0, utils_1.getTempDir)(this.options);
+        // Ensure temp directory exists
+        if (!fs.existsSync(tempDir)) {
+            fs.mkdirSync(tempDir, { recursive: true });
+        }
+        this.tempArchiveName = path.join(tempDir, `${path.basename(this.archiveName)}.tmp.${Date.now()}`);
+        if (this.options.tempPath && this.options.verbose) {
+            (0, utils_1.log)(`📁 Using custom temp directory: ${tempDir}`, this.options);
+        }
+    }
+    /**
+     * Collect and filter files for compression (unified for both modes)
+     */
+    async collectAndFilterFiles() {
+        const collectedFiles = await (0, file_operations_1.collectFilesRecursively)(this.files, this.options);
+        const filePaths = collectedFiles.map(f => f.displayPath);
+        const filteredFilePaths = (0, file_operations_1.filterFiles)(filePaths, this.options);
+        return collectedFiles.filter(f => filteredFilePaths.includes(f.displayPath)).map(f => ({
+            entryName: f.entryName,
+            absPath: f.absPath,
+            displayPath: f.displayPath,
+            stat: f.stat,
+            isSymlink: f.isSymlink,
+            linkTarget: f.linkTarget,
+            isHardLink: f.isHardLink,
+            originalEntry: f.originalEntry,
+            inode: f.inode
+        }));
+    }
+    async processFiles() {
+        // Load existing archive if update or freshen mode is enabled
+        let existingArchive = null;
+        if (this.options.update || this.options.freshen) {
+            try {
+                existingArchive = (0, file_operations_1.loadExistingArchive)(this.archiveName, this.options);
+                if (existingArchive) {
+                    const mode = this.options.freshen ? 'Freshen' : 'Update';
+                    const existingDir = existingArchive.getDirectory();
+                    (0, utils_1.log)(`📦 ${mode} mode: Found existing archive with ${existingDir?.length || 0} files`, this.options);
+                }
+                else {
+                    const mode = this.options.freshen ? 'Freshen' : 'Update';
+                    (0, utils_1.log)(`📦 ${mode} mode: No existing archive found, creating new one`, this.options);
+                }
+            }
+            catch (error) {
+                (0, utils_1.logError)(`❌ Failed to load existing archive: ${error instanceof Error ? error.message : String(error)}`);
+                (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.CANT_OPEN_ARCHIVE);
+            }
+        }
+        // Collect files recursively using unified method
+        const filteredFiles = await this.collectAndFilterFiles();
+        if (this.options.verbose && (this.options.include || this.options.exclude || this.options.suffixes)) {
+            const collectedFiles = await (0, file_operations_1.collectFilesRecursively)(this.files, this.options);
+            (0, utils_1.log)(`File filtering applied:`, this.options);
+            if (this.options.include) {
+                (0, utils_1.log)(`  Include patterns: ${this.options.include.join(', ')}`, this.options);
+            }
+            if (this.options.exclude) {
+                (0, utils_1.log)(`  Exclude patterns: ${this.options.exclude.join(', ')}`, this.options);
+            }
+            if (this.options.suffixes) {
+                (0, utils_1.log)(`  Excluded suffixes: ${this.options.suffixes.join(', ')}`, this.options);
+            }
+            (0, utils_1.log)(`  Original files: ${collectedFiles.length}, Filtered files: ${filteredFiles.length}`, this.options);
+        }
+        // Store filtered files for use in compression
+        this.inputFiles = filteredFiles;
+        // Filter files for update or freshen mode
+        if ((this.options.update || this.options.freshen) && existingArchive) {
+            const originalCount = this.inputFiles.length;
+            this.inputFiles = this.inputFiles.filter(file => {
+                const shouldUpdate = (0, file_operations_1.shouldUpdateFile)(file.entryName, file.stat, existingArchive, this.options.freshen);
+                if (!shouldUpdate && this.options.verbose) {
+                    const reason = this.options.freshen ? 'not in archive' : 'up to date';
+                    (0, utils_1.log)(`skipping: ${file.displayPath} (${reason})`, this.options);
+                }
+                return shouldUpdate;
+            });
+            const mode = this.options.freshen ? 'Freshen' : 'Update';
+            if (this.options.verbose) {
+                (0, utils_1.log)(`${mode} filtering: ${originalCount} files checked, ${this.inputFiles.length} files need updating`, this.options);
+            }
+        }
+        // Display planned files (optional)
+        if (this.options.verbose) {
+            (0, utils_1.log)('Files to compress:', this.options);
+            for (const it of this.inputFiles) {
+                (0, utils_1.log)(`  - ${it.displayPath} (${(0, utils_1.formatBytes)(it.stat.size)})`, this.options);
+            }
+        }
+        // Handle existing archive entries for update mode
+        if (this.options.update && existingArchive) {
+            const existingEntries = await existingArchive.getDirectory() || [];
+            const updatedEntryNames = new Set(this.inputFiles.map(f => f.entryName));
+            // Copy existing entries that aren't being updated
+            const entriesToPreserve = existingEntries.filter(entry => !updatedEntryNames.has(entry.filename));
+            for (const existingEntry of entriesToPreserve) {
+                // Copy the existing entry to the new archive
+                const newEntry = this.zip.createZipEntry(existingEntry.filename);
+                newEntry.timeDateDOS = existingEntry.timeDateDOS;
+                newEntry.uncompressedSize = existingEntry.uncompressedSize;
+                newEntry.compressedSize = existingEntry.compressedSize;
+                newEntry.cmpMethod = existingEntry.cmpMethod;
+                newEntry.crc = existingEntry.crc;
+                // Copy the file data from the existing archive
+                try {
+                    const existingData = await (async () => {
+                        try {
+                            const buf = fs.readFileSync(this.archiveName);
+                            const { default: Zipkit } = require('neozipkit');
+                            const kit = new Zipkit();
+                            kit.loadZip(buf);
+                            return await kit.extract(existingEntry);
+                        }
+                        catch {
+                            return null;
+                        }
+                    })();
+                    if (existingData) {
+                        newEntry.fileBuffer = existingData;
+                        newEntry.isUpdated = true;
+                    }
+                }
+                catch (error) {
+                    if (this.options.verbose) {
+                        (0, utils_1.log)(`warning: Could not copy existing entry ${existingEntry.filename}`, this.options);
+                    }
+                }
+                if (this.options.verbose)
+                    (0, utils_1.log)(`preserved: ${existingEntry.filename} (existing)`, this.options);
+            }
+        }
+        // Create entries for input files
+        let processedFiles = 0;
+        const totalFiles = this.inputFiles.length;
+        for (const { entryName, absPath, stat, displayPath, isSymlink, linkTarget, isHardLink, originalEntry, inode } of this.inputFiles) {
+            if (this.options.debug) {
+                (0, utils_1.logDebug)(`Processing file: ${displayPath}`, this.options);
+                (0, utils_1.logDebug)(`  Entry name: ${entryName}`, this.options);
+                (0, utils_1.logDebug)(`  Absolute path: ${absPath}`, this.options);
+                (0, utils_1.logDebug)(`  File size: ${stat.size} bytes`, this.options);
+                (0, utils_1.logDebug)(`  File stats: ${JSON.stringify({
+                    isFile: stat.isFile(),
+                    isDirectory: stat.isDirectory(),
+                    mode: stat.mode,
+                    mtime: stat.mtime.toISOString(),
+                    atime: stat.atime.toISOString(),
+                    ctime: stat.ctime.toISOString()
+                })}`, this.options);
+            }
+            if (this.options.progress && !this.options.quiet) {
+                (0, utils_1.log)(`📦 Processing file ${processedFiles + 1}/${totalFiles}: ${displayPath}`, this.options);
+            }
+            if (this.options.showFiles && !this.options.quiet) {
+                (0, utils_1.log)(`adding: ${entryName}`, this.options);
+            }
+            const entry = this.zip.createZipEntry(entryName);
+            if (this.options.debug) {
+                (0, utils_1.logDebug)(`  Creating ZIP entry for: ${entryName}`, this.options);
+            }
+            // Set the timestamp directly from file modification time
+            // @ts-ignore neozipkit ZipEntry has method setDateTime at runtime
+            entry.timeDateDOS = entry.setDateTime(new Date(stat.mtimeMs));
+            if (this.options.debug) {
+                (0, utils_1.logDebug)(`  Set timestamp: ${new Date(stat.mtimeMs).toISOString()}`, this.options);
+                (0, utils_1.logDebug)(`  Set DOS timestamp: ${entry.timeDateDOS}`, this.options);
+            }
+            // Also set lastModTimeDate for better compatibility (same as timeDateDOS)
+            entry.lastModTimeDate = entry.timeDateDOS;
+            // Set extended timestamps for better accuracy on Unix/Mac systems
+            // Try to set extended timestamps if the properties exist
+            try {
+                // @ts-ignore neozipkit ZipEntry may have extended timestamp properties
+                entry.ntfsTime = {
+                    mtime: stat.mtimeMs,
+                    atime: stat.atimeMs,
+                    ctime: stat.ctimeMs
+                };
+            }
+            catch (e) {
+                // Property may not exist, that's okay
+            }
+            try {
+                // @ts-ignore neozipkit ZipEntry may have extended timestamp properties
+                entry.extendedTime = {
+                    mtime: stat.mtimeMs,
+                    atime: stat.atimeMs,
+                    ctime: stat.ctimeMs
+                };
+            }
+            catch (e) {
+                // Property may not exist, that's okay
+            }
+            // Preserve UID/GID if requested (Unix-like systems only)
+            if (this.options.preservePerms && process.platform !== 'win32') {
+                try {
+                    // @ts-ignore fs.Stats has uid and gid on Unix systems
+                    entry.uid = stat.uid;
+                    // @ts-ignore fs.Stats has uid and gid on Unix systems  
+                    entry.gid = stat.gid;
+                    if (this.options.debug) {
+                        (0, utils_1.logDebug)(`  Preserved permissions: uid=${entry.uid}, gid=${entry.gid}`, this.options);
+                    }
+                }
+                catch (e) {
+                    if (this.options.debug) {
+                        (0, utils_1.logDebug)(`  Could not preserve permissions: ${e}`, this.options);
+                    }
+                }
+            }
+            // Handle symbolic links
+            if (isSymlink && linkTarget) {
+                // Mark entry as symbolic link and store target
+                entry.isSymlink = true;
+                entry.linkTarget = linkTarget;
+                // Set Unix file attributes for symbolic link (S_IFLNK | permissions)
+                const S_IFLNK = 0o120000; // Symbolic link file type
+                const permissions = stat.mode & 0o777; // Extract permission bits
+                entry.extFileAttr = (S_IFLNK | permissions) << 16;
+                // Set the uncompressed size to the length of the target path
+                entry.uncompressedSize = Buffer.byteLength(linkTarget, 'utf8');
+                if (this.options.debug) {
+                    (0, utils_1.logDebug)(`  Symbolic link: ${linkTarget}`, this.options);
+                    (0, utils_1.logDebug)(`  Link target size: ${entry.uncompressedSize} bytes`, this.options);
+                }
+            }
+            // Handle hard links
+            if (isHardLink && originalEntry && inode) {
+                // Mark entry as hard link and store reference to original
+                entry.isHardLink = true;
+                entry.originalEntry = originalEntry;
+                entry.inode = inode;
+                // For hard links, we don't store the file content again
+                // Set uncompressed size to 0 to indicate this is a link entry
+                entry.uncompressedSize = 0;
+                if (this.options.debug) {
+                    (0, utils_1.logDebug)(`  Hard link: ${entryName} -> ${originalEntry} (inode: ${inode})`, this.options);
+                    (0, utils_1.logDebug)(`  Link entry (no content stored)`, this.options);
+                }
+            }
+            // Debug: Check what setDateTime actually returns
+            if (process.env.DEBUG_UPDATE) {
+                console.log(`Setting timestamp for ${entryName}:`);
+                console.log(`  File mtime: ${stat.mtimeMs} (${new Date(stat.mtimeMs).toISOString()})`);
+                console.log(`  timeDateDOS set to: ${Math.floor(stat.mtimeMs / 1000)}`);
+                console.log(`  lastModTimeDate set to: ${Math.floor(stat.mtimeMs / 1000)}`);
+                console.log(`  Extended timestamps set: ntfsTime=${!!entry.ntfsTime}, extendedTime=${!!entry.extendedTime}`);
+            }
+            entry.uncompressedSize = stat.size;
+            // Mark entry as updated so it gets processed
+            entry.isUpdated = true;
+            // Entry is automatically added to zip.zipEntries[] by createZipEntry()
+            this.entryToPath.set(entryName, absPath);
+            this.entryToDisplay.set(entryName, displayPath);
+            this.entryToStats.set(entryName, stat);
+            if (this.options.verbose)
+                (0, utils_1.log)(`Queued: ${entryName} (${stat.size} bytes)`, this.options);
+            processedFiles++;
+        }
+    }
+    async setupCompression() {
+        // Handle password prompting for encryption
+        if (this.options.encrypt && this.options.password === 'PROMPT') {
+            (0, utils_1.log)('🔐 Encryption enabled - password required', this.options);
+            this.options.password = await (0, user_interaction_1.promptPassword)('Enter password: ');
+            if (!this.options.password) {
+                (0, utils_1.logError)('❌ Password is required for encryption');
+                (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.PARAMETER_ERROR);
+            }
+            (0, utils_1.log)('✅ Password set for encryption', this.options);
+        }
+    }
+    async handleComments() {
+        let commentOptions = {};
+        if (this.options.commentFile) {
+            (0, utils_1.log)('📝 Reading comments from file...', this.options);
+            const commentResult = await CommentManager_1.CommentManager.readCommentsFromFile(this.options.commentFile);
+            if (commentResult.success) {
+                commentOptions = {
+                    archiveComment: commentResult.archiveComment,
+                    fileComments: commentResult.fileComments
+                };
+                if (commentResult.archiveComment) {
+                    (0, utils_1.log)(`   Archive comment: ${commentResult.archiveComment.length} characters`, this.options);
+                }
+                if (commentResult.fileComments) {
+                    (0, utils_1.log)(`   File comments: ${Object.keys(commentResult.fileComments).length} files`, this.options);
+                }
+            }
+            else {
+                (0, utils_1.logError)(`❌ Error reading comment file: ${commentResult.error}`);
+                (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.READ_ERROR);
+            }
+        }
+        else if (this.options.archiveComment) {
+            commentOptions.archiveComment = this.options.archiveComment;
+            (0, utils_1.log)(`📝 Archive comment: ${this.options.archiveComment.length} characters`, this.options);
+        }
+        if (this.options.interactiveComments) {
+            (0, utils_1.log)('📝 Interactive comment mode enabled', this.options);
+            if (!commentOptions.archiveComment) {
+                commentOptions.archiveComment = await CommentManager_1.CommentManager.promptForArchiveComment();
+            }
+            const filenames = this.inputFiles.map(f => f.entryName);
+            const fileComments = await CommentManager_1.CommentManager.promptForFileComments(filenames);
+            if (Object.keys(fileComments).length > 0) {
+                commentOptions.fileComments = fileComments;
+            }
+        }
+        if (this.options.fileCommentsOnly) {
+            (0, utils_1.log)('📝 File comment mode enabled', this.options);
+            const filenames = this.inputFiles.map(f => f.entryName);
+            const fileComments = await CommentManager_1.CommentManager.promptForFileCommentsOnly(filenames);
+            if (Object.keys(fileComments).length > 0) {
+                commentOptions.fileComments = fileComments;
+            }
+        }
+        // Set archive comment option (will be applied during finalization)
+        if (commentOptions.archiveComment) {
+            this.options.archiveComment = commentOptions.archiveComment;
+            (0, utils_1.log)('✅ Archive comment set (will be applied during finalization)', this.options);
+        }
+        // Apply file comments to entries
+        if (commentOptions.fileComments) {
+            const entries = await this.zip.getDirectory() || [];
+            for (const [filename, comment] of Object.entries(commentOptions.fileComments)) {
+                const entry = entries.find((e) => e.filename === filename);
+                if (entry) {
+                    entry.comment = comment;
+                    if (this.options.verbose)
+                        (0, utils_1.log)(`   File comment set: ${filename}`, this.options);
+                }
+                else {
+                    (0, utils_1.logError)(`❌ File not found for comment: ${filename}`);
+                    (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.CANT_FIND_ARCHIVE);
+                }
+            }
+            (0, utils_1.log)('✅ File comments applied successfully', this.options);
+        }
+    }
+    async handleCompression() {
+        this.compressionOffset = await this.compressEntries();
+    }
+    /**
+     * Unified compression method for both in-memory and file-based modes
+     * Loops through zip.zipEntries[] directly (single source of truth for entry order)
+     */
+    async compressEntries() {
+        // Create compression options
+        const level = this.options.level ?? 6;
+        // Validate password exists when encryption is enabled
+        if (this.options.encrypt && !this.options.password) {
+            (0, utils_1.logError)('❌ Password is required for encryption');
+            throw new Error('Password is required for encryption');
+        }
+        const compressionOptions = {
+            level: level,
+            useZstd: level === 0 ? false : (this.options.compression || 'zstd') === 'zstd',
+            useSHA256: this.options.blockchain || this.options.blockchainOts || false,
+            password: this.options.encrypt ? this.options.password : null,
+            encryptionMethod: this.options.encryptionMethod || 'pkzip'
+        };
+        // Get entries from zip.getDirectory() (populated by processFiles())
+        // This is the single source of truth for entry order
+        const zipEntries = this.zip.getDirectory();
+        if (zipEntries.length === 0) {
+            (0, utils_1.log)('No files to compress', this.options);
+            return 0;
+        }
+        if (this.options.inMemory) {
+            // In-memory mode: use compressFileBuffer with BufferOutputWriter
+            (0, utils_1.log)(`🔧 Using in-memory compression (browser compatible)`, this.options);
+            (0, utils_1.log)(`🔄 Compressing ${zipEntries.length} files in memory...`, this.options);
+            // Create ZipkitNode instance for buffer-based compression
+            const zipkit = new node_1.default();
+            // Determine if we need to write to file (for blockchain mode)
+            const writeToFile = this.options.blockchain || this.options.blockchainOts;
+            // Create appropriate output writer
+            let writer;
+            const positionRef = { current: this.currentPosition };
+            if (writeToFile) {
+                // For blockchain mode, write directly to file
+                if (!this.zipWriter) {
+                    throw new Error('ZIP writer not initialized for blockchain mode');
+                }
+                // Start from currentPosition (should be 0 for new file, or existing position for append)
+                positionRef.current = this.currentPosition;
+                writer = new FileOutputWriter(this.archiveName, this.zipWriter.outputFd, this.zipWriter.outputStream, positionRef);
+            }
+            else {
+                // For non-blockchain mode, collect in memory
+                writer = new BufferOutputWriter();
+            }
+            // Compress each file using SEQUENTIAL write: header -> compress -> data -> update header
+            // Loop through zip.zipEntries[] directly (entries in processing order)
+            for (const entry of zipEntries) {
+                // Skip entries that aren't marked for update (e.g., preserved entries in update mode)
+                if (!entry.isUpdated) {
+                    continue;
+                }
+                // Read file data for this entry
+                const absPath = this.entryToPath.get(entry.filename);
+                if (!absPath) {
+                    (0, utils_1.logError)(`❌ Cannot find source path for entry: ${entry.filename}`);
+                    throw new Error(`Cannot find source path for entry: ${entry.filename}`);
+                }
+                try {
+                    // Read file data into memory
+                    let fileData = fs.readFileSync(absPath);
+                    // Apply line ending conversion if requested and file is a text file
+                    if ((this.options.toCrlf || this.options.fromCrlf) && (0, utils_1.isTextFile)(absPath)) {
+                        const originalSize = fileData.length;
+                        const convertedBuf = (0, utils_1.convertLineEndings)(fileData, this.options);
+                        fileData = Buffer.from(convertedBuf);
+                        if (this.options.verbose) {
+                            (0, utils_1.log)(`📝 Converted line endings: ${entry.filename} (${originalSize} -> ${fileData.length} bytes)`, this.options);
+                        }
+                    }
+                    // Step 1: Get header position BEFORE creating header (current file position)
+                    const headerPosition = writer.getPosition();
+                    entry.localHdrOffset = headerPosition;
+                    // Step 2: Set compression method BEFORE creating header
+                    // Determine compression method based on options
+                    if (compressionOptions.level === 0) {
+                        entry.cmpMethod = 0; // STORED
+                    }
+                    else if (compressionOptions.useZstd) {
+                        entry.cmpMethod = 93; // ZSTD
+                    }
+                    else {
+                        entry.cmpMethod = 8; // DEFLATED
+                    }
+                    // Step 3: Create local header with placeholder compressed size (0)
+                    entry.compressedSize = 0; // Placeholder - will be updated after compression
+                    const localHeader = entry.createLocalHdr();
+                    // Step 4: Write local header FIRST (with placeholder compressed size)
+                    await writer.writeHeader(localHeader);
+                    // Track entry position for central directory (position where header was written)
+                    // Note: For in-memory mode, positions are tracked in bufferWriter, not zipWriter
+                    if (this.zipWriter) {
+                        this.zipWriter.entryPositions.set(entry.filename || '', headerPosition);
+                    }
+                    // Step 5: Compress data (returns ONLY compressed data, no header)
+                    const compressedData = await zipkit.compressFileBuffer(entry, fileData, compressionOptions);
+                    // Update entry compressed size for statistics and central directory
+                    entry.compressedSize = compressedData.length;
+                    // Step 6: Write compressed data
+                    await writer.writeData(compressedData);
+                    // Step 7: Update CRC and compressed size in local header
+                    await writer.updateHeader(headerPosition, compressedData.length, entry.crc);
+                    // Update statistics
+                    this.totalIn += entry.uncompressedSize || 0;
+                    this.totalOut += entry.compressedSize || 0;
+                    this.filesCount += 1;
+                    // Accumulate SHA-256 hash as entries are added (for merkle root calculation)
+                    if (this.hashAccumulator && entry.sha256) {
+                        const filename = entry.filename || '';
+                        // Skip blockchain metadata files
+                        if (filename !== neozipkit_1.TOKENIZED_METADATA &&
+                            filename !== neozipkit_1.TIMESTAMP_METADATA &&
+                            filename !== neozipkit_1.TIMESTAMP_SUBMITTED) {
+                            const hashBuffer = Buffer.from(entry.sha256, 'hex');
+                            this.hashAccumulator.addHash(hashBuffer);
+                            if (this.options.verbose) {
+                                (0, utils_1.logDebug)(`Added SHA-256 hash to accumulator for ${filename}`, this.options);
+                            }
+                        }
+                    }
+                    // Entry is already in zip.zipEntries[] from processFiles(), updated with compression properties
+                    if (this.options.verbose) {
+                        const ratio = entry.uncompressedSize > 0 ? Math.round((1 - entry.compressedSize / entry.uncompressedSize) * 100) : 0;
+                        (0, utils_1.log)(`📦 Compressed: ${entry.filename} (${(0, utils_1.formatBytes)(entry.uncompressedSize)} -> ${(0, utils_1.formatBytes)(entry.compressedSize)} bytes, ${ratio}%)`, this.options);
+                    }
+                }
+                catch (error) {
+                    (0, utils_1.logError)(`❌ Failed to compress file ${entry.filename}: ${error instanceof Error ? error.message : String(error)}`);
+                    throw error;
+                }
+            }
+            // For non-blockchain mode, keep buffer open for metadata addition
+            // Metadata will be added before central directory in handleTokenization() and finalize()
+            if (!writeToFile) {
+                // Store buffer writer for later use (metadata addition and finalization)
+                // For in-memory non-blockchain mode, we'll write the complete ZIP file in finalize()
+                // after metadata is added
+                this.zip.bufferWriter = writer;
+                this.currentPosition = writer.getPosition();
+            }
+            else {
+                // For blockchain mode, update currentPosition from FileOutputWriter
+                // The FileOutputWriter updates positionRef.current as it writes
+                // Sync this.currentPosition with the actual file position
+                this.currentPosition = positionRef.current;
+                // Note: Do NOT close the stream here - it needs to remain open
+                // so that metadata can be added and finalize() can write central directory
+                if (this.options.verbose) {
+                    (0, utils_1.log)(`📊 Compression completed at file position: ${this.currentPosition}`, this.options);
+                }
+            }
+            return writer.getPosition();
+        }
+        else {
+            // File-based mode: use ZipkitNode's writeZipEntry() method
+            // Get entries to compress from zip.getDirectory() (populated by processFiles())
+            const zipEntries = this.zip.getDirectory().length > 0 ? this.zip.getDirectory() : await this.zip.getDirectory() || [];
+            if (zipEntries.length === 0) {
+                (0, utils_1.logError)('❌ No files to compress');
+                (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.NO_FILES_MATCHED);
+            }
+            if (!this.zipWriter) {
+                throw new Error('ZIP writer not initialized for file-based mode');
+            }
+            const cmpOptions = {
+                ...compressionOptions,
+                bufferSize: this.options.blockSize || 512 * 1024 // Default 512KB buffer
+            };
+            if (this.options.verbose) {
+                (0, utils_1.log)(`🔧 Using file-based compression with ${(0, utils_1.formatBytes)(cmpOptions.bufferSize)} buffer`, this.options);
+            }
+            try {
+                // Loop through entries and process each one
+                let entryCnt = zipEntries.length;
+                for (let index = 0; index < entryCnt; index++) {
+                    const entry = zipEntries[index];
+                    // Filter out metadata entries (handled separately in handleTokenization)
+                    if (entry.filename === neozipkit_1.TOKENIZED_METADATA ||
+                        entry.filename === neozipkit_1.TIMESTAMP_METADATA ||
+                        entry.filename === neozipkit_1.TIMESTAMP_SUBMITTED) {
+                        zipEntries.splice(index, 1);
+                        entryCnt--;
+                        index--;
+                        if (this.options.verbose) {
+                            (0, utils_1.log)(`Deleting Metadata entry: ${entry.filename}`, this.options);
+                        }
+                        continue;
+                    }
+                    // Handle non-updated entries: copy from existing ZIP
+                    if (!entry.isUpdated) {
+                        if (this.options.verbose) {
+                            (0, utils_1.log)(`Copying Entry: ${entry.filename}`, this.options);
+                        }
+                        entry.localHdrOffset = this.zipWriter.currentPosition;
+                        const inData = await this.zip.copyEntry(entry);
+                        await this.writeChunk(inData);
+                        // Update entry position tracking
+                        this.zipWriter.entryPositions.set(entry.filename || '', entry.localHdrOffset);
+                        // Update statistics
+                        this.totalIn += entry.uncompressedSize || 0;
+                        this.totalOut += entry.compressedSize || entry.uncompressedSize || 0;
+                        this.filesCount += 1;
+                        if (this.options.verbose) {
+                            const actionPath = this.entryToDisplay.get(entry.filename) || entry.filename;
+                            (0, utils_1.log)(`adding: ${actionPath} (copied, no recompression)`, this.options);
+                        }
+                        continue;
+                    }
+                    // Handle updated entries: use writeZipEntry() for compression
+                    const filePath = this.entryToPath.get(entry.filename);
+                    if (!filePath) {
+                        throw new Error(`Cannot find source path for entry: ${entry.filename}`);
+                    }
+                    // Check for pre-loaded buffer (symlinks, hardlinks, line-ending conversion)
+                    // If we have a pre-loaded buffer, we need to compress it directly
+                    let fileBuffer = null;
+                    if (entry.fileBuffer) {
+                        fileBuffer = entry.fileBuffer;
+                    }
+                    // Use writeZipEntry() for regular file compression
+                    // For pre-loaded buffers, we'll need to handle them specially
+                    if (fileBuffer) {
+                        // For pre-loaded buffers, compress in memory and write manually
+                        // This handles symlinks, hardlinks, and line-ending conversion
+                        const zipkit = new node_1.default();
+                        const cmpData = await zipkit.compressData(entry, fileBuffer, cmpOptions);
+                        // Write header manually
+                        entry.compressedSize = 0; // Placeholder
+                        entry.localHdrOffset = this.zipWriter.currentPosition;
+                        const localHdr = entry.createLocalHdr();
+                        await this.writeChunk(localHdr);
+                        this.zipWriter.entryPositions.set(entry.filename || '', entry.localHdrOffset);
+                        // Write compressed data
+                        await this.writeChunk(cmpData);
+                        // Update header with actual compressed size
+                        entry.compressedSize = cmpData.length;
+                        const compressedSizeOffset = entry.localHdrOffset + 18;
+                        const sizeBuffer = Buffer.alloc(4);
+                        sizeBuffer.writeUInt32LE(entry.compressedSize, 0);
+                        fs.writeSync(this.zipWriter.outputFd, sizeBuffer, 0, 4, compressedSizeOffset);
+                        if (entry.crc !== undefined) {
+                            const crcOffset = entry.localHdrOffset + 14;
+                            const crcBuffer = Buffer.alloc(4);
+                            crcBuffer.writeUInt32LE(entry.crc, 0);
+                            fs.writeSync(this.zipWriter.outputFd, crcBuffer, 0, 4, crcOffset);
+                        }
+                    }
+                    else {
+                        // Use writeZipEntry() for regular file compression
+                        await this.zip.writeZipEntry(this.zipWriter, entry, filePath, cmpOptions, {
+                            onProgress: (entry, bytes) => {
+                                // Progress tracking if needed
+                            },
+                            onHashCalculated: (entry, hash) => {
+                                // Accumulate SHA-256 hash for blockchain
+                                if (this.hashAccumulator) {
+                                    const filename = entry.filename || '';
+                                    // Skip blockchain metadata files
+                                    if (filename !== neozipkit_1.TOKENIZED_METADATA &&
+                                        filename !== neozipkit_1.TIMESTAMP_METADATA &&
+                                        filename !== neozipkit_1.TIMESTAMP_SUBMITTED) {
+                                        this.hashAccumulator.addHash(hash);
+                                        if (this.options.verbose) {
+                                            (0, utils_1.logDebug)(`Added SHA-256 hash to accumulator for ${filename}`, this.options);
+                                        }
+                                    }
+                                }
+                            }
+                        });
+                    }
+                    // Update currentPosition from zipWriter
+                    this.currentPosition = this.zipWriter.currentPosition;
+                    // Update statistics
+                    this.totalIn += entry.uncompressedSize || 0;
+                    this.totalOut += entry.compressedSize || 0;
+                    this.filesCount += 1;
+                    // Log progress
+                    const compressed = entry.uncompressedSize && entry.uncompressedSize > 0
+                        ? Math.max(0, Math.round((1 - (entry.compressedSize / entry.uncompressedSize)) * 100))
+                        : 0;
+                    const method = entry.cmpMethod === 0 ? 'stored' : (entry.cmpMethod === 93 ? 'zstd' : 'deflated');
+                    const actionPath = this.entryToDisplay.get(entry.filename) || entry.filename;
+                    (0, utils_1.log)(`adding: ${actionPath} (${method} ${compressed}%)`, this.options);
+                }
+            }
+            finally {
+                // Always cleanup file descriptors
+                await this.cleanupFileDescriptors();
+            }
+            if (this.options.verbose) {
+                (0, utils_1.log)(`📊 Compression completed at file position: ${this.currentPosition}`, this.options);
+            }
+            // Return the current file position
+            return this.currentPosition;
+        }
+    }
+    async addTokenMetadataDirectly(tokenMeta) {
+        // Create token metadata JSON
+        const tokenContent = JSON.stringify(tokenMeta, null, 2);
+        const tokenBuffer = Buffer.from(tokenContent, 'utf8');
+        const tokenPath = 'META-INF/NZIP.TOKEN';
+        console.log('✅ Token metadata prepared for ZIP');
+        console.log(`📄 Token content:\n${tokenContent}`);
+        // Create local file header for token metadata
+        const tokenEntry = this.zip.createZipEntry(tokenPath);
+        tokenEntry.timeDateDOS = tokenEntry.setDateTime(new Date());
+        tokenEntry.compressedSize = tokenBuffer.length;
+        tokenEntry.uncompressedSize = tokenBuffer.length;
+        tokenEntry.cmpMethod = 0; // STORED (no compression for small metadata file)
+        tokenEntry.crc = (0, neozipkit_1.crc32)(tokenBuffer);
+        // Use current file position for local header offset (not compressionOffset)
+        tokenEntry.localHdrOffset = this.currentPosition;
+        // Track entry position for central directory
+        if (this.zipWriter) {
+            this.zipWriter.entryPositions.set(tokenPath, this.currentPosition);
+        }
+        // Create local header
+        const localHdr = tokenEntry.createLocalHdr();
+        // Write token metadata directly to file (at the end, just before central directory)
+        await this.writeChunk(localHdr);
+        await this.writeChunk(tokenBuffer);
+        // Token entry is automatically added to zip.zipEntries[] by createZipEntry()
+        // Since it's added last, it will appear last in the central directory
+        console.log(`✅ Token metadata added to ZIP (${tokenBuffer.length} bytes)`);
+        return tokenEntry;
+    }
+    /**
+     * Calculate merkle root from ZIP entries with SHA-256 hashes
+     * Excludes blockchain metadata files (META-INF/*) to ensure consistent calculation
+     */
+    calculateMerkleRootFromEntries(entries) {
+        if (!entries || entries.length === 0) {
+            return null;
+        }
+        const hashAccumulator = new neozipkit_1.HashCalculator({ enableAccumulation: true });
+        // Filter out blockchain metadata files to ensure consistent Merkle Root calculation
+        const contentEntries = entries.filter(entry => {
+            const filename = entry.filename || '';
+            return filename !== neozipkit_1.TOKENIZED_METADATA &&
+                filename !== neozipkit_1.TIMESTAMP_METADATA &&
+                filename !== neozipkit_1.TIMESTAMP_SUBMITTED;
+        });
+        // Add SHA-256 hashes to accumulator
+        for (const entry of contentEntries) {
+            if (entry.sha256) {
+                // Convert hex string to Buffer
+                const hashBuffer = Buffer.from(entry.sha256, 'hex');
+                hashAccumulator.addHash(hashBuffer);
+            }
+        }
+        const merkleRoot = hashAccumulator.merkleRoot();
+        return merkleRoot;
+    }
+    async handleTokenization() {
+        let tokenMeta = null;
+        let tokenInfoEntry = null;
+        let otsMetaEntry = null;
+        let merkleRoot = null;
+        if (this.options.blockchain) {
+            // Check for wallet passkey AFTER compression is complete
+            // Priority: -w option > wallet.json > environment variable
+            // Don't show error yet - we'll prompt user if key is missing
+            const walletPasskey = (0, blockchain_2.getWalletPasskey)(this.options.walletKey, false);
+            if (!walletPasskey) {
+                // Show error message and prompt user
+                console.error('\n❌ Error: Wallet private key is required for blockchain operations');
+                console.error('');
+                console.error('   Option 1 (Recommended): Run interactive setup');
+                console.error('   $ neozip init');
+                console.error('');
+                console.error('   Option 2: Use command-line flag');
+                console.error('   $ neozip -b -w 0x... <archive> <files>');
+                console.error('');
+                console.error('   Option 3: Set environment variable');
+                console.error('   $ export NEOZIP_WALLET_PASSKEY="0x..."');
+                console.error('');
+                console.error('   Get testnet ETH from: https://www.coinbase.com/faucets/base-ethereum-sepolia-faucet');
+                console.error('');
+                // Prompt user to continue without blockchain tokenization
+                if (!this.options.nonInteractive) {
+                    const answer = await (0, user_interaction_1.promptUser)('Continue without blockchain tokenization? (y/n): ');
+                    if (answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes') {
+                        (0, utils_1.log)('⚠️  Continuing without blockchain tokenization (ZIP file is already created)...', this.options);
+                        this.options.blockchain = false;
+                        this.options.blockchainOts = false;
+                        return; // Skip tokenization, ZIP is already complete
+                    }
+                    else {
+                        (0, utils_1.logError)('💡 Tip: Run "neozip init" to set up your wallet configuration');
+                        (0, utils_1.logError)('💡 Tip: Omit blockchain flags to create ZIP without blockchain operations');
+                        (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.PARAMETER_ERROR);
+                    }
+                }
+                else {
+                    // Non-interactive mode - exit with error
+                    (0, utils_1.logError)('💡 Tip: Run "neozip init" to set up your wallet configuration');
+                    (0, utils_1.logError)('💡 Tip: Omit blockchain flags to create ZIP without blockchain operations');
+                    (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.PARAMETER_ERROR);
+                }
+            }
+            else {
+                // Wallet key is available, store it for use
+                this.options.walletPasskey = walletPasskey;
+            }
+            if (this.options.debug) {
+                (0, utils_1.logDebug)('Tokenization process starting...', this.options);
+            }
+            // Calculate merkle root from accumulated hashes (if available) or from entries
+            if (this.hashAccumulator && this.hashAccumulator.leafCount() > 0) {
+                // Use accumulated hashes (calculated incrementally during compression)
+                merkleRoot = this.hashAccumulator.merkleRoot();
+                if (this.options.verbose) {
+                    console.log(`✅ Calculated merkle root from ${this.hashAccumulator.leafCount()} accumulated SHA-256 hashes`);
+                }
+            }
+            else {
+                // Fallback: Calculate from entries (for updates or in-memory mode)
+                let entriesForMerkle = [];
+                const zipEntries = this.zip.getDirectory();
+                if (zipEntries.length > 0) {
+                    // New ZIP creation (file-based) - use entries we created (they have SHA-256 hashes from compression)
+                    entriesForMerkle = zipEntries;
+                }
+                else {
+                    // Update mode OR in-memory mode - load ZIP file and get entries
+                    // For in-memory mode, the ZIP file was already written to disk by createZipInMemory()
+                    try {
+                        if (fs.existsSync(this.archiveName)) {
+                            // Load the ZIP file to get entries with SHA-256 hashes
+                            const zipkit = new node_1.default();
+                            if (this.options.inMemory) {
+                                // For in-memory mode, load as buffer
+                                const zipBuffer = fs.readFileSync(this.archiveName);
+                                zipkit.loadZip(zipBuffer);
+                            }
+                            else {
+                                // For file-based mode
+                                await zipkit.loadZipFile(this.archiveName);
+                            }
+                            entriesForMerkle = zipkit.getDirectory() || [];
+                        }
+                        else {
+                            // Update mode - get entries from loaded ZIP
+                            entriesForMerkle = await this.zip.getDirectory() || [];
+                        }
+                    }
+                    catch (error) {
+                        console.error('❌ Error loading ZIP file for merkle root calculation:', error instanceof Error ? error.message : String(error));
+                        // Fallback to getting entries from this.zip
+                        entriesForMerkle = await this.zip.getDirectory() || [];
+                    }
+                }
+                // Calculate merkle root from entries
+                merkleRoot = this.calculateMerkleRootFromEntries(entriesForMerkle);
+            }
+            if (!merkleRoot) {
+                console.error('❌ Error: Could not calculate merkle root for tokenization');
+                console.error('   This is required for blockchain operations.');
+                console.error('   Make sure files have been compressed with SHA-256 hashes.');
+                if (this.options.verbose) {
+                    const hashCount = this.hashAccumulator ? this.hashAccumulator.leafCount() : 0;
+                    console.error(`   Found ${hashCount} accumulated SHA-256 hashes`);
+                }
+                (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.BAD_ARCHIVE_FORMAT);
+            }
+            if (this.options.verbose && this.hashAccumulator) {
+                console.log(`✅ Calculated merkle root from ${this.hashAccumulator.leafCount()} accumulated SHA-256 hashes`);
+            }
+            if (merkleRoot) {
+                console.log(`\n📋 Merkle Root: ${merkleRoot}`);
+                // Validate network
+                const network = this.options.network || 'base-sepolia';
+                // Always display network when tokenization is enabled
+                console.log(`🌐 Network: ${network}`);
+                // Get network config for contract address and version info
+                const networkConfig = (0, blockchain_1.getNetworkByName)(network);
+                let contractAddress;
+                let networkChainId;
+                let contractVersion;
+                if (networkConfig) {
+                    contractAddress = networkConfig.address;
+                    networkChainId = networkConfig.chainId;
+                    // Determine contract version: v2.11+ has version in config, prior versions are "unknown"
+                    const versionStr = networkConfig.version || '0';
+                    const versionNum = parseFloat(versionStr);
+                    contractVersion = versionNum >= 2.11 ? versionStr : 'unknown';
+                }
+                else {
+                    // Fallback to default (Base Sepolia)
+                    const defaultConfig = (0, blockchain_1.getContractConfig)(84532);
+                    contractAddress = defaultConfig.address;
+                    networkChainId = defaultConfig.chainId;
+                    const versionStr = defaultConfig.version || '0';
+                    const versionNum = parseFloat(versionStr);
+                    contractVersion = versionNum >= 2.11 ? versionStr : 'unknown';
+                }
+                // Display contract address and version right after network
+                console.log(`📄 Contract: ${contractAddress}`);
+                console.log(`🔢 Version: ${contractVersion}`);
+                if (!(0, blockchain_2.isSupportedNetwork)(network)) {
+                    const supportedNetworks = (0, blockchain_1.getSupportedNetworkNames)();
+                    console.error(`❌ Error: Unsupported network: ${network}`);
+                    console.error(`   Currently supported networks: ${supportedNetworks.join(', ')}`);
+                    (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.BLOCKCHAIN_CONFIG_ERROR);
+                }
+                let minter = null;
+                try {
+                    // Initialize blockchain minter
+                    minter = new neozipkit_1.ZipkitMinter(merkleRoot, {
+                        network: network,
+                        walletPrivateKey: this.options.walletPasskey,
+                        verbose: this.options.verbose,
+                        debug: this.options.verbose || this.options.debug || process.env.NEOZIP_DEBUG === 'true' // Enable debug output
+                    });
+                    // Start the minting process (checks duplicates, gets wallet info, estimates gas)
+                    console.log('🔗 Connecting to blockchain network...');
+                    const processResult = await Promise.race([
+                        minter.processMinting(),
+                        new Promise((_, reject) => setTimeout(() => reject(new Error('Network connection timeout after 30 seconds. The RPC endpoint may be slow or unreachable.')), 30000))
+                    ]);
+                    console.log(`💳 Wallet: ${processResult.walletInfo.address}`);
+                    console.log(`💰 Balance: ${processResult.walletInfo.balance} ETH`);
+                    // Network config already retrieved above (contractAddress and networkChainId are available)
+                    // Check if tokens already exist for this merkle root
+                    if (processResult.duplicateCheck.hasExistingTokens) {
+                        let userChoice;
+                        if (this.options.blockchainMint) {
+                            // Force mint new token
+                            console.log('\n🔨 Force minting new token (--blockchain-mint)');
+                            userChoice = { action: 'mint-new' };
+                        }
+                        else if (this.options.blockchainDefault) {
+                            // Auto-select default option
+                            if (processResult.duplicateCheck.userOwnedTokens.length > 0) {
+                                // Use the earliest token owned by user
+                                const earliestToken = processResult.duplicateCheck.userOwnedTokens[0];
+                                console.log(`\n✅ Auto-selecting existing token ID ${earliestToken.tokenId} (--blockchain-default)`);
+                                userChoice = { action: 'use-existing', selectedToken: earliestToken };
+                            }
+                            else {
+                                // No user-owned tokens, mint new
+                                console.log('\n🔨 No user-owned tokens found, minting new token (--blockchain-default)');
+                                userChoice = { action: 'mint-new' };
+                            }
+                        }
+                        else {
+                            // Present user with choices (interactive mode)
+                            userChoice = await (0, user_interaction_1.getUserTokenChoice)(processResult.duplicateCheck, {
+                                contractAddress,
+                                version: contractVersion
+                            });
+                        }
+                        if (userChoice.action === 'use-existing' && userChoice.selectedToken) {
+                            console.log(`\n✅ Using existing token ID ${userChoice.selectedToken.tokenId}`);
+                            // Create TokenMetadata from selected existing token  
+                            // Use a fixed timestamp for existing tokens to ensure consistency
+                            // Network config already retrieved above
+                            tokenMeta = {
+                                contractVersion: contractVersion,
+                                tokenId: userChoice.selectedToken.tokenId,
+                                contractAddress: contractAddress,
+                                network: processResult.walletInfo.networkName,
+                                networkChainId: networkChainId,
+                                transactionHash: userChoice.selectedToken.tokenData?.transactionHash || '',
+                                merkleRoot: merkleRoot,
+                                encryptedHash: undefined, // Currently unused
+                                mintedAt: '2025-01-01T00:00:00.000Z' // Fixed timestamp for existing tokens
+                            };
+                            // Add token metadata to ZIP (after compression, at the end)
+                            console.log('\n📄 Adding token metadata to ZIP...');
+                            if (tokenMeta) {
+                                tokenInfoEntry = await this.addTokenMetadataDirectly(tokenMeta);
+                                // Token entry is automatically added to zip.zipEntries[] by addTokenMetadataDirectly() -> createZipEntry()
+                            }
+                            // Cleanup provider to allow process to exit
+                            minter.destroy();
+                        }
+                        else if (userChoice.action === 'mint-new') {
+                            // Mint new token
+                            const mintResult = await (0, blockchain_2.handleTokenMinting)(minter, this.zip, this.options.nonInteractive || false, 0);
+                            if (mintResult.success && mintResult.tokenInfo) {
+                                tokenMeta = mintResult.tokenInfo;
+                                // Add token metadata directly to ZIP (after compression, at the end)
+                                console.log('\n📄 Adding token metadata to ZIP...');
+                                tokenInfoEntry = await this.addTokenMetadataDirectly(tokenMeta);
+                                // Token entry is automatically added to zip.zipEntries[] by addTokenMetadataDirectly() -> createZipEntry()
+                            }
+                            else {
+                                console.error('❌ Failed to mint new token');
+                                console.error('⚠️  Continuing with ZIP creation without token metadata...');
+                                tokenMeta = null;
+                                tokenInfoEntry = null;
+                            }
+                            // Cleanup provider to allow process to exit
+                            minter.destroy();
+                        }
+                        else if (userChoice.action === 'skip-tokenization') {
+                            // Skip tokenization - create ZIP without token metadata
+                            console.log('\n⏭️  Skipping tokenization - creating ZIP without token metadata');
+                            tokenMeta = null;
+                            tokenInfoEntry = null;
+                            // Cleanup provider to allow process to exit
+                            if (minter) {
+                                minter.destroy();
+                            }
+                        }
+                        else {
+                            console.log('❌ Operation cancelled by user');
+                            if (minter) {
+                                minter.destroy();
+                            }
+                            (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.TOKEN_MINT_USER_CANCELLED);
+                        }
+                    }
+                    else {
+                        // No existing tokens, mint new one
+                        const mintResult = await (0, blockchain_2.handleTokenMinting)(minter, this.zip, this.options.nonInteractive || false, 0);
+                        if (mintResult.success && mintResult.tokenInfo) {
+                            tokenMeta = mintResult.tokenInfo;
+                            // Add token metadata directly to ZIP (after compression, at the end)
+                            console.log('\n📄 Adding token metadata to ZIP...');
+                            tokenInfoEntry = await this.addTokenMetadataDirectly(tokenMeta);
+                            // Token entry is automatically added to zip.zipEntries[] by addTokenMetadataDirectly() -> createZipEntry()
+                        }
+                        else {
+                            console.error('❌ Failed to mint new token');
+                            console.error('⚠️  Continuing with ZIP creation without token metadata...');
+                            tokenMeta = null;
+                            tokenInfoEntry = null;
+                        }
+                        // Cleanup provider to allow process to exit
+                        minter.destroy();
+                    }
+                }
+                catch (error) {
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    console.error(`❌ Blockchain error: ${errorMessage}`);
+                    // Provide helpful guidance for timeout errors
+                    if (errorMessage.includes('timeout')) {
+                        console.error('');
+                        console.error('💡 Troubleshooting tips:');
+                        console.error('   1. Check your internet connection');
+                        console.error('   2. The RPC endpoint may be slow or unreachable');
+                        console.error('   3. Try using a different network or RPC endpoint');
+                        console.error('   4. Use --verbose or --debug for more details');
+                        console.error('');
+                    }
+                    console.error('⚠️  Continuing with ZIP creation without token metadata...');
+                    tokenMeta = null;
+                    tokenInfoEntry = null;
+                }
+                finally {
+                    // Always cleanup provider to allow process to exit, even on error
+                    // Note: Some paths already call destroy() above, but this ensures cleanup on all paths
+                    if (minter) {
+                        try {
+                            minter.destroy();
+                        }
+                        catch (error) {
+                            // Ignore errors during cleanup
+                        }
+                    }
+                }
+            }
+        }
+        else if (this.options.blockchainOts) {
+            // Handle OpenTimestamp for Bitcoin blockchain
+            if (this.options.debug) {
+                (0, utils_1.logDebug)('OpenTimestamp process starting...', this.options);
+            }
+            console.log('🔗 OpenTimestamp: Creating timestamp proof on Bitcoin blockchain...');
+            // Calculate merkle root for OpenTimestamp from accumulated hashes (if available) or from entries
+            let merkleRoot = null;
+            if (this.hashAccumulator && this.hashAccumulator.leafCount() > 0) {
+                // Use accumulated hashes (calculated incrementally during compression)
+                merkleRoot = this.hashAccumulator.merkleRoot();
+                if (this.options.verbose) {
+                    console.log(`✅ Calculated merkle root from ${this.hashAccumulator.leafCount()} accumulated SHA-256 hashes`);
+                }
+            }
+            else {
+                // Fallback: Calculate from entries (for updates or in-memory mode)
+                let entriesForMerkle = [];
+                const zipEntries = this.zip.getDirectory();
+                if (zipEntries.length > 0) {
+                    // New ZIP creation (file-based) - use entries we created (they have SHA-256 hashes from compression)
+                    entriesForMerkle = zipEntries;
+                }
+                else {
+                    // Update mode OR in-memory mode - load ZIP file and get entries
+                    // For in-memory mode, the ZIP file was already written to disk by createZipInMemory()
+                    try {
+                        if (fs.existsSync(this.archiveName)) {
+                            // Load the ZIP file to get entries with SHA-256 hashes
+                            const zipkit = new node_1.default();
+                            if (this.options.inMemory) {
+                                // For in-memory mode, load as buffer
+                                const zipBuffer = fs.readFileSync(this.archiveName);
+                                zipkit.loadZip(zipBuffer);
+                            }
+                            else {
+                                // For file-based mode
+                                await zipkit.loadZipFile(this.archiveName);
+                            }
+                            entriesForMerkle = zipkit.getDirectory() || [];
+                        }
+                        else {
+                            // Update mode - get entries from loaded ZIP
+                            entriesForMerkle = await this.zip.getDirectory() || [];
+                        }
+                    }
+                    catch (error) {
+                        console.error('❌ Error loading ZIP file for merkle root calculation:', error instanceof Error ? error.message : String(error));
+                        // Fallback to getting entries from this.zip
+                        entriesForMerkle = await this.zip.getDirectory() || [];
+                    }
+                }
+                // Calculate merkle root from entries
+                merkleRoot = this.calculateMerkleRootFromEntries(entriesForMerkle);
+            }
+            if (!merkleRoot) {
+                console.error('❌ Error calculating merkle root for OpenTimestamp');
+                console.error('   Make sure files have been compressed with SHA-256 hashes.');
+                if (this.options.verbose) {
+                    const hashCount = this.hashAccumulator ? this.hashAccumulator.leafCount() : 0;
+                    console.error(`   Found ${hashCount} accumulated SHA-256 hashes`);
+                }
+                (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.BAD_ARCHIVE_FORMAT);
+            }
+            if (this.options.verbose && this.hashAccumulator) {
+                console.log(`✅ Calculated merkle root from ${this.hashAccumulator.leafCount()} accumulated SHA-256 hashes`);
+            }
+            if (merkleRoot) {
+                console.log(`📋 Merkle Root: ${merkleRoot}`);
+                // Create actual OpenTimestamp proof
+                try {
+                    const otsProof = await (0, neozipkit_1.createTimestamp)(merkleRoot, { debug: this.options.verbose });
+                    if (!otsProof) {
+                        throw new Error('Failed to create OpenTimestamp proof');
+                    }
+                    console.log('📄 OpenTimestamp metadata prepared');
+                    // Use the createOtsMetadataEntry function like in the example
+                    const metaEntry = (0, blockchain_1.createOtsMetadataEntry)(this.zip, otsProof);
+                    if (metaEntry) {
+                        // Ensure the filename is set correctly
+                        metaEntry.filename = neozipkit_1.TIMESTAMP_SUBMITTED;
+                        // Ensure OTS entry uses STORED compression (no compression for small metadata file)
+                        metaEntry.cmpMethod = 0; // STORED
+                        metaEntry.compressedSize = metaEntry.fileBuffer?.length || metaEntry.uncompressedSize || 0;
+                        if (this.options.verbose) {
+                            console.log(`📂 Final timestamp entry: ${metaEntry.filename}`);
+                            console.log(`📏 Final timestamp entry size: ${metaEntry.fileBuffer?.length || metaEntry.uncompressedSize || 0} bytes`);
+                        }
+                        console.log('✅ OpenTimestamp proof created and queued for inclusion');
+                        // Use current file position for local header offset
+                        metaEntry.localHdrOffset = this.currentPosition;
+                        // Record the position for this entry
+                        if (this.zipWriter) {
+                            this.zipWriter.entryPositions.set(metaEntry.filename, this.currentPosition);
+                        }
+                        // Create local header (must be done after setting all entry properties)
+                        const localHdr = metaEntry.createLocalHdr();
+                        if (this.options.verbose) {
+                            (0, utils_1.log)(`📝 Writing OTS entry: ${metaEntry.filename} at offset ${this.currentPosition}`, this.options);
+                            (0, utils_1.log)(`📊 OTS entry size: ${metaEntry.fileBuffer?.length || 0} bytes`, this.options);
+                        }
+                        // Write local header and file data
+                        await this.writeChunk(localHdr);
+                        if (metaEntry.fileBuffer) {
+                            await this.writeChunk(metaEntry.fileBuffer);
+                        }
+                        // OTS entry is automatically added to zip.zipEntries[] by createZipEntry()
+                        // Store the metadata entry
+                        otsMetaEntry = metaEntry;
+                    }
+                    else {
+                        console.warn('⚠️  Warning: Failed to create timestamp metadata entry');
+                    }
+                }
+                catch (error) {
+                    console.error('❌ Failed to create OpenTimestamp proof:', error instanceof Error ? error.message : String(error));
+                    throw error;
+                }
+            }
+        }
+    }
+    async finalize() {
+        // Check if this is in-memory non-blockchain mode (needs special handling)
+        if (this.options.inMemory && !this.options.blockchain && !this.options.blockchainOts) {
+            // For in-memory non-blockchain mode, write complete ZIP file from buffer
+            // Metadata should already be in the buffer (added via writeChunk() in handleTokenization())
+            const bufferWriter = this.zip.bufferWriter;
+            if (bufferWriter) {
+                const zipData = bufferWriter.getResult();
+                if (zipData) {
+                    // Create central directory from zip.getDirectory() in the SAME order as data section
+                    // Files are written first during compression, then token metadata is added
+                    // So getDirectory() is already in the correct order (data section order)
+                    const zipEntries = this.zip.getDirectory();
+                    const centralDirChunks = [];
+                    for (const entry of zipEntries) {
+                        const centralDirEntry = entry.centralDirEntry();
+                        centralDirChunks.push(centralDirEntry);
+                    }
+                    const centralDir = Buffer.concat(centralDirChunks);
+                    // Create end of central directory record
+                    const endOfCentralDir = createEndOfCentralDirRecord(zipEntries.length, centralDir.length, zipData.length, this.options.archiveComment || '');
+                    // Combine everything: ZIP data (includes metadata) + Central Directory + End of Central Directory
+                    const completeZip = Buffer.concat([zipData, centralDir, endOfCentralDir]);
+                    // Write ZIP file to temporary file first (for atomic operation)
+                    if (!this.tempArchiveName) {
+                        throw new Error('Temp archive name not initialized');
+                    }
+                    fs.writeFileSync(this.tempArchiveName, completeZip);
+                    // Atomically move temp file to final location
+                    fs.renameSync(this.tempArchiveName, this.archiveName);
+                    // Apply old timestamp if requested
+                    if (this.options.oldTimestamp) {
+                        try {
+                            const oldestTime = await (0, file_operations_1.findOldestEntryTime)(this.zip);
+                            if (oldestTime) {
+                                fs.utimesSync(this.archiveName, oldestTime, oldestTime);
+                                if (this.options.verbose) {
+                                    (0, utils_1.log)(`📅 Set archive timestamp to oldest entry: ${oldestTime.toISOString()}`, this.options);
+                                }
+                            }
+                        }
+                        catch (error) {
+                            if (this.options.verbose) {
+                                (0, utils_1.log)(`⚠️  Warning: Could not set old timestamp: ${error instanceof Error ? error.message : String(error)}`, this.options);
+                            }
+                        }
+                    }
+                    // Clean up temp file (should already be moved, but ensure it's gone)
+                    if (fs.existsSync(this.tempArchiveName)) {
+                        try {
+                            fs.unlinkSync(this.tempArchiveName);
+                        }
+                        catch {
+                            // Ignore cleanup errors
+                        }
+                    }
+                    // Done - no need to close stream for in-memory mode
+                    return;
+                }
+            }
+        }
+        // For file-based mode or in-memory blockchain mode, write central directory to file
+        // Use ZipkitNode's writeCentralDirectory() and writeEndOfCentralDirectory() methods
+        if (!this.zipWriter) {
+            throw new Error('ZIP writer not initialized for finalization');
+        }
+        // Get entries - for new ZIPs, use zip.getDirectory(); for updates, use getDirectory()
+        // IMPORTANT: getDirectory() contains entries in the EXACT order they were written to the ZIP file
+        // Files are written first during compression, then token metadata is added at the end
+        // So getDirectory() already has the correct order - use it as-is without reordering
+        let zipEntries = [];
+        const currentEntries = this.zip.getDirectory();
+        if (currentEntries.length > 0) {
+            // New ZIP creation - use getDirectory() in the exact order they were written
+            // This matches the data section order: files first, then metadata last
+            zipEntries = [...currentEntries];
+        }
+        else {
+            // Update mode - get entries from loaded ZIP
+            zipEntries = await this.zip.getDirectory() || [];
+        }
+        // Write central directory using ZipkitNode method
+        const centralDirOffset = this.zipWriter.currentPosition;
+        if (this.options.verbose) {
+            (0, utils_1.log)(`📊 Central directory starts at offset: ${centralDirOffset}`, this.options);
+            (0, utils_1.log)(`📁 Writing ${zipEntries.length} central directory entries`, this.options);
+        }
+        const centralDirSize = await this.zip.writeCentralDirectory(this.zipWriter, zipEntries, {
+            archiveComment: this.options.archiveComment,
+            onProgress: (entry) => {
+                if (this.options.verbose) {
+                    (0, utils_1.log)(`📝 Writing central dir entry: ${entry.filename}`, this.options);
+                    (0, utils_1.log)(`📊 Entry localHdrOffset: ${entry.localHdrOffset}`, this.options);
+                }
+            }
+        });
+        // Update currentPosition from zipWriter
+        this.currentPosition = this.zipWriter.currentPosition;
+        // Write end of central directory using ZipkitNode method
+        if (this.options.verbose) {
+            (0, utils_1.log)(`📝 Writing end of central directory`, this.options);
+            (0, utils_1.log)(`📊 Central directory size: ${centralDirSize} bytes`, this.options);
+            (0, utils_1.log)(`📊 Total file size: ${this.currentPosition} bytes (before EOCD)`, this.options);
+        }
+        await this.zip.writeEndOfCentralDirectory(this.zipWriter, zipEntries.length, centralDirSize, centralDirOffset, this.options.archiveComment);
+        // Update currentPosition from zipWriter
+        this.currentPosition = this.zipWriter.currentPosition;
+        // Close the output stream
+        await this.closeOutput();
+        // Atomically move temp file to final location
+        if (!this.tempArchiveName) {
+            throw new Error('Temp archive name not initialized');
+        }
+        if (!fs.existsSync(this.tempArchiveName)) {
+            throw new Error(`Temporary file not found: ${this.tempArchiveName}`);
+        }
+        // Use fs.rename() for atomic move (same filesystem)
+        // This will overwrite existing file atomically if it exists
+        fs.renameSync(this.tempArchiveName, this.archiveName);
+        // Clean up temp file immediately after successful move (should already be moved, but ensure)
+        if (fs.existsSync(this.tempArchiveName)) {
+            try {
+                fs.unlinkSync(this.tempArchiveName);
+            }
+            catch {
+                // Ignore cleanup errors - file may have already been moved
+            }
+        }
+        // Apply old timestamp if requested (on final file)
+        if (this.options.oldTimestamp) {
+            try {
+                const oldestTime = await (0, file_operations_1.findOldestEntryTime)(this.zip);
+                if (oldestTime) {
+                    fs.utimesSync(this.archiveName, oldestTime, oldestTime);
+                    if (this.options.verbose) {
+                        (0, utils_1.log)(`📅 Set archive timestamp to oldest entry: ${oldestTime.toISOString()}`, this.options);
+                    }
+                }
+            }
+            catch (error) {
+                if (this.options.verbose) {
+                    (0, utils_1.log)(`⚠️  Warning: Could not set old timestamp: ${error instanceof Error ? error.message : String(error)}`, this.options);
+                }
+            }
+        }
+    }
+    cleanupFileDescriptors() {
+        for (const [filePath, fd] of this.fdCache.entries()) {
+            try {
+                fs.closeSync(fd);
+            }
+            catch (error) {
+                // Ignore errors during cleanup
+            }
+        }
+        this.fdCache.clear();
+    }
+}
+/**
+ * Test the integrity of a ZIP archive using neounzip
+ */
+async function testArchiveIntegrity(archiveName, options) {
+    try {
+        // Always show when integrity testing starts
+        (0, utils_1.log)(`\n🧪 Testing archive integrity: ${archiveName}`, options);
+        // Import child_process for shelling out
+        const { spawn } = require('child_process');
+        // Use the installed neounzip command directly (works in both dev and installed)
+        // In development, this will use the local bin, in installed package it uses global bin
+        const neounzipCommand = 'neounzip';
+        return new Promise((resolve) => {
+            // Build neounzip command arguments
+            const args = ['-t'];
+            // Add password if encryption is enabled
+            if (options.encrypt && options.password) {
+                args.push('-P', options.password);
+            }
+            args.push(archiveName);
+            // Run neounzip with -t (test) flag directly
+            const neounzip = spawn(neounzipCommand, args, {
+                stdio: ['pipe', 'pipe', 'pipe']
+            });
+            let stdout = '';
+            let stderr = '';
+            let fileCount = 0;
+            let testResults = [];
+            neounzip.stdout.on('data', (data) => {
+                const output = data.toString();
+                stdout += output;
+                // Parse the output to extract file testing information
+                const lines = output.split('\n');
+                for (const line of lines) {
+                    // Look for lines like "testing: filename ...OK SHA-256" or "testing: filename ...OK"
+                    if (line.includes('testing:') && line.includes('...OK')) {
+                        fileCount++;
+                        testResults.push(line.trim());
+                    }
+                }
+            });
+            neounzip.stderr.on('data', (data) => {
+                stderr += data.toString();
+            });
+            neounzip.on('close', (code) => {
+                if (code === 0) {
+                    // Show detailed integrity test results
+                    if (fileCount > 0) {
+                        (0, utils_1.log)(`📊 Testing ${fileCount} file(s):`, options);
+                        testResults.forEach(result => {
+                            (0, utils_1.log)(`   ${result}`, options);
+                        });
+                    }
+                    // Look for summary line like "No errors detected in compressed data of X files"
+                    const summaryMatch = stdout.match(/No errors detected in compressed data of (\d+) files?/);
+                    if (summaryMatch) {
+                        (0, utils_1.log)(`✅ Archive integrity test passed - ${summaryMatch[1]} files verified`, options);
+                    }
+                    else {
+                        (0, utils_1.log)(`✅ Archive integrity test passed`, options);
+                    }
+                    resolve(true);
+                }
+                else {
+                    (0, utils_1.log)(`❌ Archive integrity test failed (exit code: ${code})`, options);
+                    if (stderr) {
+                        (0, utils_1.log)(`Error output: ${stderr}`, options);
+                    }
+                    resolve(false);
+                }
+            });
+            neounzip.on('error', (error) => {
+                (0, utils_1.log)(`❌ Failed to run integrity test: ${error.message}`, options);
+                resolve(false);
+            });
+        });
+    }
+    catch (error) {
+        (0, utils_1.log)(`❌ Error during integrity test: ${error instanceof Error ? error.message : String(error)}`, options);
+        return false;
+    }
+}
+/**
+ * Creates the end of central directory record manually
+ * @param totalEntries - Total number of entries in the ZIP
+ * @param centralDirSize - Size of central directory
+ * @param centralDirOffset - Offset to central directory
+ * @param archiveComment - Optional archive comment
+ * @returns Buffer containing end of central directory record
+ */
+function createEndOfCentralDirRecord(totalEntries, centralDirSize, centralDirOffset, archiveComment = '') {
+    const commentBytes = Buffer.from(archiveComment, 'utf8');
+    const commentLength = Math.min(commentBytes.length, 0xFFFF); // Max 65535 bytes
+    const buffer = Buffer.alloc(22 + commentLength);
+    let offset = 0;
+    // End of central directory signature (4 bytes)
+    buffer.writeUInt32LE(0x06054b50, offset);
+    offset += 4;
+    // Number of this disk (2 bytes)
+    buffer.writeUInt16LE(0, offset);
+    offset += 2;
+    // Number of the disk with the start of the central directory (2 bytes)
+    buffer.writeUInt16LE(0, offset);
+    offset += 2;
+    // Total number of entries in the central directory on this disk (2 bytes)
+    buffer.writeUInt16LE(totalEntries, offset);
+    offset += 2;
+    // Total number of entries in the central directory (2 bytes)
+    buffer.writeUInt16LE(totalEntries, offset);
+    offset += 2;
+    // Size of the central directory (4 bytes)
+    buffer.writeUInt32LE(centralDirSize, offset);
+    offset += 4;
+    // Offset of start of central directory with respect to the starting disk number (4 bytes)
+    buffer.writeUInt32LE(centralDirOffset, offset);
+    offset += 4;
+    // ZIP file comment length (2 bytes)
+    buffer.writeUInt16LE(commentLength, offset);
+    offset += 2;
+    // ZIP file comment (variable length)
+    if (commentLength > 0) {
+        commentBytes.copy(buffer, offset, 0, commentLength);
+    }
+    return buffer;
+}
+/**
+ * Upgrade existing ZIP file for tokenization by adding SHA-256 hashes to entries
+ * that don't have them, preserving original compression methods
+ */
+async function upgradeZipForTokenization(inputZipPath, options) {
+    const os = require('os');
+    (0, utils_1.log)(`\n🔧 Upgrading ZIP file for tokenization: ${inputZipPath}`, options);
+    // Validate input file exists
+    if (!fs.existsSync(inputZipPath)) {
+        (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.CANT_FIND_ARCHIVE, `Error: Input ZIP file not found: ${inputZipPath}`);
+    }
+    // Determine output file path (final destination)
+    let outputZipPath;
+    if (options.overwrite) {
+        outputZipPath = inputZipPath;
+        (0, utils_1.log)(`   Output: ${outputZipPath} (overwriting input)`, options);
+    }
+    else {
+        const inputDir = path.dirname(inputZipPath);
+        const inputBase = path.basename(inputZipPath, path.extname(inputZipPath));
+        const inputExt = path.extname(inputZipPath);
+        outputZipPath = path.join(inputDir, `${inputBase}-tokenized${inputExt}`);
+        (0, utils_1.log)(`   Output: ${outputZipPath}`, options);
+    }
+    // Create temporary file path for atomic operation (even when overwriting)
+    const tempDir = options.tempPath || os.tmpdir();
+    // Ensure temp directory exists
+    if (!fs.existsSync(tempDir)) {
+        fs.mkdirSync(tempDir, { recursive: true });
+    }
+    const tempOutputPath = path.join(tempDir, `${path.basename(outputZipPath)}.tmp.${Date.now()}`);
+    // Load existing ZIP
+    const sourceZip = new node_1.default();
+    await sourceZip.loadZipFile(inputZipPath);
+    const entries = await sourceZip.getDirectory();
+    if (!entries || entries.length === 0) {
+        (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.BAD_ARCHIVE_FORMAT, 'Error: ZIP file is empty or invalid');
+    }
+    (0, utils_1.log)(`   Found ${entries.length} entries in ZIP`, options);
+    // Check for existing token metadata (ignore per requirement 3a)
+    const hasTokenMetadata = entries.some((e) => e.filename === neozipkit_1.TOKENIZED_METADATA);
+    if (hasTokenMetadata && options.verbose) {
+        (0, utils_1.log)(`   Note: ZIP already contains token metadata (will create new token)`, options);
+    }
+    // Process entries: extract if missing SHA-256, calculate hash, preserve compression
+    const processedEntries = [];
+    const hashAccumulator = new neozipkit_1.HashCalculator({ enableAccumulation: true });
+    let tempFiles = [];
+    try {
+        for (const entry of entries) {
+            const filename = entry.filename || '';
+            // Skip metadata entries and directories
+            if (filename === neozipkit_1.TOKENIZED_METADATA ||
+                filename === neozipkit_1.TIMESTAMP_METADATA ||
+                filename === neozipkit_1.TIMESTAMP_SUBMITTED ||
+                entry.isDirectory) {
+                continue;
+            }
+            // Check if entry needs SHA-256 hash
+            let needsHash = !entry.sha256;
+            if (needsHash) {
+                (0, utils_1.log)(`   Processing: ${filename} (calculating SHA-256...)`, options);
+                // Check if encrypted (requirement 5c: error if cannot process)
+                if (entry.isEncrypted) {
+                    if (!options.password) {
+                        (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.BAD_ARCHIVE_FORMAT, `Error: Entry "${filename}" is encrypted but no password provided. Use -P or --password option.`);
+                    }
+                    // Set password on source ZIP for decryption
+                    sourceZip.password = options.password;
+                }
+                // Extract entry to get uncompressed data
+                let uncompressedData;
+                try {
+                    // Check if ZIP is file-based or buffer-based
+                    const isFileBased = sourceZip.fileHandle !== undefined;
+                    if (isFileBased) {
+                        // File-based: extract to temp file
+                        const tempFile = path.join(tempDir, `neozip-upgrade-${Date.now()}-${filename.replace(/[^a-zA-Z0-9]/g, '_')}`);
+                        tempFiles.push(tempFile);
+                        await sourceZip.extractToFile(entry, tempFile, { skipHashCheck: false });
+                        uncompressedData = fs.readFileSync(tempFile);
+                    }
+                    else {
+                        // Buffer-based: extract directly
+                        const extracted = await sourceZip.extract(entry, false);
+                        if (!extracted) {
+                            (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.READ_ERROR, `Error: Failed to extract entry "${filename}"`);
+                        }
+                        uncompressedData = extracted;
+                    }
+                }
+                catch (error) {
+                    const errorMsg = error instanceof Error ? error.message : String(error);
+                    (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.READ_ERROR, `Error: Failed to extract entry "${filename}": ${errorMsg}`);
+                }
+                // Calculate SHA-256 hash
+                const hashHex = (0, neozipkit_1.sha256)(uncompressedData);
+                entry.sha256 = hashHex;
+                if (options.verbose) {
+                    (0, utils_1.log)(`     SHA-256: ${hashHex.substring(0, 16)}...`, options);
+                }
+            }
+            else {
+                if (options.verbose) {
+                    (0, utils_1.log)(`   Skipping: ${filename} (already has SHA-256)`, options);
+                }
+            }
+            // Read compressed data from original ZIP (preserve compression)
+            let compressedData;
+            try {
+                const isFileBased = sourceZip.fileHandle !== undefined;
+                if (isFileBased) {
+                    // Read local header to find data offset
+                    const localHeaderBuffer = Buffer.alloc(30);
+                    await sourceZip.fileHandle.read(localHeaderBuffer, 0, 30, entry.localHdrOffset);
+                    if (localHeaderBuffer.readUInt32LE(0) !== 0x04034b50) {
+                        (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.BAD_ARCHIVE_FORMAT, `Error: Invalid local header for entry "${filename}"`);
+                    }
+                    const filenameLength = localHeaderBuffer.readUInt16LE(26);
+                    const extraFieldLength = localHeaderBuffer.readUInt16LE(28);
+                    const dataStart = entry.localHdrOffset + 30 + filenameLength + extraFieldLength;
+                    // Read compressed data
+                    compressedData = Buffer.alloc(entry.compressedSize);
+                    await sourceZip.fileHandle.read(compressedData, 0, entry.compressedSize, dataStart);
+                }
+                else {
+                    // Buffer-based: parse local header and read compressed data
+                    const buffer = sourceZip.ensureBuffer();
+                    compressedData = sourceZip.parseLocalHeader(entry, buffer);
+                }
+            }
+            catch (error) {
+                const errorMsg = error instanceof Error ? error.message : String(error);
+                (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.READ_ERROR, `Error: Failed to read compressed data for entry "${filename}": ${errorMsg}`);
+            }
+            // Store processed entry with compressed data
+            processedEntries.push({ entry, compressedData });
+            // Add hash to merkle root calculation
+            if (entry.sha256) {
+                const hashBuffer = Buffer.from(entry.sha256, 'hex');
+                hashAccumulator.addHash(hashBuffer);
+            }
+        }
+        // Calculate merkle root
+        const merkleRoot = hashAccumulator.merkleRoot();
+        if (!merkleRoot) {
+            (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.BAD_ARCHIVE_FORMAT, 'Error: Failed to calculate merkle root (no content files found)');
+        }
+        (0, utils_1.log)(`   Calculated merkle root: ${merkleRoot.substring(0, 16)}...`, options);
+        // Rebuild ZIP with updated entries (write to temp file first for atomic operation)
+        (0, utils_1.log)(`   Rebuilding ZIP with updated entries...`, options);
+        const outputZip = new node_1.default();
+        const writer = await outputZip.initializeZipFile(tempOutputPath);
+        try {
+            let currentOffset = 0;
+            // Write all entries with updated SHA-256 hashes
+            for (const { entry, compressedData } of processedEntries) {
+                // Create new entry with same properties but updated SHA-256
+                const newEntry = new neozipkit_1.ZipEntry(entry.filename || '', null, false);
+                Object.assign(newEntry, {
+                    filename: entry.filename,
+                    cmpMethod: entry.cmpMethod,
+                    compressedSize: entry.compressedSize,
+                    uncompressedSize: entry.uncompressedSize,
+                    crc: entry.crc,
+                    sha256: entry.sha256,
+                    timeDateDOS: entry.timeDateDOS,
+                    lastModTimeDate: entry.lastModTimeDate,
+                    comment: entry.comment,
+                    isDirectory: entry.isDirectory,
+                    isEncrypted: entry.isEncrypted,
+                    encryptionMethod: entry.encryptionMethod,
+                    uid: entry.uid,
+                    gid: entry.gid,
+                    isSymlink: entry.isSymlink,
+                    linkTarget: entry.linkTarget,
+                    universalTime: entry.universalTime
+                });
+                // Create local header
+                const localHeader = newEntry.createLocalHdr();
+                newEntry.localHdrOffset = currentOffset;
+                // Write local header
+                await new Promise((resolve, reject) => {
+                    writer.outputStream.write(localHeader, (error) => {
+                        if (error) {
+                            reject(error);
+                        }
+                        else {
+                            writer.currentPosition += localHeader.length;
+                            resolve();
+                        }
+                    });
+                });
+                currentOffset += localHeader.length;
+                // Write compressed data (preserved from original)
+                await new Promise((resolve, reject) => {
+                    writer.outputStream.write(compressedData, (error) => {
+                        if (error) {
+                            reject(error);
+                        }
+                        else {
+                            writer.currentPosition += compressedData.length;
+                            currentOffset += compressedData.length;
+                            resolve();
+                        }
+                    });
+                });
+            }
+            // Mint new token before finalizing ZIP (so we can add metadata)
+            // Check for wallet passkey - don't show error yet
+            const walletPasskey = (0, blockchain_2.getWalletPasskey)(options.walletKey, false);
+            if (!walletPasskey) {
+                // Show error message and prompt user
+                console.error('❌ Error: Wallet private key is required for blockchain operations');
+                console.error('');
+                console.error('   Option 1 (Recommended): Run interactive setup');
+                console.error('   $ neozip init');
+                console.error('');
+                console.error('   Option 2: Use command-line flag');
+                console.error('   $ neozip --upgrade -w 0x... <archive>');
+                console.error('');
+                console.error('   Option 3: Set environment variable');
+                console.error('   $ export NEOZIP_WALLET_PASSKEY="0x..."');
+                console.error('');
+                console.error('   Get testnet ETH from: https://www.coinbase.com/faucets/base-ethereum-sepolia-faucet');
+                console.error('');
+                // Prompt user to continue without blockchain tokenization
+                if (!options.nonInteractive) {
+                    const answer = await (0, user_interaction_1.promptUser)('Continue upgrade without blockchain tokenization? (y/n): ');
+                    if (answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes') {
+                        (0, utils_1.log)('⚠️  Continuing upgrade without blockchain tokenization (SHA-256 hashes will be added)...', options);
+                        // Skip token minting - ZIP will be upgraded with SHA-256 hashes but no token metadata
+                    }
+                    else {
+                        (0, utils_1.logError)('💡 Tip: Run "neozip init" to set up your wallet configuration');
+                        (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.BLOCKCHAIN_CONFIG_ERROR);
+                    }
+                }
+                else {
+                    // Non-interactive mode - exit with error
+                    (0, utils_1.logError)('💡 Tip: Run "neozip init" to set up your wallet configuration');
+                    (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.BLOCKCHAIN_CONFIG_ERROR);
+                }
+            }
+            // Only mint token if wallet passkey is available
+            if (walletPasskey) {
+                (0, utils_1.log)(`   Minting new token on blockchain...`, options);
+                const network = options.network || 'base-sepolia';
+                if (!(0, blockchain_2.isSupportedNetwork)(network)) {
+                    (0, exit_codes_1.exitZip)(exit_codes_1.ZIP_EXIT_CODES.BLOCKCHAIN_CONFIG_ERROR, `Error: Unsupported network: ${network}`);
+                }
+                const minter = new neozipkit_1.ZipkitMinter(merkleRoot, {
+                    network,
+                    walletPrivateKey: walletPasskey,
+                    verbose: options.verbose,
+                    debug: options.debug,
+                    rpcUrlIndex: 0
+                });
+                // Create a temporary ZipkitNode instance for handleTokenMinting
+                // (it needs a zip instance, but we'll add metadata manually)
+                const tempZip = new node_1.default();
+                const mintResult = await (0, blockchain_2.handleTokenMinting)(minter, tempZip, options.nonInteractive || false, 0);
+                if (mintResult.success && mintResult.tokenInfo) {
+                    // Add token metadata entry before central directory
+                    const tokenContent = JSON.stringify(mintResult.tokenInfo, null, 2);
+                    const tokenBuffer = Buffer.from(tokenContent, 'utf8');
+                    const tokenEntry = new neozipkit_1.ZipEntry(neozipkit_1.TOKENIZED_METADATA, null, false);
+                    tokenEntry.timeDateDOS = tokenEntry.setDateTime(new Date());
+                    tokenEntry.compressedSize = tokenBuffer.length;
+                    tokenEntry.uncompressedSize = tokenBuffer.length;
+                    tokenEntry.cmpMethod = 0; // STORED
+                    tokenEntry.crc = (0, neozipkit_1.crc32)(tokenBuffer);
+                    tokenEntry.localHdrOffset = currentOffset;
+                    // Write token metadata entry
+                    const tokenLocalHeader = tokenEntry.createLocalHdr();
+                    await new Promise((resolve, reject) => {
+                        writer.outputStream.write(tokenLocalHeader, (error) => {
+                            if (error) {
+                                reject(error);
+                            }
+                            else {
+                                writer.currentPosition += tokenLocalHeader.length;
+                                resolve();
+                            }
+                        });
+                    });
+                    currentOffset += tokenLocalHeader.length;
+                    await new Promise((resolve, reject) => {
+                        writer.outputStream.write(tokenBuffer, (error) => {
+                            if (error) {
+                                reject(error);
+                            }
+                            else {
+                                writer.currentPosition += tokenBuffer.length;
+                                currentOffset += tokenBuffer.length;
+                                resolve();
+                            }
+                        });
+                    });
+                    // Add token entry to processed entries for central directory
+                    processedEntries.push({ entry: tokenEntry, compressedData: tokenBuffer });
+                    // Clean up minter
+                    minter.destroy();
+                    (0, utils_1.log)(`   ✓ Token minted successfully!`, options);
+                    (0, utils_1.log)(`   ✓ Token ID: ${mintResult.tokenInfo.tokenId}`, options);
+                    (0, utils_1.log)(`   ✓ Transaction: ${mintResult.tokenInfo.transactionHash}`, options);
+                }
+                else {
+                    // Clean up minter
+                    minter.destroy();
+                    (0, utils_1.log)(`   ⚠️  Token minting failed, but ZIP upgrade will continue`, options);
+                }
+            }
+            else {
+                (0, utils_1.log)(`   ⚠️  Skipping blockchain tokenization (no wallet key provided)`, options);
+            }
+            // Write central directory (including token entry if minting succeeded)
+            const finalCentralDirOffset = currentOffset;
+            let finalCentralDirSize = 0;
+            for (const { entry } of processedEntries) {
+                const newEntry = new neozipkit_1.ZipEntry(entry.filename || '', null, false);
+                Object.assign(newEntry, {
+                    filename: entry.filename,
+                    cmpMethod: entry.cmpMethod,
+                    compressedSize: entry.compressedSize,
+                    uncompressedSize: entry.uncompressedSize,
+                    crc: entry.crc,
+                    sha256: entry.sha256,
+                    timeDateDOS: entry.timeDateDOS,
+                    lastModTimeDate: entry.lastModTimeDate,
+                    comment: entry.comment,
+                    isDirectory: entry.isDirectory,
+                    localHdrOffset: entry.localHdrOffset,
+                    uid: entry.uid,
+                    gid: entry.gid,
+                    isSymlink: entry.isSymlink,
+                    linkTarget: entry.linkTarget,
+                    universalTime: entry.universalTime
+                });
+                const centralDirEntry = newEntry.centralDirEntry();
+                await new Promise((resolve, reject) => {
+                    writer.outputStream.write(centralDirEntry, (error) => {
+                        if (error) {
+                            reject(error);
+                        }
+                        else {
+                            writer.currentPosition += centralDirEntry.length;
+                            finalCentralDirSize += centralDirEntry.length;
+                            currentOffset += centralDirEntry.length;
+                            resolve();
+                        }
+                    });
+                });
+            }
+            // Write end of central directory
+            await outputZip.writeEndOfCentralDirectory(writer, processedEntries.length, finalCentralDirSize, finalCentralDirOffset, '' // No comment
+            );
+            // Finalize ZIP file
+            await outputZip.finalizeZipFile(writer);
+            // Atomically move temp file to final location
+            if (!fs.existsSync(tempOutputPath)) {
+                throw new Error(`Temporary file not found: ${tempOutputPath}`);
+            }
+            // Use fs.rename() for atomic move (same filesystem)
+            // This will overwrite existing file atomically if it exists
+            fs.renameSync(tempOutputPath, outputZipPath);
+            // Clean up temp file immediately after successful move
+            if (fs.existsSync(tempOutputPath)) {
+                try {
+                    fs.unlinkSync(tempOutputPath);
+                }
+                catch {
+                    // Ignore cleanup errors - file may have already been moved
+                }
+            }
+            (0, utils_1.log)(`   ✓ ZIP rebuilt successfully`, options);
+        }
+        catch (error) {
+            // Clean up temp output file on error
+            if (fs.existsSync(tempOutputPath)) {
+                try {
+                    fs.unlinkSync(tempOutputPath);
+                }
+                catch {
+                    // Ignore cleanup errors
+                }
+            }
+            throw error;
+        }
+        (0, utils_1.log)(`\n✅ ZIP upgrade completed successfully!`, options);
+        (0, utils_1.log)(`   Output: ${outputZipPath}`, options);
+    }
+    finally {
+        // Clean up temporary extraction files
+        for (const tempFile of tempFiles) {
+            try {
+                if (fs.existsSync(tempFile)) {
+                    fs.unlinkSync(tempFile);
+                }
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+        }
+        // Ensure temp output file is cleaned up if it still exists (error case)
+        if (fs.existsSync(tempOutputPath)) {
+            try {
+                fs.unlinkSync(tempOutputPath);
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+        }
+    }
+}
+//# sourceMappingURL=createZip.js.map