neozip-cli 0.70.0-alpha

package/dist/src/neounzip.js

@@ -0,0 +1,2177 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * NEOUNZIP - Standalone ZIP extraction tool with blockchain tokenization verification
+ */
+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.main = main;
+exports.parseArgs = parseArgs;
+exports.showHelp = showHelp;
+exports.showExtendedHelp = showExtendedHelp;
+// No environment variables needed for neounzip
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const src_1 = require('../neozipkit-wrappers');
+const server_1 = require('../neozipkit-wrappers/server');
+const blockchain_1 = require('../neozipkit-wrappers/blockchain');
+const Logger_1 = require('../neozipkit-wrappers/core/components/Logger');
+const HashCalculator_1 = __importDefault(require('../neozipkit-wrappers/core/components/HashCalculator'));
+const readline = __importStar(require("readline"));
+const version_1 = require("./version");
+const exit_codes_1 = require("./exit-codes");
+/**
+ * Format bytes for display
+ */
+function formatBytes(bytes) {
+    const units = ['B', 'KB', 'MB', 'GB'];
+    let i = 0;
+    let v = bytes;
+    while (v >= 1024 && i < units.length - 1) {
+        v /= 1024;
+        i++;
+    }
+    return `${v.toFixed(i === 0 ? 0 : 1)} ${units[i]}`;
+}
+/**
+ * Pad string to the right
+ */
+function padRight(s, n) {
+    return (s + ' '.repeat(n)).slice(0, n);
+}
+/**
+ * Pad string to the left
+ */
+function padLeft(s, n) {
+    return ((' '.repeat(n)) + s).slice(-n);
+}
+/**
+ * Convert date to DOS date parts
+ */
+function toDateParts(date) {
+    const year = date.getFullYear();
+    const month = (date.getMonth() + 1).toString().padStart(2, '0');
+    const day = date.getDate().toString().padStart(2, '0');
+    const hours = date.getHours().toString().padStart(2, '0');
+    const minutes = date.getMinutes().toString().padStart(2, '0');
+    return {
+        date: `${month}-${day}-${year}`,
+        time: `${hours}:${minutes}`
+    };
+}
+/**
+ * Get method label
+ */
+function methodLabel(method) {
+    switch (method.toLowerCase()) {
+        case 'stored': return 'Stored';
+        case 'deflate': return 'Deflate';
+        case 'deflate64': return 'Deflate64';
+        case 'bzip2': return 'BZip2';
+        case 'lzma': return 'LZMA';
+        case 'ppmd': return 'PPMd';
+        case 'zstd': return 'Zstd';
+        default: return method;
+    }
+}
+/**
+ * Get method name from method code
+ */
+function getMethodName(method) {
+    switch (method) {
+        case 0: return 'stored';
+        case 8: return 'deflate';
+        case 9: return 'deflate64';
+        case 12: return 'bzip2';
+        case 14: return 'lzma';
+        case 95: return 'ppmd';
+        case 93: return 'zstd'; // Z Standard compression
+        default: return `unknown (${method})`;
+    }
+}
+/**
+ * Logging function that respects quiet mode
+ */
+function log(message, options = { dest: '.', test: false, skipBlockchain: false, verbose: false, quiet: false }) {
+    if (!options.quiet) {
+        console.log(message);
+    }
+}
+/**
+ * Prompt user for overwrite confirmation
+ * Returns 'y' for yes, 'n' for no, 'a' for always, 'q' for quit/abort
+ */
+function promptOverwrite(filename) {
+    return new Promise((resolve) => {
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+        rl.question(`replace ${filename}? [y]es, [n]o, [a]ll, [q]uit: `, (answer) => {
+            rl.close();
+            const lower = answer.toLowerCase().trim();
+            if (lower === 'a' || lower === 'all') {
+                resolve('a');
+            }
+            else if (lower === 'q' || lower === 'quit' || lower === 'abort' || lower === 'c' || lower === 'cancel') {
+                resolve('q');
+            }
+            else if (lower === 'y' || lower === 'yes' || lower === '') {
+                resolve('y');
+            }
+            else {
+                resolve('n');
+            }
+        });
+    });
+}
+/**
+ * Extract entry - async for Buffer-based ZIPs
+ * For file-based ZIPs, use extractToFile() instead
+ */
+async function extractEntry(zip, entry, skipBlockchain) {
+    // Use Zipkit.extract() method (Buffer-based ZIP only)
+    return await zip.extract(entry, skipBlockchain);
+}
+/**
+ * Helper function to check if ZIP is file-based
+ */
+function isFileBased(zip) {
+    try {
+        zip.getFileHandle();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Helper function to check if ZIP is buffer-based
+ */
+function isBufferBased(zip) {
+    return zip.inBuffer !== undefined && zip.inBuffer !== null;
+}
+/**
+ * Get directory - auto-detects backend (Buffer or File)
+ */
+async function getDirectory(zip, debug) {
+    // Check backend type and use appropriate method
+    const bufferBased = isBufferBased(zip);
+    const fileBased = isFileBased(zip);
+    if (bufferBased) {
+        // Buffer-based: use synchronous getDirectory()
+        return zip.getDirectory(debug) || [];
+    }
+    else if (fileBased) {
+        // File-based: use getDirectory()
+        return await zip.getDirectory(debug) || [];
+    }
+    else {
+        throw new Error('ZIP file not loaded. Cannot determine backend type.');
+    }
+}
+/**
+ * Error logging function (always shows errors)
+ */
+function logError(message) {
+    console.error(message);
+}
+/**
+ * Debug logging function (only shows in debug mode)
+ */
+function logDebug(message, options = { dest: '', test: false, skipBlockchain: false, verbose: false, quiet: false }) {
+    if (options.debug && !options.quiet) {
+        console.log(`🐛 DEBUG: ${message}`);
+    }
+}
+/**
+ * Prompt user for OTS upgrade confirmation
+ */
+async function promptForOtsUpgrade(otsResult, archivePath) {
+    if (!otsResult.upgraded || !otsResult.upgradedOts) {
+        return false;
+    }
+    console.log(' - Upgrade: Available (improved timestamp can be saved)');
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+    return new Promise((resolve) => {
+        rl.question(' - Apply upgraded timestamp to archive now? (y/N): ', (answer) => {
+            rl.close();
+            const response = answer.toLowerCase().trim();
+            const shouldUpgrade = response === 'y' || response === 'yes';
+            resolve(shouldUpgrade);
+        });
+    });
+}
+/**
+ * Prompt user for action when verification times out
+ */
+async function promptForTimeoutAction(networkConfig, currentRpcIndex, nonInteractive) {
+    if (nonInteractive) {
+        return 'exit';
+    }
+    const rpcUrls = networkConfig.rpcUrls || [];
+    const hasMoreRpcs = currentRpcIndex + 1 < rpcUrls.length;
+    console.log('\n⏱️  Verification timeout occurred');
+    console.log(`   Current RPC: ${rpcUrls[currentRpcIndex] || 'unknown'}`);
+    if (hasMoreRpcs) {
+        console.log(`   ${rpcUrls.length - currentRpcIndex - 1} more RPC URL(s) available`);
+    }
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+    return new Promise((resolve) => {
+        console.log('\nChoose an option:');
+        console.log('  1. Retry verification with same RPC');
+        if (hasMoreRpcs) {
+            console.log('  2. Try next RPC URL');
+        }
+        console.log('  3. Exit');
+        rl.question('Enter your choice (1-3): ', (answer) => {
+            rl.close();
+            const choice = answer.trim();
+            if (choice === '1') {
+                resolve('retry');
+            }
+            else if (choice === '2' && hasMoreRpcs) {
+                resolve('next-rpc');
+            }
+            else if (choice === '3') {
+                resolve('exit');
+            }
+            else {
+                // Invalid choice, default to exit
+                console.log('Invalid choice, exiting...');
+                resolve('exit');
+            }
+        });
+    });
+}
+/**
+ * Perform OTS upgrade on the archive
+ */
+async function performOtsUpgrade(archivePath, upgradedOts) {
+    try {
+        // Create upgrade filename by adding "-upgrade" before the extension
+        const ext = path.extname(archivePath);
+        const baseName = path.basename(archivePath, ext);
+        const dirName = path.dirname(archivePath);
+        const upgradedPath = path.join(dirName, `${baseName}-upgrade${ext}`);
+        console.log(` - Upgraded OTS size: ${upgradedOts.length} bytes`);
+        console.log(` - Creating upgraded archive: ${upgradedPath}`);
+        // Copy the original file to the upgrade location first
+        if (fs.existsSync(upgradedPath)) {
+            fs.unlinkSync(upgradedPath);
+            console.log(` - Removed existing upgrade file`);
+        }
+        fs.copyFileSync(archivePath, upgradedPath);
+        console.log(` - Copied original file to upgrade location`);
+        // Use the upgradeOTS function
+        await (0, blockchain_1.upgradeOTS)(upgradedPath, upgradedOts);
+        console.log(' - Upgrade: Applied successfully');
+        console.log(` - Note: Upgraded timestamp saved to ${upgradedPath}`);
+        console.log(` - Original file ${archivePath} remains unchanged`);
+    }
+    catch (error) {
+        console.log(` - Upgrade failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        console.log(` - Error details: ${error instanceof Error ? error.stack : 'No stack trace'}`);
+    }
+}
+/**
+ * Prompt user for password (hidden input)
+ */
+async function promptPassword(question) {
+    const readline = require('readline');
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+    return new Promise((resolve) => {
+        // Hide the password input
+        process.stdout.write(question);
+        // Check if stdin has setRawMode method (Node.js environment)
+        if (process.stdin.setRawMode) {
+            process.stdin.setRawMode(true);
+            process.stdin.resume();
+            process.stdin.setEncoding('utf8');
+            let password = '';
+            process.stdin.on('data', (char) => {
+                const charStr = char.toString();
+                if (charStr === '\r' || charStr === '\n') {
+                    // Enter pressed
+                    process.stdin.setRawMode(false);
+                    process.stdin.pause();
+                    process.stdout.write('\n');
+                    rl.close();
+                    resolve(password);
+                }
+                else if (charStr === '\u0003') {
+                    // Ctrl+C
+                    process.stdin.setRawMode(false);
+                    process.stdin.pause();
+                    process.exit(0);
+                }
+                else if (charStr === '\u007f') {
+                    // Backspace
+                    if (password.length > 0) {
+                        password = password.slice(0, -1);
+                        process.stdout.write('\b \b');
+                    }
+                }
+                else {
+                    // Regular character
+                    password += charStr;
+                    process.stdout.write('*');
+                }
+            });
+        }
+        else {
+            // Fallback to regular readline if setRawMode is not available
+            rl.question(question, (answer) => {
+                rl.close();
+                resolve(answer.trim());
+            });
+        }
+    });
+}
+/**
+ * Ensure directory exists
+ */
+function ensureDir(dirPath) {
+    if (!fs.existsSync(dirPath)) {
+        fs.mkdirSync(dirPath, { recursive: true });
+    }
+}
+/**
+ * Extract files to stdout (pipe mode)
+ */
+async function pipeArchive(zip, options, filePatterns) {
+    const entries = await getDirectory(zip, false);
+    // Filter entries based on file patterns if provided
+    let filteredEntries = entries;
+    if (filePatterns && filePatterns.length > 0) {
+        filteredEntries = entries.filter(entry => {
+            const filename = entry.filename || '';
+            return filePatterns.some(pattern => {
+                // Simple pattern matching - could be enhanced with glob patterns
+                return filename.includes(pattern) || filename === pattern;
+            });
+        });
+    }
+    // Apply include/exclude filtering using ZipkitServer.filterEntries()
+    const finalEntries = zip.filterEntries(filteredEntries, {
+        include: options.include,
+        exclude: options.exclude,
+        skipMetadata: true // Skip META-INF/NZIP.TOKEN automatically
+    });
+    for (const entry of finalEntries) {
+        const filename = entry.filename || '';
+        // Skip token metadata
+        if (filename === 'META-INF/NZIP.TOKEN') {
+            continue;
+        }
+        // Skip directories
+        if (entry.isDirectory) {
+            continue;
+        }
+        try {
+            // Check if file is encrypted
+            const isEncrypted = entry.isEncrypted;
+            let data = null;
+            // Handle encrypted files - extractEntry() handles decryption and decompression
+            if (isEncrypted && !options.password) {
+                process.stderr.write(`neounzip: ${filename}: encrypted file, password required\n`);
+                continue;
+            }
+            // Set password on zip instance for decryption (if provided)
+            if (isEncrypted && options.password) {
+                zip.password = options.password;
+            }
+            // Use extractEntry which handles both encrypted and non-encrypted files
+            // It will decrypt (if password set) and decompress automatically
+            try {
+                data = await extractEntry(zip, entry, options.skipBlockchain);
+                if (!data) {
+                    if (isEncrypted) {
+                        process.stderr.write(`neounzip: ${filename}: incorrect password\n`);
+                    }
+                    else {
+                        process.stderr.write(`neounzip: ${filename}: extraction failed\n`);
+                    }
+                    continue;
+                }
+            }
+            catch (error) {
+                if (isEncrypted) {
+                    process.stderr.write(`neounzip: ${filename}: decryption failed\n`);
+                }
+                else {
+                    process.stderr.write(`neounzip: ${filename}: extraction failed\n`);
+                }
+                continue;
+            }
+            // Write file content to stdout
+            if (data) {
+                process.stdout.write(data);
+            }
+        }
+        catch (error) {
+            process.stderr.write(`neounzip: ${filename}: ${error instanceof Error ? error.message : String(error)}\n`);
+        }
+    }
+}
+/**
+ * Display archive comment only
+ */
+async function showCommentOnly(zip, archivePath, options) {
+    // Load the central directory completely to ensure comment is available
+    await getDirectory(zip);
+    // Always show the archive name first
+    console.log(`Archive:  ${archivePath}`);
+    // Get archive comment
+    const archiveComment = zip.getZipComment();
+    if (archiveComment && archiveComment.trim()) {
+        // Show the comment after the archive name
+        console.log(archiveComment);
+    }
+    // If no comment, just show the archive name (no additional output)
+}
+/**
+ * List archive contents in table format (using neolist default format)
+ */
+async function listArchive(zip, archivePath, options) {
+    const entries = await getDirectory(zip, false);
+    // Always show listing output, even in quiet mode
+    console.log(`Archive:  ${archivePath}`);
+    // Detailed verbose format matching neolist default
+    const sep = '  ';
+    const lengthW = 8, sizeW = 7, cmprW = 4, methodW = 6, dateW = 10, timeW = 5, crcW = 8;
+    console.log(padLeft('Length', lengthW) + sep +
+        padRight('Method', methodW) + sep +
+        padLeft('Size', sizeW) + ' ' +
+        padRight('Cmpr', cmprW) + ' ' +
+        padRight('Date', dateW) + ' ' +
+        padRight('Time', timeW) + '  ' +
+        padRight('CRC-32', crcW) + sep +
+        'Name');
+    console.log('--------  ------  ------- ---- ---------- ----- --------  ----');
+    let totalLen = 0;
+    let totalCmp = 0;
+    entries.forEach(entry => {
+        const unc = entry.uncompressedSize || 0;
+        const cmp = entry.compressedSize || 0;
+        totalLen += unc;
+        totalCmp += cmp;
+        const cmpr = unc > 0 ? padRight(String(Math.max(0, Math.round((1 - cmp / unc) * 100))) + '%', cmprW) : padRight('0%', cmprW);
+        const modifiedDate = entry.parseDateTime(entry.timeDateDOS) || new Date();
+        const { date, time } = toDateParts(modifiedDate);
+        const crc = ((entry.crc || 0) >>> 0).toString(16).padStart(8, '0');
+        const filename = entry.filename || '';
+        console.log(padLeft(String(unc), lengthW) + sep +
+            padRight(methodLabel(getMethodName(entry.cmpMethod)), methodW) + sep +
+            padLeft(String(cmp), sizeW) + ' ' +
+            cmpr + ' ' +
+            padRight(date, dateW) + ' ' +
+            padRight(time, timeW) + '  ' +
+            padRight(crc, crcW) + sep +
+            filename);
+        // Show file comment below the file entry
+        if (entry.comment) {
+            console.log(entry.comment);
+        }
+    });
+    console.log('--------  ------  ------- ---- ---------- ----- --------  ----');
+    const filesCount = entries.length;
+    const compressionRatio = totalLen > 0 ? Math.round((1 - totalCmp / totalLen) * 100) : 0;
+    console.log(padLeft(String(totalLen), lengthW) + '          ' +
+        padLeft(String(totalCmp), sizeW) + '      ' +
+        padRight(`${compressionRatio}%`, 4) + ' ' +
+        padRight(`${filesCount} files`, 0));
+    // Show archive comment by default
+    const archiveComment = zip.getZipComment();
+    if (archiveComment && archiveComment.trim()) {
+        console.log(archiveComment);
+    }
+}
+/**
+ * Test archive without extracting
+ */
+async function testArchive(zip, options) {
+    const entries = await getDirectory(zip, false);
+    let failures = 0;
+    // Set password on zip instance if provided (needed for decryption)
+    if (options.password) {
+        zip.password = options.password;
+    }
+    // Check if ZIP is file-based or buffer-based
+    const fileBased = isFileBased(zip);
+    const bufferBased = isBufferBased(zip);
+    // For merkle root calculation: collect verified SHA-256 hashes during test extraction
+    const hashAccumulator = new HashCalculator_1.default({ enableAccumulation: true });
+    let allFilesValid = true;
+    const failedFiles = [];
+    // Filter out metadata files for merkle root calculation
+    const contentEntriesForMerkle = entries.filter(entry => {
+        const filename = entry.filename || '';
+        return filename !== src_1.TOKENIZED_METADATA &&
+            filename !== src_1.TIMESTAMP_METADATA &&
+            filename !== src_1.TIMESTAMP_SUBMITTED &&
+            !entry.isDirectory;
+    });
+    for (const entry of entries) {
+        const name = entry.filename || '';
+        // Skip directories
+        if (entry.isDirectory) {
+            continue;
+        }
+        if (options.showFiles && !options.quiet) {
+            log(`testing: ${name}`, options);
+        }
+        try {
+            if (bufferBased) {
+                // Buffer-based: use extract() which performs CRC/SHA checks
+                await extractEntry(zip, entry, options.skipBlockchain);
+            }
+            else if (fileBased) {
+                // File-based: use extractToFile() to a temporary file for testing
+                // extractToFile() performs CRC/SHA checks during extraction
+                const tmpPath = path.join(require('os').tmpdir(), `neounzip-test-${Date.now()}-${entry.filename?.replace(/[^a-zA-Z0-9]/g, '_') || 'file'}`);
+                try {
+                    await zip.extractToFile(entry, tmpPath, {
+                        skipHashCheck: options.skipBlockchain
+                    });
+                    // If extraction succeeds, verification passed (CRC/SHA checks are done during extraction)
+                    // Clean up temporary file
+                    if (fs.existsSync(tmpPath)) {
+                        fs.unlinkSync(tmpPath);
+                    }
+                }
+                catch (extractErr) {
+                    // Clean up temporary file on error
+                    if (fs.existsSync(tmpPath)) {
+                        try {
+                            fs.unlinkSync(tmpPath);
+                        }
+                        catch {
+                            // Ignore cleanup errors
+                        }
+                    }
+                    throw extractErr;
+                }
+            }
+            else {
+                throw new Error('ZIP file not loaded. Cannot determine backend type.');
+            }
+            // Report success
+            if (entry.sha256 && !options.skipBlockchain) {
+                console.log(`testing: ${name} ...OK SHA-256`);
+                // Collect verified SHA-256 hash for merkle root calculation (single pass - no double check)
+                const isContentFile = name !== src_1.TOKENIZED_METADATA &&
+                    name !== src_1.TIMESTAMP_METADATA &&
+                    name !== src_1.TIMESTAMP_SUBMITTED &&
+                    !entry.isDirectory;
+                if (isContentFile && entry.sha256) {
+                    // Use the verified hash from the entry (already verified during extraction)
+                    const hashBuffer = Buffer.from(entry.sha256, 'hex');
+                    hashAccumulator.addHash(hashBuffer);
+                }
+            }
+            else if (entry.sha256 && options.skipBlockchain) {
+                console.log(`testing: ${name} ...OK (SHA-256 skipped)`);
+            }
+            else {
+                console.log(`testing: ${name} ...OK`);
+            }
+        }
+        catch (err) {
+            failures += 1;
+            let msg = err?.message || String(err) || 'ERROR';
+            // Check if entry is encrypted to provide better error messages
+            // Check bitFlags for encryption flag (bit 0)
+            const isEncrypted = entry.isEncrypted || (entry.bitFlags & 0x01) !== 0;
+            // Track failed files for merkle root calculation
+            const isContentFile = name !== src_1.TOKENIZED_METADATA &&
+                name !== src_1.TIMESTAMP_METADATA &&
+                name !== src_1.TIMESTAMP_SUBMITTED &&
+                !entry.isDirectory;
+            if (isEncrypted) {
+                // For encrypted files, decompression errors after decryption usually mean wrong password
+                // Check for pako inflate errors which indicate corrupted/decompressed data
+                if (msg.includes('CRC32') || msg.includes('INVALID_CRC') || msg.includes('CRC-32') || msg.includes('CRC32 checksum')) {
+                    msg = 'Incorrect Password';
+                }
+                else if (msg.includes('SHA-256') || msg.includes('INVALID_SHA256') || msg.includes('SHA-256 hash')) {
+                    msg = 'Incorrect Password';
+                    // Track SHA-256 failure for content files
+                    if (isContentFile && !options.skipBlockchain) {
+                        allFilesValid = false;
+                        failedFiles.push(name);
+                    }
+                }
+                else if (msg.includes('invalid distance') || msg.includes('invalid block type') ||
+                    msg.includes('invalid stored block') || msg.includes('invalid code lengths') ||
+                    msg.includes('invalid distance code') || msg.includes('deflate') ||
+                    msg.includes('inflate') || msg.includes('corrupted')) {
+                    // These are decompression errors, which for encrypted files usually mean wrong password
+                    msg = 'Incorrect Password';
+                }
+                else if (msg === 'ERROR' || !msg || msg.length === 0) {
+                    // If we get a generic error on encrypted file, assume password issue
+                    msg = 'Incorrect Password';
+                }
+                // Otherwise use the error message as-is for other decryption errors
+            }
+            else {
+                // For non-encrypted files, provide clearer CRC/SHA error messages
+                if (msg.includes('CRC32') || msg.includes('INVALID_CRC') || msg.includes('CRC-32') || msg.includes('CRC32 checksum')) {
+                    msg = 'CRC-32 failed';
+                }
+                else if (msg.includes('SHA-256') || msg.includes('INVALID_SHA256') || msg.includes('SHA-256 hash')) {
+                    msg = 'SHA-256 failed';
+                    // Track SHA-256 failure for content files
+                    if (isContentFile && !options.skipBlockchain) {
+                        allFilesValid = false;
+                        failedFiles.push(name);
+                    }
+                }
+            }
+            console.log(`testing: ${name}  ${msg}`);
+        }
+    }
+    const count = entries.length;
+    if (failures === 0) {
+        console.log(`No errors detected in compressed data of ${count} file${count === 1 ? '' : 's'}`);
+    }
+    else {
+        console.log(`Errors detected in compressed data (${failures} of ${count} file${count === 1 ? '' : 's'})`);
+    }
+    // Calculate merkle root from verified hashes
+    let merkleRoot = null;
+    if (!options.skipBlockchain && contentEntriesForMerkle.length > 0) {
+        merkleRoot = hashAccumulator.merkleRoot();
+    }
+    return {
+        failures,
+        extractionResult: { merkleRoot, allFilesValid, failedFiles }
+    };
+}
+/**
+ * Pre-verify archive integrity and blockchain authenticity before extraction
+ * Returns success status and any errors
+ */
+async function preVerifyArchive(zip, archiveName, options) {
+    console.log('\n🔍 Pre-verifying archive before extraction...\n');
+    // Step 1: Test archive integrity (CRC/SHA-256)
+    const testResult = await testArchive(zip, options);
+    if (testResult.failures > 0) {
+        console.log(`\n❌ Integrity verification failed: ${testResult.failures} file(s) failed CRC/SHA-256 checks`);
+        return {
+            success: false,
+            integrityPassed: false,
+            blockchainPassed: false,
+            error: `Integrity check failed: ${testResult.failures} file(s) failed verification`
+        };
+    }
+    if (!testResult.extractionResult.allFilesValid) {
+        console.log(`\n❌ Integrity verification failed: SHA-256 verification failed for one or more files`);
+        if (testResult.extractionResult.failedFiles.length > 0) {
+            console.log(`   Failed files: ${testResult.extractionResult.failedFiles.join(', ')}`);
+        }
+        return {
+            success: false,
+            integrityPassed: false,
+            blockchainPassed: false,
+            error: `SHA-256 verification failed for: ${testResult.extractionResult.failedFiles.join(', ')}`
+        };
+    }
+    console.log('✓ Integrity verification passed (CRC/SHA-256)');
+    // Step 2: Check for blockchain metadata and verify if present
+    const entries = await getDirectory(zip, false);
+    const tokenEntry = entries.find((e) => (e.filename || '') === 'META-INF/NZIP.TOKEN');
+    if (!tokenEntry) {
+        // No blockchain metadata - integrity check is sufficient
+        console.log('✓ No blockchain metadata found - integrity verification sufficient');
+        return {
+            success: true,
+            integrityPassed: true,
+            blockchainPassed: true // Not applicable
+        };
+    }
+    // Blockchain metadata exists - verify it
+    console.log('Blockchain metadata detected - verifying authenticity...');
+    if (options.skipBlockchain) {
+        console.log('⚠️  Blockchain verification skipped by user request');
+        return {
+            success: true,
+            integrityPassed: true,
+            blockchainPassed: false // Skipped
+        };
+    }
+    // Perform blockchain verification
+    // We'll use a modified approach that captures the result
+    let verificationSuccess = false;
+    let verificationError;
+    try {
+        const verifier = new src_1.ZipkitVerifier({
+            debug: options.verbose,
+            skipHash: options.skipBlockchain
+        });
+        // Extract token metadata
+        const fileBased = isFileBased(zip);
+        const bufferBased = isBufferBased(zip);
+        let tokenBuffer;
+        try {
+            if (bufferBased) {
+                const tokenBuf = await extractEntry(zip, tokenEntry);
+                if (!tokenBuf) {
+                    throw new Error('Cannot read token metadata (no data)');
+                }
+                tokenBuffer = tokenBuf;
+            }
+            else if (fileBased) {
+                const tmpPath = path.join(require('os').tmpdir(), `neounzip-preverify-${Date.now()}-${tokenEntry.filename?.replace(/[^a-zA-Z0-9]/g, '_') || 'token'}`);
+                try {
+                    await zip.extractToFile(tokenEntry, tmpPath, {
+                        skipHashCheck: options.skipBlockchain
+                    });
+                    tokenBuffer = fs.readFileSync(tmpPath);
+                    if (fs.existsSync(tmpPath)) {
+                        fs.unlinkSync(tmpPath);
+                    }
+                }
+                catch (extractErr) {
+                    if (fs.existsSync(tmpPath)) {
+                        try {
+                            fs.unlinkSync(tmpPath);
+                        }
+                        catch {
+                            // Ignore cleanup errors
+                        }
+                    }
+                    throw extractErr;
+                }
+            }
+            else {
+                throw new Error('ZIP file not loaded. Cannot determine backend type.');
+            }
+        }
+        catch (err) {
+            throw new Error(`Cannot read token metadata: ${err.message}`);
+        }
+        // Parse token metadata
+        const metadataResult = await verifier.extractTokenMetadata(tokenBuffer);
+        if (!metadataResult.success || !metadataResult.metadata) {
+            throw new Error(metadataResult.error || 'Failed to parse token metadata');
+        }
+        // Use pre-calculated merkle root from test
+        const calculatedMerkleRoot = testResult.extractionResult.merkleRoot;
+        if (!calculatedMerkleRoot) {
+            throw new Error('Failed to calculate merkle root from archive contents');
+        }
+        // Get network config
+        const tokenMetadata = metadataResult.metadata;
+        const chainId = tokenMetadata.networkChainId;
+        let networkConfig = null;
+        if (chainId) {
+            networkConfig = (0, blockchain_1.getContractConfig)(chainId);
+        }
+        else {
+            const networkName = tokenMetadata.network.toLowerCase();
+            if (networkName.includes('base sepolia') || networkName === 'base-sepolia') {
+                networkConfig = (0, blockchain_1.getContractConfig)(84532);
+            }
+            else if (networkName.includes('base mainnet') || networkName === 'base-mainnet' || networkName === 'base') {
+                networkConfig = (0, blockchain_1.getContractConfig)(8453);
+            }
+            else if (networkName.includes('arbitrum sepolia') || networkName === 'arbitrum-sepolia' || (networkName.includes('arbitrum') && networkName.includes('sepolia'))) {
+                networkConfig = (0, blockchain_1.getContractConfig)(421614);
+            }
+            else if (networkName.includes('sepolia testnet') || networkName === 'sepolia-testnet' || (networkName.includes('sepolia') && !networkName.includes('base') && !networkName.includes('arbitrum'))) {
+                networkConfig = (0, blockchain_1.getContractConfig)(11155111);
+            }
+        }
+        // Perform verification (non-interactive mode for pre-verify)
+        const originalNonInteractive = options.nonInteractive;
+        options.nonInteractive = true; // Force non-interactive to avoid prompts during pre-verify
+        let verificationResult;
+        let currentRpcIndex = 0;
+        let maxRetries = 3;
+        let retryCount = 0;
+        while (true) {
+            try {
+                verificationResult = await verifier.verifyToken(tokenMetadata, calculatedMerkleRoot, {
+                    debug: options.verbose,
+                    skipHash: options.skipBlockchain
+                }, currentRpcIndex);
+                if (verificationResult.success) {
+                    verificationSuccess = true;
+                    break;
+                }
+                // Check if timeout - in pre-verify mode, we'll try next RPC or fail
+                const isTimeout = verificationResult.message?.toLowerCase().includes('timeout') ||
+                    verificationResult.errorDetails?.errorType === 'CONTRACT_ERROR' &&
+                        (verificationResult.message?.includes('timeout') ||
+                            verificationResult.message?.includes('Contract call timeout'));
+                if (isTimeout && networkConfig && currentRpcIndex < networkConfig.rpcUrls.length - 1) {
+                    // Try next RPC
+                    currentRpcIndex++;
+                    retryCount = 0;
+                    continue;
+                }
+                else {
+                    // No more RPCs or not a timeout - fail
+                    verificationError = verificationResult.message || 'Blockchain verification failed';
+                    break;
+                }
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                const isTimeout = errorMessage.toLowerCase().includes('timeout');
+                if (isTimeout && networkConfig && currentRpcIndex < networkConfig.rpcUrls.length - 1) {
+                    currentRpcIndex++;
+                    retryCount = 0;
+                    continue;
+                }
+                else {
+                    verificationError = `Verification error: ${errorMessage}`;
+                    break;
+                }
+            }
+        }
+        // Restore original non-interactive setting
+        options.nonInteractive = originalNonInteractive;
+        if (verificationSuccess) {
+            console.log('✓ Blockchain verification passed');
+            return {
+                success: true,
+                integrityPassed: true,
+                blockchainPassed: true
+            };
+        }
+        else {
+            console.log(`\n❌ Blockchain verification failed: ${verificationError}`);
+            return {
+                success: false,
+                integrityPassed: true,
+                blockchainPassed: false,
+                error: verificationError
+            };
+        }
+    }
+    catch (error) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        console.log(`\n❌ Blockchain verification error: ${errorMsg}`);
+        return {
+            success: false,
+            integrityPassed: true,
+            blockchainPassed: false,
+            error: errorMsg
+        };
+    }
+}
+/**
+ * Extract archive to destination
+ * Returns merkle root calculation result for blockchain verification
+ */
+async function extractArchive(zip, destination, options) {
+    ensureDir(destination);
+    // Set password on zip instance if provided (needed for decryption)
+    if (options.password) {
+        zip.password = options.password;
+    }
+    const entries = await getDirectory(zip, false);
+    // Filter entries using ZipkitServer.filterEntries()
+    const filteredEntries = zip.filterEntries(entries, {
+        include: options.include,
+        exclude: options.exclude,
+        skipMetadata: true // Skip META-INF/NZIP.TOKEN automatically
+    });
+    if (options.verbose && (options.include || options.exclude)) {
+        log(`File filtering applied:`, options);
+        if (options.include) {
+            log(`  Include patterns: ${options.include.join(', ')}`, options);
+        }
+        if (options.exclude) {
+            log(`  Exclude patterns: ${options.exclude.join(', ')}`, options);
+        }
+        log(`  Original files: ${entries.length}, Filtered files: ${filteredEntries.length}`, options);
+    }
+    let totalFiles = 0;
+    let totalBytes = 0;
+    let alwaysOverwrite = false; // Track "always" response from user
+    let processedFiles = 0;
+    const totalEntries = filteredEntries.length;
+    // For merkle root calculation: collect verified SHA-256 hashes during extraction
+    const hashAccumulator = new HashCalculator_1.default({ enableAccumulation: true });
+    let allFilesValid = true;
+    const failedFiles = [];
+    // Filter out metadata files for merkle root calculation
+    const contentEntriesForMerkle = filteredEntries.filter(entry => {
+        const filename = entry.filename || '';
+        return filename !== src_1.TOKENIZED_METADATA &&
+            filename !== src_1.TIMESTAMP_METADATA &&
+            filename !== src_1.TIMESTAMP_SUBMITTED &&
+            !entry.isDirectory;
+    });
+    for (const entry of filteredEntries) {
+        const filename = entry.filename || '';
+        if (options.debug) {
+            logDebug(`Processing entry: ${filename}`, options);
+            logDebug(`  Entry size: ${entry.uncompressedSize || 0} bytes`, options);
+            logDebug(`  Compressed size: ${entry.compressedSize || 0} bytes`, options);
+            logDebug(`  Compression method: ${entry.compressionMethod || 'unknown'}`, options);
+            logDebug(`  Is encrypted: ${entry.isEncrypted || false}`, options);
+            logDebug(`  CRC32: ${entry.crc || 'unknown'}`, options);
+        }
+        if (options.progress && !options.quiet) {
+            log(`📦 Extracting file ${processedFiles + 1}/${totalEntries}: ${filename}`, options);
+        }
+        if (options.showFiles && !options.quiet) {
+            log(`extracting: ${filename}`, options);
+        }
+        // Prepare extraction path using ZipkitServer.prepareExtractionPath()
+        const outPath = zip.prepareExtractionPath(entry, destination, {
+            junkPaths: options.junkPaths
+        });
+        // Determine if entry should be extracted using ZipkitServer.shouldExtractEntry()
+        const shouldExtract = await zip.shouldExtractEntry(entry, outPath, {
+            overwrite: options.overwrite || alwaysOverwrite,
+            never: options.never,
+            freshenOnly: options.freshenOnly,
+            updateOnly: options.updateOnly,
+            onOverwritePrompt: async (filename) => {
+                if (options.quiet) {
+                    return 'n'; // Skip in quiet mode
+                }
+                const response = await promptOverwrite(filename);
+                if (response === 'a') {
+                    alwaysOverwrite = true; // Track "always" response
+                }
+                return response;
+            }
+        });
+        if (!shouldExtract.shouldExtract) {
+            if (shouldExtract.reason) {
+                if (options.verbose || shouldExtract.reason.includes('abort')) {
+                    log(shouldExtract.reason, options);
+                }
+                if (shouldExtract.reason.includes('abort')) {
+                    return { merkleRoot: null, allFilesValid: false, failedFiles: [] }; // User aborted
+                }
+            }
+            continue;
+        }
+        // Extract entry using ZipkitServer.extractEntryToPath()
+        const result = await zip.extractEntryToPath(entry, outPath, {
+            skipHashCheck: options.skipBlockchain,
+            preserveTimestamps: true, // Always preserve timestamps
+            preservePermissions: options.preservePerms || false,
+            symlinks: options.symlinks || false,
+            hardLinks: options.hardLinks || false,
+            onProgress: options.enableProgress ? (entry, bytes) => {
+                // Update progress if needed
+                if (options.progress && !options.quiet) {
+                    // Progress is already shown above
+                }
+            } : undefined
+        });
+        if (result.success) {
+            totalFiles++;
+            totalBytes += result.bytesExtracted;
+            const hasSha = entry.sha256 ? true : false;
+            const suffix = hasSha ? (options.skipBlockchain ? ' (SHA-256 skipped)' : ' (SHA-256 OK)') : '';
+            if (options.verbose)
+                log(`extracting: ${filename} (${result.bytesExtracted} bytes)${suffix}`, options);
+            else
+                log(`extracting: ${filename}${suffix}`, options);
+            // Collect verified SHA-256 hash for merkle root calculation (single pass - no double check)
+            // Only if this is a content file (not metadata) and SHA-256 verification was performed
+            if (!options.skipBlockchain && hasSha) {
+                const isContentFile = filename !== src_1.TOKENIZED_METADATA &&
+                    filename !== src_1.TIMESTAMP_METADATA &&
+                    filename !== src_1.TIMESTAMP_SUBMITTED &&
+                    !entry.isDirectory;
+                if (isContentFile && entry.sha256) {
+                    // Use the verified hash from the entry (already verified during extraction)
+                    const hashBuffer = Buffer.from(entry.sha256, 'hex');
+                    hashAccumulator.addHash(hashBuffer);
+                }
+            }
+        }
+        else {
+            log(`error: ${filename} (${result.error || 'unknown error'})`, options);
+            // Track failed files for merkle root calculation
+            const isContentFile = filename !== src_1.TOKENIZED_METADATA &&
+                filename !== src_1.TIMESTAMP_METADATA &&
+                filename !== src_1.TIMESTAMP_SUBMITTED &&
+                !entry.isDirectory;
+            if (isContentFile && !options.skipBlockchain) {
+                // Check if failure was due to SHA-256 mismatch
+                const errorMsg = result.error || '';
+                if (errorMsg.includes('SHA-256') || errorMsg.includes('INVALID_SHA256')) {
+                    allFilesValid = false;
+                    failedFiles.push(filename);
+                }
+            }
+        }
+        processedFiles++;
+    }
+    if (totalFiles > 0) {
+        log(`\n✅ Extraction completed: ${totalFiles} files, ${formatBytes(totalBytes)} extracted`, options);
+    }
+    // Calculate merkle root from verified hashes
+    let merkleRoot = null;
+    if (!options.skipBlockchain && contentEntriesForMerkle.length > 0) {
+        merkleRoot = hashAccumulator.merkleRoot();
+    }
+    return { merkleRoot, allFilesValid, failedFiles };
+}
+/**
+ * Detect and verify tokenization metadata inside the ZIP against blockchain
+ * @param extractionResult Optional pre-calculated merkle root from extraction/test (avoids double pass)
+ */
+async function verifyTokenization(zip, archiveName, options, extractionResult) {
+    try {
+        const entries = await getDirectory(zip, false);
+        const tokenEntry = entries.find((e) => (e.filename || '') === 'META-INF/NZIP.TOKEN');
+        if (tokenEntry) {
+            console.log('\nTokenization detected (META-INF/NZIP.TOKEN)');
+        }
+        // Only do token verification if there's a token entry
+        if (tokenEntry) {
+            // Skip blockchain verification if requested
+            if (options.skipBlockchain) {
+                console.log('Blockchain verification skipped by user request');
+                return;
+            }
+            // Initialize blockchain verifier
+            const verifier = new src_1.ZipkitVerifier({
+                debug: options.verbose, // Enable debug output in verbose mode
+                skipHash: options.skipBlockchain
+            });
+            // Extract token metadata from ZIP
+            // Check if ZIP is file-based or buffer-based and use appropriate extraction method
+            const fileBased = isFileBased(zip);
+            const bufferBased = isBufferBased(zip);
+            let tokenBuffer;
+            try {
+                if (bufferBased) {
+                    // Buffer-based: use extract() which performs CRC/SHA checks
+                    const tokenBuf = await extractEntry(zip, tokenEntry);
+                    if (!tokenBuf) {
+                        console.log('✗ Cannot read token metadata (no data)');
+                        return;
+                    }
+                    tokenBuffer = tokenBuf;
+                }
+                else if (fileBased) {
+                    // File-based: extract to temporary file, then read it
+                    const tmpPath = path.join(require('os').tmpdir(), `neounzip-token-${Date.now()}-${tokenEntry.filename?.replace(/[^a-zA-Z0-9]/g, '_') || 'token'}`);
+                    try {
+                        await zip.extractToFile(tokenEntry, tmpPath, {
+                            skipHashCheck: options.skipBlockchain
+                        });
+                        // Read the extracted token file
+                        tokenBuffer = fs.readFileSync(tmpPath);
+                        // Clean up temporary file
+                        if (fs.existsSync(tmpPath)) {
+                            fs.unlinkSync(tmpPath);
+                        }
+                    }
+                    catch (extractErr) {
+                        // Clean up temporary file on error
+                        if (fs.existsSync(tmpPath)) {
+                            try {
+                                fs.unlinkSync(tmpPath);
+                            }
+                            catch {
+                                // Ignore cleanup errors
+                            }
+                        }
+                        throw extractErr;
+                    }
+                }
+                else {
+                    throw new Error('ZIP file not loaded. Cannot determine backend type.');
+                }
+            }
+            catch (err) {
+                console.log('✗ Cannot read token metadata (CRC/IO error)');
+                if (options.verbose) {
+                    console.log(`   Error: ${err.message}`);
+                }
+                return;
+            }
+            // Parse token metadata
+            const metadataResult = await verifier.extractTokenMetadata(tokenBuffer);
+            if (!metadataResult.success || !metadataResult.metadata) {
+                console.log(`✗ ${metadataResult.error}`);
+                return;
+            }
+            // Calculate merkle root from archive contents
+            // CRITICAL: Use pre-calculated merkle root from extraction if available (single pass - no double extraction)
+            // If not available (e.g., list-only mode), extract files once to calculate merkle root
+            let calculatedMerkleRoot = null;
+            let allFilesValid = true;
+            let failedFiles = [];
+            if (extractionResult) {
+                // Use pre-calculated merkle root from extraction/test (single pass - already verified SHA-256)
+                calculatedMerkleRoot = extractionResult.merkleRoot;
+                allFilesValid = extractionResult.allFilesValid;
+                failedFiles = extractionResult.failedFiles;
+                if (!allFilesValid) {
+                    console.log('\n⚠️  WARNING: One or more files failed SHA-256 verification during extraction.');
+                    console.log('   Blockchain verification cannot be considered valid.');
+                    if (options.verbose && failedFiles.length > 0) {
+                        console.log(`   Failed files: ${failedFiles.join(', ')}`);
+                    }
+                    // Skip blockchain verification if files failed SHA-256
+                    return;
+                }
+            }
+            else if (!options.skipBlockchain) {
+                // No pre-calculated result (e.g., list-only mode) - extract files once to calculate merkle root
+                try {
+                    console.log('   Calculating merkle root from actual file contents...');
+                    const hashAccumulator = new HashCalculator_1.default({ enableAccumulation: true });
+                    // Filter out blockchain metadata files to ensure consistent Merkle Root calculation
+                    const contentEntries = entries.filter(entry => {
+                        const filename = entry.filename || '';
+                        return filename !== src_1.TOKENIZED_METADATA &&
+                            filename !== src_1.TIMESTAMP_METADATA &&
+                            filename !== src_1.TIMESTAMP_SUBMITTED &&
+                            !entry.isDirectory; // Skip directories
+                    });
+                    // Extract each file once and verify SHA-256 during extraction
+                    let hashCount = 0;
+                    for (const entry of contentEntries) {
+                        try {
+                            let fileData = null;
+                            // Extract the file to get actual data (single pass - verify SHA-256 during extraction)
+                            if (bufferBased) {
+                                // Buffer-based: use extract() which verifies SHA-256 during extraction
+                                fileData = await zip.extract(entry, false); // false = verify hash
+                            }
+                            else if (fileBased) {
+                                // File-based: extract to temporary file, then read it
+                                const tmpPath = path.join(require('os').tmpdir(), `neounzip-verify-${Date.now()}-${(entry.filename || 'file').replace(/[^a-zA-Z0-9]/g, '_')}`);
+                                try {
+                                    await zip.extractToFile(entry, tmpPath, {
+                                        skipHashCheck: false // Verify hashes during extraction
+                                    });
+                                    fileData = fs.readFileSync(tmpPath);
+                                    // Clean up temporary file
+                                    if (fs.existsSync(tmpPath)) {
+                                        fs.unlinkSync(tmpPath);
+                                    }
+                                }
+                                catch (extractErr) {
+                                    // Clean up temporary file on error
+                                    if (fs.existsSync(tmpPath)) {
+                                        try {
+                                            fs.unlinkSync(tmpPath);
+                                        }
+                                        catch {
+                                            // Ignore cleanup errors
+                                        }
+                                    }
+                                    // If extraction fails due to SHA-256, track it
+                                    const errorMsg = extractErr instanceof Error ? extractErr.message : String(extractErr);
+                                    if (errorMsg.includes('SHA-256') || errorMsg.includes('INVALID_SHA256')) {
+                                        allFilesValid = false;
+                                        failedFiles.push(entry.filename || 'unknown');
+                                    }
+                                    // Skip this entry
+                                    if (options.verbose) {
+                                        console.log(`   Warning: Could not extract ${entry.filename} for merkle root calculation`);
+                                    }
+                                    continue;
+                                }
+                            }
+                            else {
+                                if (options.verbose) {
+                                    console.log(`   Warning: ZIP backend type unknown, cannot extract ${entry.filename}`);
+                                }
+                                continue;
+                            }
+                            if (fileData && entry.sha256) {
+                                // Use the verified hash from the entry (already verified during extraction - no double check)
+                                const hashBuffer = Buffer.from(entry.sha256, 'hex');
+                                hashAccumulator.addHash(hashBuffer);
+                                hashCount++;
+                            }
+                        }
+                        catch (error) {
+                            // If we can't extract a file, track it
+                            const errorMsg = error instanceof Error ? error.message : String(error);
+                            if (errorMsg.includes('SHA-256') || errorMsg.includes('INVALID_SHA256')) {
+                                allFilesValid = false;
+                                failedFiles.push(entry.filename || 'unknown');
+                            }
+                            // Skip this entry
+                            if (options.verbose) {
+                                console.log(`   Warning: Could not calculate hash for ${entry.filename}: ${errorMsg}`);
+                            }
+                            continue;
+                        }
+                    }
+                    if (hashCount === 0) {
+                        if (options.verbose) {
+                            console.log(`   Error: No files could be extracted for merkle root calculation`);
+                        }
+                        calculatedMerkleRoot = null;
+                    }
+                    else {
+                        calculatedMerkleRoot = hashAccumulator.merkleRoot();
+                        if (options.verbose) {
+                            console.log(`   Calculated merkle root from ${hashCount} file(s)`);
+                        }
+                    }
+                    // Check if any files failed SHA-256
+                    if (!allFilesValid) {
+                        console.log('\n⚠️  WARNING: One or more files failed SHA-256 verification.');
+                        console.log('   Blockchain verification cannot be considered valid.');
+                        if (options.verbose && failedFiles.length > 0) {
+                            console.log(`   Failed files: ${failedFiles.join(', ')}`);
+                        }
+                        // Skip blockchain verification if files failed SHA-256
+                        return;
+                    }
+                }
+                catch (error) {
+                    if (options.verbose) {
+                        console.log(`   Error calculating merkle root: ${error instanceof Error ? error.message : String(error)}`);
+                    }
+                    calculatedMerkleRoot = null;
+                }
+            }
+            // Perform complete verification with timeout handling and RPC retry logic
+            console.log('Verifying token on blockchain...');
+            // Get network config to access RPC URLs
+            const tokenMetadata = metadataResult.metadata;
+            const chainId = tokenMetadata.networkChainId;
+            let networkConfig = null;
+            if (chainId) {
+                networkConfig = (0, blockchain_1.getContractConfig)(chainId);
+            }
+            else {
+                // Fallback: try to determine chain ID from network name
+                const networkName = tokenMetadata.network.toLowerCase();
+                if (networkName.includes('base sepolia') || networkName === 'base-sepolia') {
+                    networkConfig = (0, blockchain_1.getContractConfig)(84532);
+                }
+                else if (networkName.includes('base mainnet') || networkName === 'base-mainnet' || networkName === 'base') {
+                    networkConfig = (0, blockchain_1.getContractConfig)(8453);
+                }
+                else if (networkName.includes('arbitrum sepolia') || networkName === 'arbitrum-sepolia' || (networkName.includes('arbitrum') && networkName.includes('sepolia'))) {
+                    networkConfig = (0, blockchain_1.getContractConfig)(421614);
+                }
+                else if (networkName.includes('sepolia testnet') || networkName === 'sepolia-testnet' || (networkName.includes('sepolia') && !networkName.includes('base') && !networkName.includes('arbitrum'))) {
+                    networkConfig = (0, blockchain_1.getContractConfig)(11155111);
+                }
+            }
+            let verificationResult;
+            let currentRpcIndex = 0;
+            let maxRetries = 3; // Maximum retries per RPC
+            let retryCount = 0;
+            while (true) {
+                try {
+                    verificationResult = await verifier.verifyToken(tokenMetadata, calculatedMerkleRoot, {
+                        debug: options.verbose,
+                        skipHash: options.skipBlockchain
+                    }, currentRpcIndex);
+                    // If successful, break out of retry loop
+                    if (verificationResult.success) {
+                        break;
+                    }
+                    // Check if this is a timeout error
+                    const isTimeout = verificationResult.message?.toLowerCase().includes('timeout') ||
+                        verificationResult.errorDetails?.errorType === 'CONTRACT_ERROR' &&
+                            (verificationResult.message?.includes('timeout') ||
+                                verificationResult.message?.includes('Contract call timeout'));
+                    if (isTimeout && !options.nonInteractive && networkConfig) {
+                        // Display the error first
+                        console.log(`❌ ${verificationResult.message}`);
+                        // Show verbose error details
+                        if (verificationResult.errorDetails) {
+                            const errorDetails = verificationResult.errorDetails;
+                            console.log(`  Error Type: ${errorDetails.errorType}`);
+                            if (errorDetails.networkName)
+                                console.log(`  Network: ${errorDetails.networkName}`);
+                            if (errorDetails.rpcUrl)
+                                console.log(`  RPC URL: ${errorDetails.rpcUrl}`);
+                            if (errorDetails.contractAddress)
+                                console.log(`  Contract: ${errorDetails.contractAddress}`);
+                            if (errorDetails.tokenId)
+                                console.log(`  Token ID: ${errorDetails.tokenId}`);
+                        }
+                        // Prompt user for action
+                        const action = await promptForTimeoutAction(networkConfig, currentRpcIndex, options.nonInteractive || false);
+                        if (action === 'exit') {
+                            // User chose to exit - exit with appropriate code
+                            const errorType = verificationResult.errorDetails?.errorType;
+                            if (errorType === 'METADATA_ERROR') {
+                                (0, exit_codes_1.exitUnzip)(exit_codes_1.UNZIP_EXIT_CODES.TOKEN_VERIFY_METADATA_ERROR, 'Verification cancelled by user');
+                            }
+                            else if (errorType === 'MERKLE_ERROR') {
+                                (0, exit_codes_1.exitUnzip)(exit_codes_1.UNZIP_EXIT_CODES.TOKEN_VERIFY_MERKLE_MISMATCH, 'Verification cancelled by user');
+                            }
+                            else if (errorType === 'NETWORK_ERROR') {
+                                (0, exit_codes_1.exitUnzip)(exit_codes_1.UNZIP_EXIT_CODES.TOKEN_VERIFY_NETWORK_ERROR, 'Verification cancelled by user');
+                            }
+                            else {
+                                (0, exit_codes_1.exitUnzip)(exit_codes_1.UNZIP_EXIT_CODES.TOKEN_VERIFY_USER_CANCELLED, 'Verification cancelled by user');
+                            }
+                        }
+                        else if (action === 'retry') {
+                            // Retry with same RPC
+                            retryCount++;
+                            if (retryCount >= maxRetries) {
+                                console.log(`\n❌ Maximum retries (${maxRetries}) reached for current RPC`);
+                                break;
+                            }
+                            console.log(`\n🔄 Retrying verification (attempt ${retryCount + 1}/${maxRetries})...`);
+                            continue;
+                        }
+                        else if (action === 'next-rpc') {
+                            // Try next RPC URL
+                            currentRpcIndex++;
+                            retryCount = 0; // Reset retry count for new RPC
+                            if (currentRpcIndex >= networkConfig.rpcUrls.length) {
+                                console.log('\n❌ No more RPC URLs available');
+                                break;
+                            }
+                            console.log(`\n🔄 Trying next RPC URL (${currentRpcIndex + 1}/${networkConfig.rpcUrls.length})...`);
+                            continue;
+                        }
+                    }
+                    else {
+                        // Not a timeout or non-interactive mode - break and show error
+                        break;
+                    }
+                }
+                catch (error) {
+                    // Handle unexpected errors
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    const isTimeout = errorMessage.toLowerCase().includes('timeout');
+                    if (isTimeout && !options.nonInteractive && networkConfig) {
+                        // Display the error first
+                        console.log(`❌ Verification error: ${errorMessage}`);
+                        console.log(`  Network: ${tokenMetadata.network}`);
+                        console.log(`  RPC URL: ${networkConfig.rpcUrls[currentRpcIndex] || 'unknown'}`);
+                        const action = await promptForTimeoutAction(networkConfig, currentRpcIndex, options.nonInteractive || false);
+                        if (action === 'exit') {
+                            // User chose to exit - exit with timeout/network error code
+                            if (errorMessage.toLowerCase().includes('timeout')) {
+                                (0, exit_codes_1.exitUnzip)(exit_codes_1.UNZIP_EXIT_CODES.TOKEN_VERIFY_TIMEOUT, `Verification cancelled by user: ${errorMessage}`);
+                            }
+                            else {
+                                (0, exit_codes_1.exitUnzip)(exit_codes_1.UNZIP_EXIT_CODES.TOKEN_VERIFY_NETWORK_ERROR, `Verification cancelled by user: ${errorMessage}`);
+                            }
+                        }
+                        else if (action === 'retry') {
+                            retryCount++;
+                            if (retryCount >= maxRetries) {
+                                verificationResult = {
+                                    success: false,
+                                    message: `Maximum retries reached: ${errorMessage}`,
+                                    errorDetails: {
+                                        errorType: 'CONTRACT_ERROR',
+                                        networkName: tokenMetadata.network
+                                    }
+                                };
+                                break;
+                            }
+                            console.log(`\n🔄 Retrying verification (attempt ${retryCount + 1}/${maxRetries})...`);
+                            continue;
+                        }
+                        else if (action === 'next-rpc') {
+                            currentRpcIndex++;
+                            retryCount = 0;
+                            if (currentRpcIndex >= networkConfig.rpcUrls.length) {
+                                verificationResult = {
+                                    success: false,
+                                    message: `No more RPC URLs available: ${errorMessage}`,
+                                    errorDetails: {
+                                        errorType: 'CONTRACT_ERROR',
+                                        networkName: tokenMetadata.network
+                                    }
+                                };
+                                break;
+                            }
+                            console.log(`\n🔄 Trying next RPC URL (${currentRpcIndex + 1}/${networkConfig.rpcUrls.length})...`);
+                            continue;
+                        }
+                    }
+                    else {
+                        // Not a timeout or non-interactive - return error
+                        verificationResult = {
+                            success: false,
+                            message: `Verification error: ${errorMessage}`,
+                            errorDetails: {
+                                errorType: 'CONTRACT_ERROR',
+                                networkName: tokenMetadata.network
+                            }
+                        };
+                        break;
+                    }
+                }
+            }
+            // Display results based on verification outcome
+            if (verificationResult.success && verificationResult.verificationDetails) {
+                // Show Merkle Root verification first
+                if (verificationResult.verificationDetails.merkleRoot && verificationResult.verificationDetails.calculatedMerkleRoot) {
+                    const contractRoot = verificationResult.verificationDetails.merkleRoot;
+                    const calculatedRoot = verificationResult.verificationDetails.calculatedMerkleRoot;
+                    const rootsMatch = contractRoot === calculatedRoot;
+                    console.log(`🔐 Merkle Root: ${contractRoot}`);
+                    if (rootsMatch) {
+                        console.log(`✓ Contract Merkle Root verified against calculated Merkle Root`);
+                    }
+                }
+                // Green checkmark for successful verification
+                // NOTE: All verification data (merkle root, mint date) comes from blockchain, not metadata
+                console.log(`✅ ${verificationResult.message}.`);
+                console.log(`The archive, tokenized as NFT #${verificationResult.verificationDetails.tokenId} on the ${verificationResult.verificationDetails.network}, was minted on ${verificationResult.verificationDetails.mintDate}.`);
+                if (options.verbose && verificationResult.verificationDetails) {
+                    console.log(`  Contract: ${verificationResult.verificationDetails.contractAddress}`);
+                    console.log(`  Network: ${verificationResult.verificationDetails.network}`);
+                    if (verificationResult.verificationDetails.declaredMerkleRoot) {
+                        console.log(`  Declared: ${verificationResult.verificationDetails.declaredMerkleRoot}`);
+                    }
+                }
+            }
+            else {
+                // Red X for failed verification
+                console.log(`❌ ${verificationResult.message}`);
+                // Always show Merkle root details for MERKLE_ERROR type
+                if (verificationResult.errorDetails?.errorType === 'MERKLE_ERROR') {
+                    const errorDetails = verificationResult.errorDetails;
+                    console.log(`\n📊 Merkle Root Comparison:`);
+                    if (errorDetails.calculatedMerkleRoot) {
+                        console.log(`   Calculated Merkle Root: ${errorDetails.calculatedMerkleRoot}`);
+                    }
+                    if (errorDetails.onChainMerkleRoot) {
+                        console.log(`   On-Chain Merkle Root:   ${errorDetails.onChainMerkleRoot}`);
+                    }
+                    if (errorDetails.calculatedMerkleRoot && errorDetails.onChainMerkleRoot) {
+                        const match = errorDetails.calculatedMerkleRoot.toLowerCase() === errorDetails.onChainMerkleRoot.toLowerCase();
+                        console.log(`   Match: ${match ? '✓' : '✗'}`);
+                    }
+                }
+                if (options.verbose && verificationResult.errorDetails) {
+                    const errorDetails = verificationResult.errorDetails;
+                    console.log(`\n  Error Type: ${errorDetails.errorType}`);
+                    if (errorDetails.networkName)
+                        console.log(`  Network: ${errorDetails.networkName}`);
+                    if (errorDetails.rpcUrl)
+                        console.log(`  RPC URL: ${errorDetails.rpcUrl}`);
+                    if (errorDetails.contractAddress)
+                        console.log(`  Contract: ${errorDetails.contractAddress}`);
+                    if (errorDetails.tokenId)
+                        console.log(`  Token ID: ${errorDetails.tokenId}`);
+                    if (errorDetails.merkleRoot && errorDetails.errorType !== 'MERKLE_ERROR') {
+                        // Only show this if we haven't already shown the detailed comparison above
+                        console.log(`  Merkle Root: ${errorDetails.merkleRoot}`);
+                    }
+                }
+            }
+        } // End of token verification if statement
+        // Check for OpenTimestamp verification and upgrade
+        await verifyAndUpgradeOts(zip, archiveName, options);
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        console.log(`✗ Tokenization verification failed: ${msg}`);
+    }
+}
+/**
+ * Verify OpenTimestamp and prompt for upgrade if available
+ */
+async function verifyAndUpgradeOts(zip, archiveName, options) {
+    try {
+        // Skip OTS verification if blockchain verification is disabled
+        if (options.skipBlockchain) {
+            console.log('OpenTimestamps verification skipped by user request');
+            return;
+        }
+        // Check if this is an OTS timestamped file
+        const entries = await getDirectory(zip, false);
+        const otsEntry = entries.find((e) => (e.filename || '') === 'META-INF/TS-SUBMIT.OTS' ||
+            (e.filename || '') === 'META-INF/TIMESTAMP.OTS');
+        if (!otsEntry) {
+            return;
+        }
+        const res = await (0, src_1.verifyOtsZip)(zip);
+        console.log('\n🕐 OpenTimestamps Verification:');
+        if (res.status === 'none') {
+            console.log(' - Status: No OpenTimestamps found');
+            return;
+        }
+        if (res.status === 'valid') {
+            if (res.blockHeight && res.attestedAt) {
+                const date = res.attestedAt.toLocaleDateString(undefined, {
+                    month: '2-digit',
+                    day: '2-digit',
+                    year: 'numeric'
+                });
+                const time = res.attestedAt.toLocaleTimeString(undefined, {
+                    hour: '2-digit',
+                    minute: '2-digit',
+                    hour12: false
+                });
+                console.log(` - Status: ✅ VERIFIED`);
+                console.log(` - Attested: Bitcoin block ${res.blockHeight} on ${date} ${time}`);
+            }
+            else {
+                console.log(' - Status: ✅ VERIFIED');
+            }
+            if (res.upgraded && res.upgradedOts) {
+                let doUpgrade = false;
+                // Check automation options
+                if (options.otsSkipUpgrade) {
+                    doUpgrade = false;
+                    console.log(' - Upgrade: Skipped (--ots-skip-upgrade)');
+                }
+                else if (options.otsAutoUpgrade) {
+                    doUpgrade = true;
+                    console.log(' - Upgrade: Automatically applying (--ots-auto-upgrade)');
+                }
+                else {
+                    // Interactive mode - prompt user
+                    doUpgrade = await promptForOtsUpgrade(res, archiveName);
+                }
+                if (doUpgrade) {
+                    await performOtsUpgrade(archiveName, res.upgradedOts);
+                }
+                else if (!options.otsSkipUpgrade && !options.otsAutoUpgrade) {
+                    console.log(' - Note: You can upgrade later to save the improved timestamp');
+                }
+            }
+            return;
+        }
+        if (res.status === 'pending') {
+            console.log(' - Status: ⏳ PENDING (waiting for Bitcoin confirmation)');
+            if (res.message) {
+                console.log(` - Info: ${res.message}`);
+            }
+            return;
+        }
+        if (res.status === 'error') {
+            console.log(' - Status: ❌ ERROR');
+            if (res.message) {
+                console.log(` - Error: ${res.message}`);
+            }
+            return;
+        }
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        console.log('\n🕐 OpenTimestamps Verification:');
+        // Check for network/communication errors
+        if (errorMessage.includes('ESOCKETTIMEDOUT') ||
+            errorMessage.includes('ECONNRESET') ||
+            errorMessage.includes('ENOTFOUND') ||
+            errorMessage.includes('ECONNREFUSED') ||
+            errorMessage.includes('RequestError') ||
+            errorMessage.includes('timeout') ||
+            errorMessage.includes('network')) {
+            console.log(' - Status: 📡 COMMUNICATION ERROR (unable to contact OpenTimestamps servers)');
+            console.log(` - Error: ${errorMessage}`);
+            console.log(' - Note: Check your internet connection or try again later');
+            console.log(' - The archive\'s timestamp data is present but could not be verified due to connectivity issues');
+        }
+        else {
+            console.log(' - Status: ❌ ERROR during verification');
+            console.log(` - Error: ${errorMessage}`);
+        }
+    }
+}
+/**
+ * Parse command line arguments
+ */
+function parseArgs(args) {
+    const options = {
+        dest: '.',
+        test: false,
+        skipBlockchain: false,
+        verbose: false,
+        quiet: false,
+        overwrite: false,
+        testOnly: false,
+        bufferSize: 512 * 1024, // 512KB default (optimal for modern systems)
+        enableProgress: true,
+        junkPaths: false,
+        never: false
+    };
+    let archive = '';
+    let destination = '.';
+    let filePatterns = [];
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        switch (arg) {
+            case '-h':
+                showHelp();
+                process.exit(0);
+                break;
+            case '-h2':
+            case '--help-extended':
+                showExtendedHelp();
+                process.exit(0);
+                break;
+            case '--help':
+                showHelp();
+                process.exit(0);
+                break;
+            case '-V':
+            case '--version':
+                console.log(`NeoUnZip Version: ${version_1.APP_VERSION} (${version_1.APP_RELEASE_DATE})`);
+                process.exit(0);
+                break;
+            case '-v':
+            case '--verbose':
+                options.verbose = true;
+                break;
+            case '-q':
+            case '--quiet':
+                options.quiet = true;
+                break;
+            case '-o':
+            case '--overwrite':
+                options.overwrite = true;
+                break;
+            case '-f':
+                options.freshenOnly = true;
+                break;
+            case '-u':
+                options.updateOnly = true;
+                break;
+            case '-z':
+                options.commentOnly = true;
+                break;
+            case '-t':
+            case '--test':
+                if (options.preVerify) {
+                    console.error('Error: -t/--test and -T/--pre-verify cannot be used together');
+                    (0, exit_codes_1.exitUnzip)(exit_codes_1.UNZIP_EXIT_CODES.INVALID_OPTIONS);
+                }
+                options.testOnly = true;
+                break;
+            case '-T':
+            case '--pre-verify':
+                if (options.testOnly) {
+                    console.error('Error: -t/--test and -T/--pre-verify cannot be used together');
+                    (0, exit_codes_1.exitUnzip)(exit_codes_1.UNZIP_EXIT_CODES.INVALID_OPTIONS);
+                }
+                options.preVerify = true;
+                break;
+            case '-l':
+            case '--list':
+                options.listOnly = true;
+                break;
+            case '--skip-blockchain':
+                options.skipBlockchain = true;
+                break;
+            case '--buffer-size':
+                const bufferSize = parseInt(args[++i], 10);
+                if (isNaN(bufferSize) || bufferSize < 1024) {
+                    console.error('Error: Buffer size must be at least 1024 bytes');
+                    (0, exit_codes_1.exitUnzip)(exit_codes_1.UNZIP_EXIT_CODES.INVALID_OPTIONS);
+                }
+                options.bufferSize = bufferSize;
+                break;
+            case '--no-progress':
+                options.enableProgress = false;
+                break;
+            case '--progress':
+                options.progress = true;
+                options.enableProgress = true;
+                break;
+            case '--debug':
+                options.debug = true;
+                break;
+            case '-sf':
+            case '--show-files':
+                options.showFiles = true;
+                break;
+            case '-p':
+                options.pipeToStdout = true;
+                break;
+            case '-P':
+            case '--password':
+                if (i + 1 < args.length && !args[i + 1].startsWith('-')) {
+                    // Password provided directly
+                    options.password = args[++i];
+                }
+                else {
+                    // No password provided, will prompt later
+                    options.askPassword = true;
+                }
+                break;
+            case '-x':
+            case '--exclude':
+                if (!options.exclude)
+                    options.exclude = [];
+                options.exclude.push(args[++i]);
+                break;
+            case '-i':
+            case '--include':
+                if (!options.include)
+                    options.include = [];
+                options.include.push(args[++i]);
+                break;
+            case '-j':
+            case '--junk-paths':
+                options.junkPaths = true;
+                break;
+            case '-n':
+            case '--never':
+                options.never = true;
+                break;
+            case '-d':
+            case '--exdir':
+                options.exdir = args[++i];
+                if (!options.exdir) {
+                    console.error('Error: --exdir requires a directory path');
+                    (0, exit_codes_1.exitUnzip)(exit_codes_1.UNZIP_EXIT_CODES.INVALID_OPTIONS);
+                }
+                break;
+            case '-X':
+            case '--preserve-perms':
+                options.preservePerms = true;
+                break;
+            case '-y':
+            case '--symlinks':
+                options.symlinks = true;
+                break;
+            case '-H':
+            case '--hard-links':
+                options.hardLinks = true;
+                break;
+            case '--ots-auto-upgrade':
+                options.otsAutoUpgrade = true;
+                break;
+            case '--ots-skip-upgrade':
+                options.otsSkipUpgrade = true;
+                break;
+            case '--in-memory':
+                options.inMemory = true;
+                break;
+            case '--non-interactive':
+                options.nonInteractive = true;
+                break;
+            default:
+                if (arg.startsWith('-')) {
+                    console.error(`Error: Unknown option ${arg}`);
+                    showHelp();
+                    (0, exit_codes_1.exitUnzip)(exit_codes_1.UNZIP_EXIT_CODES.INVALID_OPTIONS);
+                }
+                else if (!archive) {
+                    archive = arg;
+                }
+                else if (destination === '.' && !options.pipeToStdout) {
+                    destination = arg;
+                }
+                else {
+                    // Additional arguments are file patterns for extraction/pipe
+                    filePatterns.push(arg);
+                }
+                break;
+        }
+    }
+    if (!archive) {
+        console.error('Error: Archive name is required');
+        showHelp();
+        (0, exit_codes_1.exitUnzip)(exit_codes_1.UNZIP_EXIT_CODES.INVALID_OPTIONS);
+    }
+    if (!fs.existsSync(archive)) {
+        console.error(`Error: Archive not found: ${archive}`);
+        (0, exit_codes_1.exitUnzip)(exit_codes_1.UNZIP_EXIT_CODES.FILES_NOT_FOUND);
+    }
+    // Verify archive is a file, not a directory
+    const stats = fs.statSync(archive);
+    if (!stats.isFile()) {
+        console.error(`Error: Archive path is not a file: ${archive}`);
+        (0, exit_codes_1.exitUnzip)(exit_codes_1.UNZIP_EXIT_CODES.FILES_NOT_FOUND);
+    }
+    return { archive, destination, options, filePatterns };
+}
+/**
+ * Show help information
+ */
+function showHelp() {
+    console.log(`
+NeoUnZip Version: ${version_1.APP_VERSION} (${version_1.APP_RELEASE_DATE})
+
+Usage: neounzip [options] <archive> [destination]
+
+Options:
+  -h, --help             Show this help message
+  -V, --version          Show version information
+  -v, --verbose          Verbose output
+  -q, --quiet            Suppress output
+  -o, --overwrite        Overwrite existing files when extracting
+  -f                     Freshen existing files, create none
+  -u                     Update files, create if necessary
+  -t, --test             Test compressed data without extracting
+  -T, --pre-verify       Pre-verify integrity and blockchain before extraction (abort on failure)
+  -z                     Display archive comment only
+  -l, --list             List archive contents without extracting
+  -p                     Extract files to pipe (stdout), no messages
+      --skip-blockchain  Skip all blockchain verification (token and OTS)
+      --non-interactive  Skip interactive prompts (exit on timeout)
+      --buffer-size <bytes> Buffer size for streaming (default: 65536)
+      --no-progress      Disable progress reporting
+      --progress         Enable enhanced progress reporting
+      --debug            Enable debug output
+  -sf, --show-files      Show files as they are extracted
+  -P, --password [pwd]   Password for encrypted files. Provide password or will prompt
+  -x, --exclude <pattern> Exclude files matching pattern (can be used multiple times)
+  -i, --include <pattern> Include only files matching pattern (can be used multiple times)
+  -j, --junk-paths       Extract files without directory structure (flatten to destination)
+  -n, --never            Never overwrite existing files when extracting
+  -d, --exdir <dir>      Extract files to specified directory
+  -X, --preserve-perms   Restore file permissions and ownership (UID/GID)
+  -y, --symlinks         Restore symbolic links as links (don't follow them)
+  -H, --hard-links       Restore hard links efficiently (recreate link relationships)
+      --ots-auto-upgrade Automatically upgrade OTS timestamps when available
+      --ots-skip-upgrade Skip OTS timestamp upgrades (no prompt)
+      --in-memory        Force in-memory processing mode (browser compatible)
+
+Arguments:
+  <archive>        ZIP file to extract or test
+  [destination]    Output directory (default: current directory)
+
+Examples:
+  neounzip output/calgary.nzip ./extracted
+  neounzip -t output/calgary.nzip
+  neounzip -l output/calgary.nzip
+`);
+}
+/**
+ * Show extended help information (equivalent to InfoZip's -h2)
+ */
+function showExtendedHelp() {
+    console.log('Extended Help for NeoUnzip');
+    console.log('');
+    console.log('NeoUnzip is a next-generation ZIP extraction utility that builds upon the strengths');
+    console.log('of the ZIP format while incorporating blockchain verification and modern features.');
+    console.log('');
+    console.log('Basic command line:');
+    console.log('  neounzip [options] archive [destination]');
+    console.log('');
+    console.log('Some examples:');
+    console.log('  Extract all files to current directory:          neounzip archive.nzip');
+    console.log('  Extract to specific directory:                   neounzip archive.nzip ./extracted');
+    console.log('  Extract specific files:                          neounzip archive.nzip file1.txt file2.txt');
+    console.log('  Test archive integrity:                          neounzip -t archive.nzip');
+    console.log('');
+    console.log('Basic modes:');
+    console.log('  -t        test archive integrity (no extraction)');
+    console.log('  -T        pre-verify integrity and blockchain before extraction (abort on failure)');
+    console.log('  -l        list archive contents (no extraction)');
+    console.log('  -v        verbose listing with details');
+    console.log('  -j        junk directory names (extract to flat structure)');
+    console.log('');
+    console.log('Basic options:');
+    console.log('  -q        quiet operation');
+    console.log('  -v        verbose operation');
+    console.log('  -o        overwrite files without prompting');
+    console.log('  -n        never overwrite existing files');
+    console.log('  -j        junk directory names (extract to flat structure)');
+    console.log('  -x        exclude files matching patterns');
+    console.log('  -i        include only files matching patterns');
+    console.log('');
+    console.log('Syntax:');
+    console.log('  The full command line syntax is:');
+    console.log('');
+    console.log('    neounzip [options] archive [destination] [file_patterns...]');
+    console.log('');
+    console.log('  Archive is the ZIP file to extract from');
+    console.log('  Destination is the directory to extract to (default: current directory)');
+    console.log('  File patterns specify which files to extract (default: all files)');
+    console.log('');
+    console.log('Options and Values:');
+    console.log('  For short options that take values, use -ovalue or -o value or -o=value');
+    console.log('  For long option values, use either --longoption=value or --longoption value');
+    console.log('  For example:');
+    console.log('    neounzip --password=mypass --exclude "*.tmp" archive.nzip ./extracted');
+    console.log('');
+    console.log('File Patterns:');
+    console.log('  NeoUnzip supports the following patterns:');
+    console.log('    ?       matches any single character');
+    console.log('    *       matches any number of characters, including zero');
+    console.log('    [list]  matches char in list (regex), can do range [a-f], all but [!bf]');
+    console.log('  Examples:');
+    console.log('    neounzip archive.nzip "*.txt"           # Extract only .txt files');
+    console.log('    neounzip archive.nzip "test[0-9].*"     # Extract test0.txt, test1.txt, etc.');
+    console.log('');
+    console.log('Include and Exclude:');
+    console.log('  -i pattern pattern ...   include only files that match a pattern');
+    console.log('  -x pattern pattern ...   exclude files that match a pattern');
+    console.log('  Patterns are paths with optional wildcards and match paths as stored in');
+    console.log('  archive. Exclude and include lists end at next option or end of line.');
+    console.log('');
+    console.log('End Of Line Translation (text files only):');
+    console.log('  -a        auto-convert text files (convert line endings)');
+    console.log('  -aa       convert all files (including binary)');
+    console.log('  -j        junk directory names (extract to flat structure)');
+    console.log('  If first buffer read from file contains binary the translation is skipped');
+    console.log('');
+    console.log('File Handling:');
+    console.log('  -o        overwrite files without prompting');
+    console.log('  -n        never overwrite existing files');
+    console.log('  -f        freshen existing files (extract only if newer)');
+    console.log('  -u        update existing files (extract if newer or missing)');
+    console.log('');
+    console.log('Symbolic Links and Hard Links:');
+    console.log('  -y        restore symbolic links (don\'t follow them)');
+    console.log('  -H        restore hard links efficiently');
+    console.log('');
+    console.log('File Permissions:');
+    console.log('  -X        restore file permissions and ownership (UID/GID)');
+    console.log('  -P        restore file permissions only (not ownership)');
+    console.log('');
+    console.log('Encryption:');
+    console.log('  --password <pass>  use password for encrypted archives');
+    console.log('  --pkzip-decrypt    use legacy PKZip 2.0 decryption');
+    console.log('');
+    console.log('Blockchain Features:');
+    console.log('  --skip-blockchain  disable blockchain verification');
+    console.log('  --non-interactive  skip interactive prompts (exit on timeout)');
+    console.log('  --network <net>    specify blockchain network (base-sepolia, ethereum, etc.)');
+    console.log('  --wallet <addr>    specify wallet address for verification');
+    console.log('  --ots-verify       verify OTS (OpenTimestamps) signatures');
+    console.log('  --ots-skip         skip OTS verification');
+    console.log('');
+    console.log('Testing and Listing:');
+    console.log('  -t        test archive integrity (no extraction)');
+    console.log('  -T        pre-verify integrity and blockchain before extraction (abort on failure)');
+    console.log('  -l        list archive contents (no extraction)');
+    console.log('  -v        verbose listing with details');
+    console.log('  --json    output in JSON format');
+    console.log('  --debug   show debug information');
+    console.log('');
+    console.log('Progress and Verbosity:');
+    console.log('  -v        verbose operation');
+    console.log('  -q        quiet operation');
+    console.log('  --progress show progress bar');
+    console.log('  --debug   show debug information');
+    console.log('');
+    console.log('More option highlights:');
+    console.log('  --buffer-size <size>  set extraction buffer size');
+    console.log('  --show-files          show files to be extracted and exit');
+    console.log('  --dry-run             show what would be extracted without actually extracting');
+    console.log('');
+    console.log('For more information, visit: https://github.com/NeoWareInc/neozip-cli');
+    console.log('For detailed API documentation, see: https://docs.neoware.io/neozip');
+}
+/**
+ * Main execution function
+ */
+async function main() {
+    // Declare variables outside try block for cleanup in catch
+    let zip = null;
+    let options = null;
+    try {
+        // Parse command line arguments
+        const args = process.argv.slice(2);
+        const parsed = parseArgs(args);
+        const { archive, destination, filePatterns } = parsed;
+        options = parsed.options;
+        // Use exdir option if provided, otherwise use destination
+        const extractDestination = options.exdir || destination;
+        // Load the ZIP file
+        zip = new server_1.ZipkitServer();
+        if (options.inMemory) {
+            // Use Buffer-based loading (browser compatible)
+            const data = fs.readFileSync(archive);
+            zip.loadZip(data);
+        }
+        else {
+            // Use file-based loading (default)
+            await zip.loadZipFile(archive);
+        }
+        // Handle password prompting for decryption
+        if (options.askPassword) {
+            log('🔐 Encrypted archive detected - password required', options);
+            options.password = await promptPassword('Enter password: ');
+            if (!options.password) {
+                logError('❌ Password is required for decryption');
+                (0, exit_codes_1.exitUnzip)(exit_codes_1.UNZIP_EXIT_CODES.BAD_PASSWORD);
+            }
+            log('✅ Password set for decryption', options);
+        }
+        // Display streaming information (suppress in pipe and comment modes)
+        if (!options.pipeToStdout && !options.commentOnly) {
+            log(`🚀 NEOUNZIP v${version_1.APP_VERSION} (${version_1.APP_RELEASE_DATE})`, options);
+            log(`📦 Archive: ${archive}`, options);
+            log(`📁 Destination: ${extractDestination}`, options);
+            if (options.debug) {
+                // Set global Logger level to 'debug' for debug output
+                // Note: Individual class logging is controlled by their loggingEnabled static property
+                Logger_1.Logger.setLevel('debug');
+                logDebug('Debug mode enabled', options);
+                logDebug(`Command line arguments: ${process.argv.join(' ')}`, options);
+                logDebug(`Working directory: ${process.cwd()}`, options);
+                logDebug(`Node.js version: ${process.version}`, options);
+                logDebug(`Platform: ${process.platform} ${process.arch}`, options);
+                logDebug(`Archive file: ${archive}`, options);
+                logDebug(`Extract destination: ${extractDestination}`, options);
+                log('', options);
+            }
+        }
+        if (options.testOnly) {
+            const testResult = await testArchive(zip, options);
+            // Always verify tokenization info after testing so users see results at the end
+            // Pass pre-calculated merkle root to avoid double extraction (single pass)
+            await verifyTokenization(zip, archive, options, testResult.extractionResult);
+            process.exit(testResult.failures === 0 ? exit_codes_1.UNZIP_EXIT_CODES.SUCCESS : exit_codes_1.UNZIP_EXIT_CODES.WARNING);
+        }
+        else if (options.listOnly) {
+            await listArchive(zip, archive, options);
+            // Show tokenization info after listing (no pre-calculated result, will extract once)
+            await verifyTokenization(zip, archive, options);
+        }
+        else if (options.commentOnly) {
+            // Comment mode - show only archive comment, no other output
+            await showCommentOnly(zip, archive, options);
+            // Exit without showing tokenization info
+            return;
+        }
+        else if (options.pipeToStdout) {
+            // Pipe mode - extract to stdout, no messages, no tokenization info
+            await pipeArchive(zip, options, filePatterns.length > 0 ? filePatterns : undefined);
+            // Exit without showing tokenization info
+            return;
+        }
+        else {
+            // Pre-verify before extraction if requested
+            if (options.preVerify) {
+                const preVerifyResult = await preVerifyArchive(zip, archive, options);
+                if (!preVerifyResult.success) {
+                    // Determine appropriate exit code based on failure type
+                    if (!preVerifyResult.integrityPassed) {
+                        // Integrity check failed (CRC/SHA-256)
+                        (0, exit_codes_1.exitUnzip)(exit_codes_1.UNZIP_EXIT_CODES.WARNING, `Pre-verification failed: ${preVerifyResult.error || 'Integrity check failed'}`);
+                    }
+                    else if (!preVerifyResult.blockchainPassed) {
+                        // Blockchain verification failed
+                        (0, exit_codes_1.exitUnzip)(exit_codes_1.UNZIP_EXIT_CODES.ZIP_FORMAT_ERROR, `Pre-verification failed: ${preVerifyResult.error || 'Blockchain verification failed'}`);
+                    }
+                    else {
+                        // Unknown failure
+                        (0, exit_codes_1.exitUnzip)(exit_codes_1.UNZIP_EXIT_CODES.ZIP_FORMAT_ERROR, `Pre-verification failed: ${preVerifyResult.error || 'Unknown error'}`);
+                    }
+                }
+                // Pre-verification passed - proceed with extraction
+                console.log('\n✅ Pre-verification passed - proceeding with extraction...\n');
+            }
+            const extractionResult = await extractArchive(zip, extractDestination, options);
+            // Show tokenization info after extraction (pass pre-calculated merkle root to avoid double extraction)
+            // Skip blockchain verification if we already did it during pre-verify
+            if (!options.preVerify) {
+                await verifyTokenization(zip, archive, options, extractionResult);
+            }
+        }
+        log('✓ NeoUnZip completed successfully', options);
+        // Close file handle if file-based ZIP was loaded
+        if (zip && !options.inMemory && isFileBased(zip)) {
+            try {
+                await zip.closeFile();
+            }
+            catch (closeError) {
+                // Ignore cleanup errors - file may already be closed
+                if (options.debug) {
+                    logDebug(`Note: Error closing file handle: ${closeError instanceof Error ? closeError.message : String(closeError)}`, options);
+                }
+            }
+        }
+        // Force process exit to avoid waiting for event loop
+        // This prevents delays from lingering async operations (e.g., blockchain RPC connections)
+        process.exit(0);
+    }
+    catch (error) {
+        // Close file handle if file-based ZIP was loaded (cleanup on error)
+        if (zip && options && !options.inMemory && isFileBased(zip)) {
+            try {
+                await zip.closeFile();
+            }
+            catch (closeError) {
+                // Ignore cleanup errors
+            }
+        }
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logError(`Error: ${errorMessage}`);
+        // Determine appropriate exit code based on error type
+        if (errorMessage.includes('ENOENT') || errorMessage.includes('not found')) {
+            (0, exit_codes_1.exitUnzip)(exit_codes_1.UNZIP_EXIT_CODES.FILES_NOT_FOUND, `Error: ${errorMessage}`);
+        }
+        else if (errorMessage.includes('password') || errorMessage.includes('decrypt')) {
+            (0, exit_codes_1.exitUnzip)(exit_codes_1.UNZIP_EXIT_CODES.BAD_PASSWORD, `Error: ${errorMessage}`);
+        }
+        else if (errorMessage.includes('compression') || errorMessage.includes('unsupported')) {
+            (0, exit_codes_1.exitUnzip)(exit_codes_1.UNZIP_EXIT_CODES.UNSUPPORTED_COMPRESSION, `Error: ${errorMessage}`);
+        }
+        else if (errorMessage.includes('ENOSPC') || errorMessage.includes('disk full')) {
+            (0, exit_codes_1.exitUnzip)(exit_codes_1.UNZIP_EXIT_CODES.DISK_FULL, `Error: ${errorMessage}`);
+        }
+        else if (errorMessage.includes('unexpected end') || errorMessage.includes('truncated')) {
+            (0, exit_codes_1.exitUnzip)(exit_codes_1.UNZIP_EXIT_CODES.UNEXPECTED_END, `Error: ${errorMessage}`);
+        }
+        else if (errorMessage.includes('ZIP format') || errorMessage.includes('corrupt')) {
+            (0, exit_codes_1.exitUnzip)(exit_codes_1.UNZIP_EXIT_CODES.SEVERE_ZIP_ERROR, `Error: ${errorMessage}`);
+        }
+        else if (errorMessage.includes('memory') || errorMessage.includes('allocation')) {
+            (0, exit_codes_1.exitUnzip)(exit_codes_1.UNZIP_EXIT_CODES.MEMORY_ERROR, `Error: ${errorMessage}`);
+        }
+        else {
+            (0, exit_codes_1.exitUnzip)(exit_codes_1.UNZIP_EXIT_CODES.ZIP_FORMAT_ERROR, `Error: ${errorMessage}`);
+        }
+    }
+}
+// Always run main when this module is loaded
+// This allows it to work both when called directly and when imported by index.js
+main().catch(err => {
+    console.error('Fatal error:', err);
+    (0, exit_codes_1.exitUnzip)(exit_codes_1.UNZIP_EXIT_CODES.ZIP_FORMAT_ERROR);
+});
+//# sourceMappingURL=neounzip.js.map