portapack 0.2.1 → 0.3.0

package/dist/cli/{cli-entry.js → cli-entry.cjs}

@@ -1,6 +1,11 @@
 #!/usr/bin/env node
+"use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
@@ -8,6 +13,23 @@ var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/types.ts
 var LogLevel;
@@ -26,15 +48,14 @@ var init_types = __esm({
 });
 
 // src/cli/options.ts
-import { Command, Option } from "commander";
 function parseRecursiveValue(val) {
   if (val === void 0) return true;
   const parsed = parseInt(val, 10);
   return isNaN(parsed) || parsed < 0 ? true : parsed;
 }
 function parseOptions(argv = process.argv) {
-  const program = new Command();
-  program.name("portapack").version("0.0.0").description("\u{1F4E6} Bundle HTML and its dependencies into a portable file").argument("[input]", "Input HTML file or URL").option("-o, --output <file>", "Output file path").option("-m, --minify", "Enable all minification (HTML, CSS, JS)").option("--no-minify", "Disable all minification").option("--no-minify-html", "Disable HTML minification").option("--no-minify-css", "Disable CSS minification").option("--no-minify-js", "Disable JavaScript minification").option("-e, --embed-assets", "Embed assets as data URIs").option("--no-embed-assets", "Keep asset links relative/absolute").option("-r, --recursive [depth]", "Recursively crawl site (optional depth)", parseRecursiveValue).option("--max-depth <n>", "Set max depth for recursive crawl (alias for -r <n>)", parseInt).option("-b, --base-url <url>", "Base URL for resolving relative links").option("-d, --dry-run", "Run without writing output file").option("-v, --verbose", "Enable verbose (debug) logging").addOption(new Option("--log-level <level>", "Set logging level").choices(logLevels));
+  const program = new import_commander.Command();
+  program.name("portapack").version("0.0.0").description("\u{1F4E6} Bundle HTML and its dependencies into a portable file").argument("[input]", "Input HTML file or URL").option("-o, --output <file>", "Output file path").option("-m, --minify", "Enable all minification (HTML, CSS, JS)").option("--no-minify", "Disable all minification").option("--no-minify-html", "Disable HTML minification").option("--no-minify-css", "Disable CSS minification").option("--no-minify-js", "Disable JavaScript minification").option("-e, --embed-assets", "Embed assets as data URIs").option("--no-embed-assets", "Keep asset links relative/absolute").option("-r, --recursive [depth]", "Recursively crawl site (optional depth)", parseRecursiveValue).option("--max-depth <n>", "Set max depth for recursive crawl (alias for -r <n>)", parseInt).option("-b, --base-url <url>", "Base URL for resolving relative links").option("-d, --dry-run", "Run without writing output file").option("-v, --verbose", "Enable verbose (debug) logging").addOption(new import_commander.Option("--log-level <level>", "Set logging level").choices(logLevels));
   program.parse(argv);
   const opts = program.opts();
   const inputArg = program.args.length > 0 ? program.args[0] : void 0;
@@ -110,17 +131,130 @@ function parseOptions(argv = process.argv) {
     // minifyHtml, minifyCss, minifyJs (commander's raw boolean flags)
   };
 }
-var logLevels;
+var import_commander, logLevels;
 var init_options = __esm({
   "src/cli/options.ts"() {
     "use strict";
+    import_commander = require("commander");
     init_types();
     logLevels = ["debug", "info", "warn", "error", "silent", "none"];
   }
 });
 
+// src/utils/logger.ts
+var Logger;
+var init_logger = __esm({
+  "src/utils/logger.ts"() {
+    "use strict";
+    init_types();
+    Logger = class _Logger {
+      /** The current minimum log level required for a message to be output. */
+      level;
+      /**
+       * Creates a new Logger instance.
+       * Defaults to LogLevel.INFO if no level is provided.
+       *
+       * @param {LogLevel} [level=LogLevel.INFO] - The initial log level for this logger instance.
+       * Must be one of the values from the LogLevel enum.
+       */
+      constructor(level = 3 /* INFO */) {
+        this.level = level !== void 0 && LogLevel[level] !== void 0 ? level : 3 /* INFO */;
+      }
+      /**
+       * Updates the logger's current level. Messages below this level will be suppressed.
+       *
+       * @param {LogLevel} level - The new log level to set. Must be a LogLevel enum member.
+       */
+      setLevel(level) {
+        this.level = level;
+      }
+      /**
+       * Logs a debug message if the current log level is DEBUG or higher.
+       *
+       * @param {string} message - The debug message string.
+       */
+      debug(message) {
+        if (this.level >= 4 /* DEBUG */) {
+          console.debug(`[DEBUG] ${message}`);
+        }
+      }
+      /**
+       * Logs an informational message if the current log level is INFO or higher.
+       *
+       * @param {string} message - The informational message string.
+       */
+      info(message) {
+        if (this.level >= 3 /* INFO */) {
+          console.info(`[INFO] ${message}`);
+        }
+      }
+      /**
+       * Logs a warning message if the current log level is WARN or higher.
+       *
+       * @param {string} message - The warning message string.
+       */
+      warn(message) {
+        if (this.level >= 2 /* WARN */) {
+          console.warn(`[WARN] ${message}`);
+        }
+      }
+      /**
+       * Logs an error message if the current log level is ERROR or higher.
+       *
+       * @param {string} message - The error message string.
+       */
+      error(message) {
+        if (this.level >= 1 /* ERROR */) {
+          console.error(`[ERROR] ${message}`);
+        }
+      }
+      /**
+       * Static factory method to create a Logger instance based on a simple boolean `verbose` flag.
+       *
+       * @static
+       * @param {{ verbose?: boolean }} [options={}] - An object potentially containing a `verbose` flag.
+       * @returns {Logger} A new Logger instance set to LogLevel.DEBUG if options.verbose is true,
+       * otherwise set to LogLevel.INFO.
+       */
+      static fromVerboseFlag(options = {}) {
+        return new _Logger(options.verbose ? 4 /* DEBUG */ : 3 /* INFO */);
+      }
+      /**
+       * Static factory method to create a Logger instance based on a LogLevel string name.
+       * Useful for creating a logger from config files or environments variables.
+       *
+       * @static
+       * @param {string | undefined} levelName - The name of the log level (e.g., 'debug', 'info', 'warn', 'error', 'silent'/'none'). Case-insensitive.
+       * @param {LogLevel} [defaultLevel=LogLevel.INFO] - The level to use if levelName is invalid or undefined.
+       * @returns {Logger} A new Logger instance set to the corresponding LogLevel.
+       */
+      static fromLevelName(levelName, defaultLevel = 3 /* INFO */) {
+        if (!levelName) {
+          return new _Logger(defaultLevel);
+        }
+        switch (levelName.toLowerCase()) {
+          // Return enum members
+          case "debug":
+            return new _Logger(4 /* DEBUG */);
+          case "info":
+            return new _Logger(3 /* INFO */);
+          case "warn":
+            return new _Logger(2 /* WARN */);
+          case "error":
+            return new _Logger(1 /* ERROR */);
+          case "silent":
+          case "none":
+            return new _Logger(0 /* NONE */);
+          default:
+            console.warn(`[Logger] Invalid log level name "${levelName}". Defaulting to ${LogLevel[defaultLevel]}.`);
+            return new _Logger(defaultLevel);
+        }
+      }
+    };
+  }
+});
+
 // src/utils/mime.ts
-import path from "path";
 function guessMimeType(urlOrPath) {
   if (!urlOrPath) {
     return DEFAULT_MIME_TYPE;
@@ -128,16 +262,17 @@ function guessMimeType(urlOrPath) {
   let ext = "";
   try {
     const parsedUrl = new URL(urlOrPath);
-    ext = path.extname(parsedUrl.pathname).toLowerCase();
+    ext = import_path.default.extname(parsedUrl.pathname).toLowerCase();
   } catch {
-    ext = path.extname(urlOrPath).toLowerCase();
+    ext = import_path.default.extname(urlOrPath).toLowerCase();
   }
   return MIME_MAP[ext] || DEFAULT_MIME_TYPE;
 }
-var MIME_MAP, DEFAULT_MIME_TYPE;
+var import_path, MIME_MAP, DEFAULT_MIME_TYPE;
 var init_mime = __esm({
   "src/utils/mime.ts"() {
     "use strict";
+    import_path = __toESM(require("path"), 1);
     MIME_MAP = {
       // CSS
       ".css": { mime: "text/css", assetType: "css" },
@@ -181,84 +316,7 @@ var init_mime = __esm({
   }
 });
 
-// src/core/parser.ts
-import { readFile } from "fs/promises";
-import * as cheerio from "cheerio";
-async function parseHTML(entryFilePath, logger) {
-  logger?.debug(`Parsing HTML file: ${entryFilePath}`);
-  let htmlContent;
-  try {
-    htmlContent = await readFile(entryFilePath, "utf-8");
-    logger?.debug(`Successfully read HTML file (${Buffer.byteLength(htmlContent)} bytes).`);
-  } catch (err) {
-    logger?.error(`Failed to read HTML file "${entryFilePath}": ${err.message}`);
-    throw new Error(`Could not read input HTML file: ${entryFilePath}`, { cause: err });
-  }
-  const $ = cheerio.load(htmlContent);
-  const assets = [];
-  const addedUrls = /* @__PURE__ */ new Set();
-  const addAsset = (url, forcedType) => {
-    if (!url || url.trim() === "" || url.startsWith("data:")) {
-      return;
-    }
-    if (!addedUrls.has(url)) {
-      addedUrls.add(url);
-      const mimeInfo = guessMimeType(url);
-      const type = forcedType ?? mimeInfo.assetType;
-      assets.push({ type, url });
-      logger?.debug(`Discovered asset: Type='${type}', URL='${url}'`);
-    } else {
-      logger?.debug(`Skipping duplicate asset URL: ${url}`);
-    }
-  };
-  logger?.debug("Extracting assets from HTML tags...");
-  $('link[rel="stylesheet"][href]').each((_, el) => {
-    addAsset($(el).attr("href"), "css");
-  });
-  $("script[src]").each((_, el) => {
-    addAsset($(el).attr("src"), "js");
-  });
-  $("img[src]").each((_, el) => addAsset($(el).attr("src"), "image"));
-  $('input[type="image"][src]').each((_, el) => addAsset($(el).attr("src"), "image"));
-  $("img[srcset], picture source[srcset]").each((_, el) => {
-    const srcset = $(el).attr("srcset");
-    srcset?.split(",").forEach((entry) => {
-      const [url] = entry.trim().split(/\s+/);
-      addAsset(url, "image");
-    });
-  });
-  $("video[src]").each((_, el) => addAsset($(el).attr("src"), "video"));
-  $("video[poster]").each((_, el) => addAsset($(el).attr("poster"), "image"));
-  $("audio[src]").each((_, el) => addAsset($(el).attr("src"), "audio"));
-  $("video > source[src]").each((_, el) => addAsset($(el).attr("src"), "video"));
-  $("audio > source[src]").each((_, el) => addAsset($(el).attr("src"), "audio"));
-  $("link[href]").filter((_, el) => {
-    const rel = $(el).attr("rel")?.toLowerCase() ?? "";
-    return ["icon", "shortcut icon", "apple-touch-icon", "manifest"].includes(rel);
-  }).each((_, el) => {
-    const rel = $(el).attr("rel")?.toLowerCase() ?? "";
-    const isIcon = ["icon", "shortcut icon", "apple-touch-icon"].includes(rel);
-    addAsset($(el).attr("href"), isIcon ? "image" : void 0);
-  });
-  $('link[rel="preload"][as="font"][href]').each((_, el) => {
-    addAsset($(el).attr("href"), "font");
-  });
-  logger?.info(`HTML parsing complete. Discovered ${assets.length} unique asset links.`);
-  return { htmlContent, assets };
-}
-var init_parser = __esm({
-  "src/core/parser.ts"() {
-    "use strict";
-    init_mime();
-  }
-});
-
 // src/core/extractor.ts
-import { readFile as readFile2 } from "fs/promises";
-import * as fs from "fs";
-import path2 from "path";
-import { fileURLToPath, URL as URL2 } from "url";
-import * as axios from "axios";
 function isUtf8DecodingLossy(originalBuffer, decodedString) {
   try {
     const reEncodedBuffer = Buffer.from(decodedString, "utf-8");
@@ -268,6 +326,7 @@ function isUtf8DecodingLossy(originalBuffer, decodedString) {
   }
 }
 function determineBaseUrl(inputPathOrUrl, logger) {
+  console.log(`[DEBUG determineBaseUrl] Input: "${inputPathOrUrl}"`);
   logger?.debug(`Determining base URL for input: ${inputPathOrUrl}`);
   if (!inputPathOrUrl) {
     logger?.warn("Cannot determine base URL: inputPathOrUrl is empty or invalid.");
@@ -275,55 +334,52 @@ function determineBaseUrl(inputPathOrUrl, logger) {
   }
   try {
     if (/^https?:\/\//i.test(inputPathOrUrl)) {
-      const url = new URL2(inputPathOrUrl);
+      const url = new import_url.URL(inputPathOrUrl);
       url.pathname = url.pathname.substring(0, url.pathname.lastIndexOf("/") + 1);
       url.search = "";
       url.hash = "";
       const baseUrl = url.href;
       logger?.debug(`Determined remote base URL: ${baseUrl}`);
+      console.log(`[DEBUG determineBaseUrl] Determined Remote URL: "${baseUrl}"`);
       return baseUrl;
     } else if (inputPathOrUrl.includes("://") && !inputPathOrUrl.startsWith("file:")) {
       logger?.warn(`Input "${inputPathOrUrl}" looks like a URL but uses an unsupported protocol. Cannot determine base URL.`);
+      console.log(`[DEBUG determineBaseUrl] Unsupported protocol.`);
       return void 0;
     } else {
-      let absolutePath;
+      let resourcePath;
+      let isInputLikelyDirectory = false;
       if (inputPathOrUrl.startsWith("file:")) {
-        try {
-          absolutePath = fileURLToPath(inputPathOrUrl);
-        } catch (e) {
-          logger?.error(`\u{1F480} Failed to convert file URL "${inputPathOrUrl}" to path: ${e.message}`);
-          return void 0;
-        }
+        resourcePath = (0, import_url.fileURLToPath)(inputPathOrUrl);
+        isInputLikelyDirectory = inputPathOrUrl.endsWith("/");
       } else {
-        absolutePath = path2.resolve(inputPathOrUrl);
-      }
-      let isDirectory = false;
-      try {
-        isDirectory = fs.statSync(absolutePath).isDirectory();
-      } catch (statError) {
-        if (statError instanceof Error && statError.code === "ENOENT") {
-          logger?.debug(`Path "${absolutePath}" not found. Assuming input represents a file, using its parent directory as base.`);
-        } else {
-          logger?.warn(`Could not stat local path "${absolutePath}" during base URL determination: ${statError instanceof Error ? statError.message : String(statError)}. Assuming input represents a file.`);
+        resourcePath = import_path2.default.resolve(inputPathOrUrl);
+        try {
+          isInputLikelyDirectory = fs.statSync(resourcePath).isDirectory();
+        } catch {
+          isInputLikelyDirectory = false;
         }
-        isDirectory = false;
       }
-      const dirPath = isDirectory ? absolutePath : path2.dirname(absolutePath);
-      let normalizedPathForURL = dirPath.replace(/\\/g, "/");
+      console.log(`[DEBUG determineBaseUrl] resourcePath: "${resourcePath}", isInputLikelyDirectory: ${isInputLikelyDirectory}`);
+      const baseDirPath = isInputLikelyDirectory ? resourcePath : import_path2.default.dirname(resourcePath);
+      console.log(`[DEBUG determineBaseUrl] Calculated baseDirPath: "${baseDirPath}"`);
+      let normalizedPathForURL = baseDirPath.replace(/\\/g, "/");
       if (/^[A-Z]:\//i.test(normalizedPathForURL) && !normalizedPathForURL.startsWith("/")) {
         normalizedPathForURL = "/" + normalizedPathForURL;
       }
-      const fileUrl = new URL2("file://" + normalizedPathForURL);
-      let fileUrlString = fileUrl.href;
-      if (!fileUrlString.endsWith("/")) {
-        fileUrlString += "/";
+      if (!normalizedPathForURL.endsWith("/")) {
+        normalizedPathForURL += "/";
       }
-      logger?.debug(`Determined local base URL: ${fileUrlString} (from: ${inputPathOrUrl}, resolved dir: ${dirPath}, isDir: ${isDirectory})`);
+      const fileUrl = new import_url.URL("file://" + normalizedPathForURL);
+      const fileUrlString = fileUrl.href;
+      logger?.debug(`Determined base URL: ${fileUrlString} (from: ${inputPathOrUrl}, resolved base dir: ${baseDirPath})`);
+      console.log(`[DEBUG determineBaseUrl] Determined File URL: "${fileUrlString}"`);
       return fileUrlString;
     }
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    logger?.error(`\u{1F480} Failed to determine base URL for "${inputPathOrUrl}": ${message}${error instanceof Error ? ` - Stack: ${error.stack}` : ""}`);
+    console.error(`[DEBUG determineBaseUrl] Error determining base URL: ${message}`);
+    logger?.error(`\u{1F480} Failed to determine base URL for "${inputPathOrUrl}": ${message}${error instanceof Error && error.stack ? ` - Stack: ${error.stack}` : ""}`);
     return void 0;
   }
 }
@@ -335,7 +391,7 @@ function resolveAssetUrl(assetUrl, baseContextUrl, logger) {
   let resolvableUrl = trimmedUrl;
   if (resolvableUrl.startsWith("//") && baseContextUrl) {
     try {
-      const base = new URL2(baseContextUrl);
+      const base = new import_url.URL(baseContextUrl);
       resolvableUrl = base.protocol + resolvableUrl;
     } catch (e) {
       logger?.warn(`Could not extract protocol from base "${baseContextUrl}" for protocol-relative URL "${trimmedUrl}". Skipping.`);
@@ -343,7 +399,11 @@ function resolveAssetUrl(assetUrl, baseContextUrl, logger) {
     }
   }
   try {
-    const resolved = new URL2(resolvableUrl, baseContextUrl);
+    const resolved = new import_url.URL(resolvableUrl, baseContextUrl);
+    if (!["http:", "https:", "file:"].includes(resolved.protocol)) {
+      logger?.debug(`Skipping asset with unsupported protocol: ${resolved.href}`);
+      return null;
+    }
     return resolved;
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
@@ -356,83 +416,78 @@ function resolveAssetUrl(assetUrl, baseContextUrl, logger) {
   }
 }
 function resolveCssRelativeUrl(relativeUrl, cssBaseContextUrl, logger) {
-  if (!relativeUrl || relativeUrl.startsWith("data:")) {
+  console.log(`[DEBUG resolveCssRelativeUrl] Input: relative="${relativeUrl}", base="${cssBaseContextUrl}"`);
+  if (!relativeUrl || relativeUrl.startsWith("data:") || relativeUrl.startsWith("#")) {
     return null;
   }
   try {
-    if (cssBaseContextUrl.startsWith("file:")) {
-      const basePath = fileURLToPath(cssBaseContextUrl);
-      let cssDir;
-      try {
-        const stat = fs.statSync(basePath);
-        if (stat.isDirectory()) {
-          cssDir = basePath;
-        } else {
-          cssDir = path2.dirname(basePath);
-        }
-      } catch {
-        cssDir = path2.dirname(basePath);
-      }
-      let resolvedPath = path2.resolve(cssDir, relativeUrl);
-      resolvedPath = resolvedPath.replace(/\\/g, "/");
-      if (/^[A-Z]:/i.test(resolvedPath) && !resolvedPath.startsWith("/")) {
-        resolvedPath = "/" + resolvedPath;
-      }
-      return `file://${resolvedPath}`;
-    } else {
-      return new URL2(relativeUrl, cssBaseContextUrl).href;
-    }
+    const resolvedUrl = new import_url.URL(relativeUrl, cssBaseContextUrl);
+    console.log(`[DEBUG resolveCssRelativeUrl] Resolved URL object href: "${resolvedUrl.href}"`);
+    return resolvedUrl.href;
   } catch (error) {
     logger?.warn(
-      `Failed to resolve CSS URL: "${relativeUrl}" against "${cssBaseContextUrl}": ${String(error)}`
+      `Failed to resolve CSS URL: "${relativeUrl}" relative to "${cssBaseContextUrl}": ${String(error)}`
     );
+    console.error(`[DEBUG resolveCssRelativeUrl] Error resolving: ${String(error)}`);
     return null;
   }
 }
 async function fetchAsset(resolvedUrl, logger, timeout = 1e4) {
+  console.log(`[DEBUG fetchAsset] Attempting fetch for URL: ${resolvedUrl.href}`);
   logger?.debug(`Attempting to fetch asset: ${resolvedUrl.href}`);
   const protocol = resolvedUrl.protocol;
   try {
     if (protocol === "http:" || protocol === "https:") {
-      const response = await axios.default.get(resolvedUrl.href, {
+      const response = await axiosNs.default.get(resolvedUrl.href, {
         responseType: "arraybuffer",
         timeout
       });
-      logger?.debug(`Workspaceed remote asset ${resolvedUrl.href} (Status: ${response.status}, Type: ${response.headers["content-type"] || "N/A"}, Size: ${response.data.byteLength} bytes)`);
+      logger?.debug(`Workspaceed remote asset ${resolvedUrl.href} (Status: ${response.status}, Type: ${response.headers["content-type"] || "N/A"}, Size: ${response.data?.byteLength ?? 0} bytes)`);
+      console.log(`[DEBUG fetchAsset] HTTP fetch SUCCESS for: ${resolvedUrl.href}, Status: ${response.status}`);
       return Buffer.from(response.data);
     } else if (protocol === "file:") {
       let filePath;
       try {
-        filePath = fileURLToPath(resolvedUrl);
+        filePath = (0, import_url.fileURLToPath)(resolvedUrl);
       } catch (e) {
+        console.error(`[DEBUG fetchAsset] fileURLToPath FAILED for: ${resolvedUrl.href}`, e);
         logger?.error(`Could not convert file URL to path: ${resolvedUrl.href}. Error: ${e.message}`);
         return null;
       }
-      const data = await readFile2(filePath);
+      const normalizedForLog = import_path2.default.normalize(filePath);
+      console.log(`[DEBUG fetchAsset] Attempting readFile with path: "${normalizedForLog}" (Original from URL: "${filePath}")`);
+      const data = await (0, import_promises.readFile)(filePath);
+      console.log(`[DEBUG fetchAsset] readFile call SUCCEEDED for path: "${normalizedForLog}". Data length: ${data?.byteLength}`);
       logger?.debug(`Read local file ${filePath} (${data.byteLength} bytes)`);
       return data;
     } else {
+      console.log(`[DEBUG fetchAsset] Unsupported protocol: ${protocol}`);
       logger?.warn(`Unsupported protocol "${protocol}" in URL: ${resolvedUrl.href}`);
       return null;
     }
   } catch (error) {
-    if ((protocol === "http:" || protocol === "https:") && axios.default.isAxiosError(error)) {
+    const failedId = protocol === "file:" ? import_path2.default.normalize((0, import_url.fileURLToPath)(resolvedUrl)) : resolvedUrl.href;
+    console.error(`[DEBUG fetchAsset] fetch/read FAILED for: "${failedId}". Error:`, error);
+    if ((protocol === "http:" || protocol === "https:") && axiosNs.isAxiosError(error)) {
       const status = error.response?.status ?? "N/A";
       const statusText = error.response?.statusText ?? "Error";
       const code = error.code ?? "N/A";
       const message = error.message;
       const logMessage = `\u26A0\uFE0F Failed to fetch remote asset ${resolvedUrl.href}: Status ${status} - ${statusText}. Code: ${code}, Message: ${message}`;
       logger?.warn(logMessage);
-    } else if (protocol === "file:") {
+    }
+    if (error instanceof Error && error.code === "ENOENT") {
       let failedPath = resolvedUrl.href;
       try {
-        failedPath = fileURLToPath(resolvedUrl);
+        failedPath = (0, import_url.fileURLToPath)(resolvedUrl);
       } catch {
       }
+      failedPath = import_path2.default.normalize(failedPath);
       if (error instanceof Error && error.code === "ENOENT") {
         logger?.warn(`\u26A0\uFE0F File not found (ENOENT) for asset: ${failedPath}.`);
       } else if (error instanceof Error && error.code === "EACCES") {
         logger?.warn(`\u26A0\uFE0F Permission denied (EACCES) reading asset: ${failedPath}.`);
+        logger?.warn(`\u26A0\uFE0F Failed to read local asset ${failedPath}: ${error.message}`);
       } else if (error instanceof Error) {
         logger?.warn(`\u26A0\uFE0F Failed to read local asset ${failedPath}: ${error.message}`);
       } else {
@@ -460,14 +515,13 @@ function extractUrlsFromCSS(cssContent, cssBaseContextUrl, logger) {
       newlyDiscovered.push({
         type: assetType,
         url: resolvedUrl,
-        // The resolved URL string
+        // The resolved absolute URL string
         content: void 0
+        // Content will be fetched later if needed
       });
       logger?.debug(`Discovered nested ${assetType} asset (${ruleType}) in CSS ${cssBaseContextUrl}: ${resolvedUrl}`);
     }
   };
-  urlRegex.lastIndex = 0;
-  importRegex.lastIndex = 0;
   let match;
   while ((match = urlRegex.exec(cssContent)) !== null) {
     processFoundUrl(match[2], "url()");
@@ -483,23 +537,28 @@ async function extractAssets(parsed, embedAssets = true, inputPathOrUrl, logger)
   const initialAssets = parsed.assets || [];
   const finalAssetsMap = /* @__PURE__ */ new Map();
   let assetsToProcess = [];
+  const processedOrQueuedUrls = /* @__PURE__ */ new Set();
   const htmlBaseContextUrl = determineBaseUrl(inputPathOrUrl || "", logger);
   if (!htmlBaseContextUrl && initialAssets.some((a) => !/^[a-z]+:/i.test(a.url) && !a.url.startsWith("data:") && !a.url.startsWith("#") && !a.url.startsWith("/"))) {
     logger?.warn("\u{1F6A8} No valid base path/URL determined for the HTML source! Resolution of relative asset paths from HTML may fail.");
   } else if (htmlBaseContextUrl) {
     logger?.debug(`Using HTML base context URL: ${htmlBaseContextUrl}`);
   }
-  const processedOrQueuedUrls = /* @__PURE__ */ new Set();
   logger?.debug(`Queueing ${initialAssets.length} initial assets parsed from HTML...`);
   for (const asset of initialAssets) {
     const resolvedUrlObj = resolveAssetUrl(asset.url, htmlBaseContextUrl, logger);
-    const urlToQueue = resolvedUrlObj ? resolvedUrlObj.href : asset.url;
+    if (!resolvedUrlObj) {
+      logger?.debug(` -> Skipping initial asset with unresolvable/ignorable URL: ${asset.url}`);
+      continue;
+    }
+    const urlToQueue = resolvedUrlObj.href;
     if (!urlToQueue.startsWith("data:") && !processedOrQueuedUrls.has(urlToQueue)) {
       processedOrQueuedUrls.add(urlToQueue);
       const { assetType: guessedType } = guessMimeType(urlToQueue);
       const initialType = asset.type ?? guessedType;
       assetsToProcess.push({
         url: urlToQueue,
+        // Use the resolved URL
         type: initialType,
         content: void 0
       });
@@ -507,7 +566,7 @@ async function extractAssets(parsed, embedAssets = true, inputPathOrUrl, logger)
     } else if (urlToQueue.startsWith("data:")) {
       logger?.debug(` -> Skipping data URI: ${urlToQueue.substring(0, 50)}...`);
     } else {
-      logger?.debug(` -> Skipping already queued initial asset: ${urlToQueue}`);
+      logger?.debug(` -> Skipping already processed/queued initial asset: ${urlToQueue}`);
     }
   }
   let iterationCount = 0;
@@ -540,7 +599,7 @@ async function extractAssets(parsed, embedAssets = true, inputPathOrUrl, logger)
       let assetUrlObj = null;
       if (needsFetching) {
         try {
-          assetUrlObj = new URL2(asset.url);
+          assetUrlObj = new import_url.URL(asset.url);
         } catch (urlError) {
           logger?.warn(`Cannot create URL object for "${asset.url}", skipping fetch. Error: ${urlError instanceof Error ? urlError.message : String(urlError)}`);
           finalAssetsMap.set(asset.url, { ...asset, content: void 0 });
@@ -578,7 +637,7 @@ async function extractAssets(parsed, embedAssets = true, inputPathOrUrl, logger)
               cssContentForParsing = textContent;
             }
           } else {
-            logger?.warn(`Could not decode ${asset.type} ${asset.url} as valid UTF-8 text.${embedAssets ? " Falling back to base64 data URI." : ""}`);
+            logger?.warn(`Could not decode ${asset.type} asset ${asset.url} as valid UTF-8 text.${embedAssets ? " Falling back to base64 data URI." : ""}`);
             cssContentForParsing = void 0;
             if (embedAssets) {
               finalContent = `data:${effectiveMime};base64,${assetContentBuffer.toString("base64")}`;
@@ -625,6 +684,7 @@ async function extractAssets(parsed, embedAssets = true, inputPathOrUrl, logger)
           const newlyDiscoveredAssets = extractUrlsFromCSS(
             cssContentForParsing,
             cssBaseContextUrl,
+            // Use CSS file's base URL
             logger
           );
           if (newlyDiscoveredAssets.length > 0) {
@@ -652,10 +712,15 @@ async function extractAssets(parsed, embedAssets = true, inputPathOrUrl, logger)
     assets: Array.from(finalAssetsMap.values())
   };
 }
-var TEXT_ASSET_TYPES, BINARY_ASSET_TYPES, MAX_ASSET_EXTRACTION_ITERATIONS;
+var import_promises, fs, import_path2, import_url, axiosNs, TEXT_ASSET_TYPES, BINARY_ASSET_TYPES, MAX_ASSET_EXTRACTION_ITERATIONS;
 var init_extractor = __esm({
   "src/core/extractor.ts"() {
     "use strict";
+    import_promises = require("fs/promises");
+    fs = __toESM(require("fs"), 1);
+    import_path2 = __toESM(require("path"), 1);
+    import_url = require("url");
+    axiosNs = __toESM(require("axios"), 1);
     init_mime();
     TEXT_ASSET_TYPES = /* @__PURE__ */ new Set(["css", "js"]);
     BINARY_ASSET_TYPES = /* @__PURE__ */ new Set(["image", "font", "video", "audio"]);
@@ -664,9 +729,6 @@ var init_extractor = __esm({
 });
 
 // src/core/minifier.ts
-import { minify as htmlMinify } from "html-minifier-terser";
-import CleanCSS from "clean-css";
-import { minify as jsMinify } from "terser";
 async function minifyAssets(parsed, options = {}, logger) {
   const { htmlContent, assets } = parsed;
   const currentHtmlContent = htmlContent ?? "";
@@ -692,7 +754,7 @@ async function minifyAssets(parsed, options = {}, logger) {
       try {
         if (minifyFlags.minifyCss && processedAsset.type === "css") {
           logger?.debug(`Minifying CSS: ${assetIdentifier}`);
-          const cssMinifier = new CleanCSS(CSS_MINIFY_OPTIONS);
+          const cssMinifier = new import_clean_css.default(CSS_MINIFY_OPTIONS);
           const result = cssMinifier.minify(processedAsset.content);
           if (result.errors && result.errors.length > 0) {
             logger?.warn(`\u26A0\uFE0F CleanCSS failed for ${assetIdentifier}: ${result.errors.join(", ")}`);
@@ -710,7 +772,7 @@ async function minifyAssets(parsed, options = {}, logger) {
         }
         if (minifyFlags.minifyJs && processedAsset.type === "js") {
           logger?.debug(`Minifying JS: ${assetIdentifier}`);
-          const result = await jsMinify(processedAsset.content, JS_MINIFY_OPTIONS);
+          const result = await (0, import_terser.minify)(processedAsset.content, JS_MINIFY_OPTIONS);
           if (result.code) {
             newContent = result.code;
             logger?.debug(`JS minified successfully: ${assetIdentifier}`);
@@ -735,7 +797,7 @@ async function minifyAssets(parsed, options = {}, logger) {
   if (minifyFlags.minifyHtml && finalHtml.length > 0) {
     logger?.debug("Minifying HTML content...");
     try {
-      finalHtml = await htmlMinify(finalHtml, {
+      finalHtml = await (0, import_html_minifier_terser.minify)(finalHtml, {
         ...HTML_MINIFY_OPTIONS,
         minifyCSS: minifyFlags.minifyCss,
         minifyJS: minifyFlags.minifyJs
@@ -754,10 +816,13 @@ async function minifyAssets(parsed, options = {}, logger) {
     // The array of processed asset copies
   };
 }
-var HTML_MINIFY_OPTIONS, CSS_MINIFY_OPTIONS, JS_MINIFY_OPTIONS;
+var import_html_minifier_terser, import_clean_css, import_terser, HTML_MINIFY_OPTIONS, CSS_MINIFY_OPTIONS, JS_MINIFY_OPTIONS;
 var init_minifier = __esm({
   "src/core/minifier.ts"() {
     "use strict";
+    import_html_minifier_terser = require("html-minifier-terser");
+    import_clean_css = __toESM(require("clean-css"), 1);
+    import_terser = require("terser");
     HTML_MINIFY_OPTIONS = {
       collapseWhitespace: true,
       removeComments: true,
@@ -815,7 +880,6 @@ var init_minifier = __esm({
 });
 
 // src/core/packer.ts
-import * as cheerio2 from "cheerio";
 function escapeScriptContent(code) {
   return code.replace(/<\/(script)/gi, "<\\/$1");
 }
@@ -928,7 +992,7 @@ function packHTML(parsed, logger) {
     return '<!DOCTYPE html><html><head><base href="./"></head><body></body></html>';
   }
   logger?.debug("Loading HTML content into Cheerio for packing...");
-  const $ = cheerio2.load(htmlContent);
+  const $ = cheerio.load(htmlContent);
   logger?.debug("Ensuring <base> tag exists...");
   ensureBaseTag($, logger);
   logger?.debug("Starting asset inlining...");
@@ -938,122 +1002,11 @@ function packHTML(parsed, logger) {
   logger?.debug(`Packing complete. Final size: ${Buffer.byteLength(finalHtml)} bytes.`);
   return finalHtml;
 }
+var cheerio;
 var init_packer = __esm({
   "src/core/packer.ts"() {
     "use strict";
-  }
-});
-
-// src/utils/logger.ts
-var Logger;
-var init_logger = __esm({
-  "src/utils/logger.ts"() {
-    "use strict";
-    init_types();
-    Logger = class _Logger {
-      /** The current minimum log level required for a message to be output. */
-      level;
-      /**
-       * Creates a new Logger instance.
-       * Defaults to LogLevel.INFO if no level is provided.
-       *
-       * @param {LogLevel} [level=LogLevel.INFO] - The initial log level for this logger instance.
-       * Must be one of the values from the LogLevel enum.
-       */
-      constructor(level = 3 /* INFO */) {
-        this.level = level !== void 0 && LogLevel[level] !== void 0 ? level : 3 /* INFO */;
-      }
-      /**
-       * Updates the logger's current level. Messages below this level will be suppressed.
-       *
-       * @param {LogLevel} level - The new log level to set. Must be a LogLevel enum member.
-       */
-      setLevel(level) {
-        this.level = level;
-      }
-      /**
-       * Logs a debug message if the current log level is DEBUG or higher.
-       *
-       * @param {string} message - The debug message string.
-       */
-      debug(message) {
-        if (this.level >= 4 /* DEBUG */) {
-          console.debug(`[DEBUG] ${message}`);
-        }
-      }
-      /**
-       * Logs an informational message if the current log level is INFO or higher.
-       *
-       * @param {string} message - The informational message string.
-       */
-      info(message) {
-        if (this.level >= 3 /* INFO */) {
-          console.info(`[INFO] ${message}`);
-        }
-      }
-      /**
-       * Logs a warning message if the current log level is WARN or higher.
-       *
-       * @param {string} message - The warning message string.
-       */
-      warn(message) {
-        if (this.level >= 2 /* WARN */) {
-          console.warn(`[WARN] ${message}`);
-        }
-      }
-      /**
-       * Logs an error message if the current log level is ERROR or higher.
-       *
-       * @param {string} message - The error message string.
-       */
-      error(message) {
-        if (this.level >= 1 /* ERROR */) {
-          console.error(`[ERROR] ${message}`);
-        }
-      }
-      /**
-       * Static factory method to create a Logger instance based on a simple boolean `verbose` flag.
-       *
-       * @static
-       * @param {{ verbose?: boolean }} [options={}] - An object potentially containing a `verbose` flag.
-       * @returns {Logger} A new Logger instance set to LogLevel.DEBUG if options.verbose is true,
-       * otherwise set to LogLevel.INFO.
-       */
-      static fromVerboseFlag(options = {}) {
-        return new _Logger(options.verbose ? 4 /* DEBUG */ : 3 /* INFO */);
-      }
-      /**
-       * Static factory method to create a Logger instance based on a LogLevel string name.
-       * Useful for creating a logger from config files or environments variables.
-       *
-       * @static
-       * @param {string | undefined} levelName - The name of the log level (e.g., 'debug', 'info', 'warn', 'error', 'silent'/'none'). Case-insensitive.
-       * @param {LogLevel} [defaultLevel=LogLevel.INFO] - The level to use if levelName is invalid or undefined.
-       * @returns {Logger} A new Logger instance set to the corresponding LogLevel.
-       */
-      static fromLevelName(levelName, defaultLevel = 3 /* INFO */) {
-        if (!levelName) {
-          return new _Logger(defaultLevel);
-        }
-        switch (levelName.toLowerCase()) {
-          // Return enum members
-          case "debug":
-            return new _Logger(4 /* DEBUG */);
-          case "info":
-            return new _Logger(3 /* INFO */);
-          case "warn":
-            return new _Logger(2 /* WARN */);
-          case "error":
-            return new _Logger(1 /* ERROR */);
-          case "silent":
-          case "none":
-            return new _Logger(0 /* NONE */);
-          default:
-            console.warn(`[Logger] Invalid log level name "${levelName}". Defaulting to ${LogLevel[defaultLevel]}.`);
-            return new _Logger(defaultLevel);
-        }
-      }
-    };
+    cheerio = __toESM(require("cheerio"), 1);
   }
 });
 
@@ -1093,9 +1046,11 @@ function bundleMultiPageHTML(pages, logger) {
     throw new Error(errorMsg);
   }
   logger?.info(`Bundling ${pages.length} pages into a multi-page HTML document.`);
+  let pageIndex = 0;
   const validPages = pages.filter((page) => {
     const isValid = page && typeof page === "object" && typeof page.url === "string" && typeof page.html === "string";
-    if (!isValid) logger?.warn("Skipping invalid page entry");
+    if (!isValid) logger?.warn(`Skipping invalid page entry at index ${pageIndex}`);
+    pageIndex++;
     return isValid;
   });
   if (validPages.length === 0) {
@@ -1105,70 +1060,137 @@ function bundleMultiPageHTML(pages, logger) {
   }
   const slugMap = /* @__PURE__ */ new Map();
   const usedSlugs = /* @__PURE__ */ new Set();
+  let firstValidSlug = void 0;
+  let pageCounterForFallback = 1;
   for (const page of validPages) {
-    const baseSlug = sanitizeSlug(page.url);
+    let baseSlug = sanitizeSlug(page.url);
+    const isRootIndex = page.url === "/" || page.url === "index.html" || page.url.endsWith("/index.html");
+    if (baseSlug === "index" && !isRootIndex) {
+      logger?.debug(`URL "${page.url}" sanitized to "index", attempting to find alternative slug.`);
+      const pathParts = page.url.replace(/\/$/, "").split("/").filter((p) => p && p.toLowerCase() !== "index.html" && p.toLowerCase() !== "index");
+      if (pathParts.length > 0) {
+        const lastPartSlug = sanitizeSlug(pathParts[pathParts.length - 1]);
+        if (lastPartSlug && lastPartSlug !== "index") {
+          baseSlug = lastPartSlug;
+          logger?.debug(`Using last path part slug "${baseSlug}" instead.`);
+        } else {
+          baseSlug = "page";
+          logger?.debug(`Last path part invalid ("${lastPartSlug}"), using fallback slug "page".`);
+        }
+      } else {
+        baseSlug = "page";
+        logger?.debug(`No valid path parts found, using fallback slug "page".`);
+      }
+    } else if (!baseSlug) {
+      if (isRootIndex) {
+        baseSlug = "index";
+        logger?.debug(`URL "${page.url}" sanitized to empty string, using "index" as it is a root index.`);
+      } else {
+        baseSlug = "page";
+        logger?.debug(`URL "${page.url}" sanitized to empty string, using fallback slug "page".`);
+      }
+    }
+    if (!baseSlug) {
+      baseSlug = `page-${pageCounterForFallback++}`;
+      logger?.warn(`Could not determine a valid base slug for "${page.url}", using generated fallback "${baseSlug}".`);
+    }
     let slug = baseSlug;
-    let counter = 1;
+    let collisionCounter = 1;
+    const originalBaseSlugForLog = baseSlug;
     while (usedSlugs.has(slug)) {
-      slug = `${baseSlug}-${counter++}`;
-      logger?.warn(`Slug collision detected for "${page.url}". Using "${slug}" instead.`);
+      const newSlug = `${originalBaseSlugForLog}-${collisionCounter++}`;
+      logger?.warn(`Slug collision detected for "${page.url}" (intended slug: '${originalBaseSlugForLog}'). Using "${newSlug}" instead.`);
+      slug = newSlug;
     }
     usedSlugs.add(slug);
     slugMap.set(page.url, slug);
+    if (firstValidSlug === void 0) {
+      firstValidSlug = slug;
+    }
   }
-  const defaultPageSlug = slugMap.get(validPages[0].url);
+  const defaultPageSlug = usedSlugs.has("index") ? "index" : firstValidSlug || "page";
   let output = `<!DOCTYPE html>
 <html lang="en">
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
     <title>Multi-Page Bundle</title>
+    <style>
+        body { font-family: sans-serif; margin: 0; }
+        #main-nav { background-color: #f0f0f0; padding: 10px; border-bottom: 1px solid #ccc; }
+        #main-nav a { margin-right: 15px; text-decoration: none; color: #007bff; }
+        #main-nav a.active { font-weight: bold; text-decoration: underline; }
+        #page-container { padding: 20px; }
+        template { display: none; }
+    </style>
 </head>
 <body>
     <nav id="main-nav">
         ${validPages.map((p) => {
     const slug = slugMap.get(p.url);
-    const label = p.url.split("/").pop()?.split(".")[0] || "Page";
+    const label = slug;
     return `<a href="#${slug}" data-page="${slug}">${label}</a>`;
-  }).join("\n")}
+  }).join("\n        ")}
     </nav>
     <div id="page-container"></div>
     ${validPages.map((p) => {
     const slug = slugMap.get(p.url);
     return `<template id="page-${slug}">${p.html}</template>`;
-  }).join("\n")}
+  }).join("\n    ")}
     <script id="router-script">
         document.addEventListener('DOMContentLoaded', function() {
+            const pageContainer = document.getElementById('page-container');
+            const navLinks = document.querySelectorAll('#main-nav a');
+
             function navigateTo(slug) {
                 const template = document.getElementById('page-' + slug);
-                const container = document.getElementById('page-container');
-                if (!template || !container) return;
-                container.innerHTML = '';
-                container.appendChild(template.content.cloneNode(true));
-                document.querySelectorAll('#main-nav a').forEach(link => {
-                    if (link.getAttribute('data-page') === slug) link.classList.add('active');
-                    else link.classList.remove('active');
+                if (!template || !pageContainer) {
+                    console.warn('Navigation failed: Template or container not found for slug:', slug);
+                    // Maybe try navigating to default page? Or just clear container?
+                    if (pageContainer) pageContainer.innerHTML = '<p>Page not found.</p>';
+                    return;
+                }
+                // Clear previous content and append new content
+                pageContainer.innerHTML = ''; // Clear reliably
+                pageContainer.appendChild(template.content.cloneNode(true));
+
+                // Update active link styling
+                navLinks.forEach(link => {
+                    link.classList.toggle('active', link.getAttribute('data-page') === slug);
                 });
+
+                // Update URL hash without triggering hashchange if already correct
                 if (window.location.hash.substring(1) !== slug) {
-                    history.pushState(null, '', '#' + slug);
+                    // Use pushState for cleaner history
+                    history.pushState({ slug: slug }, '', '#' + slug);
                 }
             }
 
-            window.addEventListener('hashchange', () => {
-                const slug = window.location.hash.substring(1);
-                if (document.getElementById('page-' + slug)) navigateTo(slug);
+            // Handle back/forward navigation
+            window.addEventListener('popstate', (event) => {
+                let slug = window.location.hash.substring(1);
+                // If popstate event has state use it, otherwise fallback to hash or default
+                if (event && event.state && event.state.slug) { // Check event exists
+                    slug = event.state.slug;
+                }
+                // Ensure the target page exists before navigating, fallback to default slug
+                const targetSlug = document.getElementById('page-' + slug) ? slug : '${defaultPageSlug}';
+                navigateTo(targetSlug);
             });
 
-            document.querySelectorAll('#main-nav a').forEach(link => {
+            // Handle direct link clicks
+            navLinks.forEach(link => {
                 link.addEventListener('click', function(e) {
                     e.preventDefault();
                     const slug = this.getAttribute('data-page');
-                    navigateTo(slug);
+                    if (slug) navigateTo(slug);
                 });
             });
 
-            const initial = window.location.hash.substring(1);
-            navigateTo(document.getElementById('page-' + initial) ? initial : '${defaultPageSlug}');
+            // Initial page load
+            const initialHash = window.location.hash.substring(1);
+            const initialSlug = document.getElementById('page-' + initialHash) ? initialHash : '${defaultPageSlug}';
+            navigateTo(initialSlug);
         });
     </script>
 </body>
@@ -1182,58 +1204,69 @@ var init_bundler = __esm({
     init_extractor();
     init_minifier();
     init_packer();
+    init_types();
     init_slugify();
   }
 });
 
 // src/core/web-fetcher.ts
-import * as puppeteer from "puppeteer";
-import * as fs2 from "fs/promises";
-async function fetchAndPackWebPage(url, logger, timeout = 3e4) {
+async function fetchAndPackWebPage(url, logger, timeout = DEFAULT_PAGE_TIMEOUT, userAgent) {
   let browser = null;
   const start = Date.now();
-  logger?.debug(`Initiating fetch for single page: ${url}`);
+  logger?.info(`Initiating fetch for single page: ${url}`);
   try {
-    browser = await puppeteer.launch({ headless: true });
-    logger?.debug(`Browser launched for ${url}`);
+    logger?.debug("Launching browser...");
+    browser = await puppeteer.launch(PUPPETEER_LAUNCH_OPTIONS);
+    logger?.debug(`Browser launched successfully (PID: ${browser.process()?.pid}).`);
     const page = await browser.newPage();
-    logger?.debug(`Page created for ${url}`);
+    logger?.debug(`New page created for ${url}`);
+    if (userAgent) {
+      await page.setUserAgent(userAgent);
+      logger?.debug(`User-Agent set to: "${userAgent}"`);
+    }
     try {
       logger?.debug(`Navigating to ${url} with timeout ${timeout}ms`);
       await page.goto(url, { waitUntil: "networkidle2", timeout });
       logger?.debug(`Navigation successful for ${url}`);
       const html = await page.content();
-      logger?.debug(`Content retrieved for ${url}`);
+      logger?.debug(`Content retrieved for ${url} (${Buffer.byteLength(html, "utf-8")} bytes)`);
       const metadata = {
         input: url,
         outputSize: Buffer.byteLength(html, "utf-8"),
         assetCount: 0,
-        // Basic fetch doesn't track assets
+        // Basic fetch doesn't track assets processed by *this* tool
         buildTimeMs: Date.now() - start,
         errors: []
         // No errors if we reached this point
       };
       await page.close();
       logger?.debug(`Page closed for ${url}`);
+      await browser.close();
       logger?.debug(`Browser closed for ${url}`);
       browser = null;
       return { html, metadata };
     } catch (pageError) {
       logger?.error(`Error during page processing for ${url}: ${pageError.message}`);
-      try {
-        await page.close();
-      } catch (closeErr) {
-        throw closeErr;
+      if (page && !page.isClosed()) {
+        try {
+          await page.close();
+          logger?.debug(`Page closed after error for ${url}`);
+        } catch (closeErr) {
+          logger?.error(`Failed to close page after error for ${url}: ${closeErr.message}`);
+        }
       }
       throw pageError;
     }
   } catch (launchError) {
-    logger?.error(`Critical error during browser launch or page creation for ${url}: ${launchError.message}`);
+    logger?.error(`Critical error during browser launch or page setup for ${url}: ${launchError.message}`);
     if (browser) {
       try {
         await browser.close();
+        logger?.debug("Browser closed after launch/setup error.");
       } catch (closeErr) {
+        logger?.warn(`Failed to close browser after launch/setup error: ${closeErr.message}`);
       }
+      browser = null;
     }
     throw launchError;
   } finally {
@@ -1246,99 +1279,123 @@ async function fetchAndPackWebPage(url, logger, timeout = 3e4) {
     }
   }
 }
-async function crawlWebsite(startUrl, maxDepth, logger) {
+async function crawlWebsite(startUrl, options) {
+  const {
+    maxDepth = 1,
+    timeout = DEFAULT_PAGE_TIMEOUT,
+    // include = ['**'], // TODO: Implement glob filtering
+    // exclude = [],
+    userAgent,
+    logger
+  } = options;
   logger?.info(`Starting crawl for ${startUrl} with maxDepth ${maxDepth}`);
   if (maxDepth <= 0) {
-    logger?.info("maxDepth is 0 or negative, no pages will be crawled.");
+    logger?.warn("maxDepth is 0 or negative, no pages will be crawled.");
     return [];
   }
-  const browser = await puppeteer.launch({ headless: true });
+  let browser = null;
   const visited = /* @__PURE__ */ new Set();
   const results = [];
   const queue = [];
   let startOrigin;
   try {
-    startOrigin = new URL(startUrl).origin;
-  } catch (e) {
-    logger?.error(`Invalid start URL: ${startUrl}. ${e.message}`);
-    await browser.close();
-    return [];
-  }
-  let normalizedStartUrl;
-  try {
-    const parsedStartUrl = new URL(startUrl);
-    parsedStartUrl.hash = "";
-    normalizedStartUrl = parsedStartUrl.href;
-  } catch (e) {
-    logger?.error(`Invalid start URL: ${startUrl}. ${e.message}`);
-    await browser.close();
-    return [];
-  }
-  visited.add(normalizedStartUrl);
-  queue.push({ url: normalizedStartUrl, depth: 1 });
-  logger?.debug(`Queued initial URL: ${normalizedStartUrl} (depth 1)`);
-  while (queue.length > 0) {
-    const { url, depth } = queue.shift();
-    logger?.info(`Processing: ${url} (depth ${depth})`);
-    let page = null;
     try {
-      page = await browser.newPage();
-      await page.setViewport({ width: 1280, height: 800 });
-      await page.goto(url, { waitUntil: "networkidle2", timeout: 3e4 });
-      const html = await page.content();
-      results.push({ url, html });
-      logger?.debug(`Successfully fetched content for ${url}`);
-      if (depth < maxDepth) {
-        logger?.debug(`Discovering links on ${url} (current depth ${depth}, maxDepth ${maxDepth})`);
-        const hrefs = await page.evaluate(
-          () => Array.from(document.querySelectorAll("a[href]"), (a) => a.getAttribute("href"))
-        );
-        logger?.debug(`Found ${hrefs.length} potential hrefs on ${url}`);
-        let linksAdded = 0;
-        for (const href of hrefs) {
-          if (!href) continue;
-          let absoluteUrl;
-          try {
-            const resolved = new URL(href, url);
-            resolved.hash = "";
-            absoluteUrl = resolved.href;
-          } catch (e) {
-            logger?.debug(`Ignoring invalid URL syntax: "${href}" on page ${url}`);
-            continue;
-          }
-          if (absoluteUrl.startsWith(startOrigin) && !visited.has(absoluteUrl)) {
-            visited.add(absoluteUrl);
-            queue.push({ url: absoluteUrl, depth: depth + 1 });
-            linksAdded++;
-          } else {
+      startOrigin = new URL(startUrl).origin;
+    } catch (e) {
+      logger?.error(`Invalid start URL: ${startUrl}. ${e.message}`);
+      throw new Error(`Invalid start URL: ${startUrl}`);
+    }
+    let normalizedStartUrl;
+    try {
+      const parsedStartUrl = new URL(startUrl);
+      parsedStartUrl.hash = "";
+      normalizedStartUrl = parsedStartUrl.href;
+    } catch (e) {
+      logger?.error(`Invalid start URL: ${startUrl}. ${e.message}`);
+      throw new Error(`Invalid start URL: ${startUrl}`);
+    }
+    logger?.debug("Launching browser for crawl...");
+    browser = await puppeteer.launch(PUPPETEER_LAUNCH_OPTIONS);
+    logger?.debug(`Browser launched for crawl (PID: ${browser.process()?.pid}).`);
+    visited.add(normalizedStartUrl);
+    queue.push({ url: normalizedStartUrl, depth: 1 });
+    logger?.debug(`Queued initial URL: ${normalizedStartUrl} (depth 1)`);
+    while (queue.length > 0) {
+      const { url, depth } = queue.shift();
+      logger?.info(`Processing: ${url} (depth ${depth})`);
+      let page = null;
+      try {
+        page = await browser.newPage();
+        if (userAgent) {
+          await page.setUserAgent(userAgent);
+        }
+        await page.goto(url, { waitUntil: "networkidle2", timeout });
+        const html = await page.content();
+        results.push({ url, html });
+        logger?.debug(`Successfully fetched content for ${url}`);
+        if (depth < maxDepth) {
+          logger?.debug(`Discovering links on ${url} (depth ${depth}/${maxDepth})`);
+          const hrefs = await page.evaluate(
+            () => Array.from(document.querySelectorAll("a[href]"), (a) => a.getAttribute("href"))
+          );
+          logger?.debug(`Found ${hrefs.length} potential hrefs on ${url}`);
+          let linksAdded = 0;
+          for (const href of hrefs) {
+            if (!href) continue;
+            let absoluteUrl;
+            try {
+              const resolved = new URL(href, url);
+              resolved.hash = "";
+              absoluteUrl = resolved.href;
+            } catch (e) {
+              logger?.debug(`Ignoring invalid URL syntax: "${href}" on page ${url}`);
+              continue;
+            }
+            if (absoluteUrl.startsWith(startOrigin) && !visited.has(absoluteUrl)) {
+              visited.add(absoluteUrl);
+              queue.push({ url: absoluteUrl, depth: depth + 1 });
+              linksAdded++;
+            }
           }
+          logger?.debug(`Added ${linksAdded} new unique internal links to queue from ${url}`);
+        } else {
+          logger?.debug(`Max depth (${maxDepth}) reached, not discovering links on ${url}`);
         }
-        logger?.debug(`Added ${linksAdded} new unique internal links to queue from ${url}`);
-      } else {
-        logger?.debug(`Max depth (${maxDepth}) reached, not discovering links on ${url}`);
-      }
-    } catch (err) {
-      logger?.warn(`\u274C Failed to process ${url}: ${err.message}`);
-    } finally {
-      if (page) {
-        try {
-          await page.close();
-        } catch (pageCloseError) {
-          logger?.error(`Failed to close page for ${url}: ${pageCloseError.message}`);
+      } catch (err) {
+        logger?.warn(`\u274C Failed to process ${url}: ${err.message}`);
+      } finally {
+        if (page && !page.isClosed()) {
+          try {
+            await page.close();
+          } catch (pageCloseError) {
+            logger?.error(`Failed to close page for ${url}: ${pageCloseError.message}`);
+          }
         }
       }
     }
+  } catch (error) {
+    logger?.error(`Critical crawl error: ${error instanceof Error ? error.message : error}`);
+    throw error;
+  } finally {
+    if (browser) {
+      logger?.info(`Crawl finished or errored. Closing browser.`);
+      await browser.close();
+      logger?.debug(`Browser closed after crawl.`);
+    }
   }
-  logger?.info(`Crawl finished. Closing browser.`);
-  await browser.close();
-  logger?.info(`Found ${results.length} pages.`);
+  logger?.info(`Crawl found ${results.length} pages.`);
   return results;
 }
-async function recursivelyBundleSite(startUrl, outputFile, maxDepth = 1) {
-  const logger = new Logger();
+async function recursivelyBundleSite(startUrl, outputFile, maxDepth = 1, loggerInstance) {
+  const logger = loggerInstance || new Logger();
   logger.info(`Starting recursive site bundle for ${startUrl} to ${outputFile} (maxDepth: ${maxDepth})`);
   try {
-    const pages = await crawlWebsite(startUrl, maxDepth, logger);
+    const crawlOptions = {
+      maxDepth,
+      logger
+      /* Add other options like timeout, userAgent if needed */
+    };
+    const pages = await crawlWebsite(startUrl, crawlOptions);
     if (pages.length === 0) {
       logger.warn("Crawl completed but found 0 pages. Output file may be empty or reflect an empty bundle.");
     } else {
@@ -1361,11 +1418,98 @@ async function recursivelyBundleSite(startUrl, outputFile, maxDepth = 1) {
     throw error;
   }
 }
+var puppeteer, fs2, PUPPETEER_LAUNCH_OPTIONS, DEFAULT_PAGE_TIMEOUT;
 var init_web_fetcher = __esm({
   "src/core/web-fetcher.ts"() {
     "use strict";
+    puppeteer = __toESM(require("puppeteer"), 1);
+    fs2 = __toESM(require("fs/promises"), 1);
     init_logger();
     init_bundler();
+    PUPPETEER_LAUNCH_OPTIONS = {
+      headless: true,
+      args: [
+        "--no-sandbox",
+        // Often required in containerized environments
+        "--disable-setuid-sandbox",
+        "--disable-dev-shm-usage"
+        // Recommended for Docker/CI
+      ]
+    };
+    DEFAULT_PAGE_TIMEOUT = 3e4;
+  }
+});
+
+// src/core/parser.ts
+async function parseHTML(entryFilePath, logger) {
+  logger?.debug(`Parsing HTML file: ${entryFilePath}`);
+  let htmlContent;
+  try {
+    htmlContent = await (0, import_promises2.readFile)(entryFilePath, "utf-8");
+    logger?.debug(`Successfully read HTML file (${Buffer.byteLength(htmlContent)} bytes).`);
+  } catch (err) {
+    logger?.error(`Failed to read HTML file "${entryFilePath}": ${err.message}`);
+    throw new Error(`Could not read input HTML file: ${entryFilePath}`, { cause: err });
+  }
+  const $ = cheerio2.load(htmlContent);
+  const assets = [];
+  const addedUrls = /* @__PURE__ */ new Set();
+  const addAsset = (url, forcedType) => {
+    if (!url || url.trim() === "" || url.startsWith("data:")) {
+      return;
+    }
+    if (!addedUrls.has(url)) {
+      addedUrls.add(url);
+      const mimeInfo = guessMimeType(url);
+      const type = forcedType ?? mimeInfo.assetType;
+      assets.push({ type, url });
+      logger?.debug(`Discovered asset: Type='${type}', URL='${url}'`);
+    } else {
+      logger?.debug(`Skipping duplicate asset URL: ${url}`);
+    }
+  };
+  logger?.debug("Extracting assets from HTML tags...");
+  $('link[rel="stylesheet"][href]').each((_, el) => {
+    addAsset($(el).attr("href"), "css");
+  });
+  $("script[src]").each((_, el) => {
+    addAsset($(el).attr("src"), "js");
+  });
+  $("img[src]").each((_, el) => addAsset($(el).attr("src"), "image"));
+  $('input[type="image"][src]').each((_, el) => addAsset($(el).attr("src"), "image"));
+  $("img[srcset], picture source[srcset]").each((_, el) => {
+    const srcset = $(el).attr("srcset");
+    srcset?.split(",").forEach((entry) => {
+      const [url] = entry.trim().split(/\s+/);
+      addAsset(url, "image");
+    });
+  });
+  $("video[src]").each((_, el) => addAsset($(el).attr("src"), "video"));
+  $("video[poster]").each((_, el) => addAsset($(el).attr("poster"), "image"));
+  $("audio[src]").each((_, el) => addAsset($(el).attr("src"), "audio"));
+  $("video > source[src]").each((_, el) => addAsset($(el).attr("src"), "video"));
+  $("audio > source[src]").each((_, el) => addAsset($(el).attr("src"), "audio"));
+  $("link[href]").filter((_, el) => {
+    const rel = $(el).attr("rel")?.toLowerCase() ?? "";
+    return ["icon", "shortcut icon", "apple-touch-icon", "manifest"].includes(rel);
+  }).each((_, el) => {
+    const rel = $(el).attr("rel")?.toLowerCase() ?? "";
+    const isIcon = ["icon", "shortcut icon", "apple-touch-icon"].includes(rel);
+    addAsset($(el).attr("href"), isIcon ? "image" : void 0);
+  });
+  $('link[rel="preload"][as="font"][href]').each((_, el) => {
+    addAsset($(el).attr("href"), "font");
+  });
+  logger?.info(`HTML parsing complete. Discovered ${assets.length} unique asset links.`);
+  return { htmlContent, assets };
+}
+var import_promises2, cheerio2;
+var init_parser = __esm({
+  "src/core/parser.ts"() {
+    "use strict";
+    import_promises2 = require("fs/promises");
+    cheerio2 = __toESM(require("cheerio"), 1);
+    init_mime();
   }
 });
 
@@ -1455,117 +1599,91 @@ var init_meta = __esm({
 });
 
 // src/index.ts
+async function pack(input, options = {}) {
+  const logger = options.loggerInstance || new Logger(options.logLevel);
+  const isHttp = /^https?:\/\//i.test(input);
+  if (!isHttp && /:\/\//.test(input) && !input.startsWith("file://")) {
+    const errorMsg = `Unsupported protocol or input type: ${input}`;
+    logger.error(errorMsg);
+    throw new Error(errorMsg);
+  }
+  const isRemote = /^https?:\/\//i.test(input);
+  const recursive = options.recursive === true || typeof options.recursive === "number";
+  if (isRemote && recursive) {
+    const depth = typeof options.recursive === "number" ? options.recursive : 1;
+    logger.info(`Starting recursive fetch for ${input} up to depth ${depth}`);
+    return generateRecursivePortableHTML(input, depth, options, logger);
+  }
+  logger.info(`Starting single page processing for: ${input}`);
+  return generatePortableHTML(input, options, logger);
+}
 async function generatePortableHTML(input, options = {}, loggerInstance) {
   const logger = loggerInstance || new Logger(options.logLevel);
-  logger.info(`Generating portable HTML for: ${input}`);
   const timer = new BuildTimer(input);
-  const isRemote = /^https?:\/\//i.test(input);
-  if (isRemote) {
-    logger.info(`Input is a remote URL. Fetching page content directly...`);
+  if (/^https?:\/\//i.test(input)) {
+    logger.info(`Workspaceing remote page: ${input}`);
     try {
-      const result = await fetchAndPackWebPage2(input, options, logger);
-      logger.info(`Remote fetch complete. Input: ${input}, Size: ${result.metadata.outputSize} bytes, Time: ${result.metadata.buildTimeMs}ms`);
-      return result;
+      const result = await fetchAndPackWebPage(input, logger);
+      const metadata = timer.finish(result.html, result.metadata);
+      logger.info(`Finished fetching and packing remote page: ${input}`);
+      return { html: result.html, metadata };
     } catch (error) {
-      logger.error(`Failed to fetch remote URL ${input}: ${error.message}`);
+      logger.error(`Error fetching remote page ${input}: ${error.message}`);
       throw error;
     }
   }
-  logger.info(`Input is a local file path. Starting local processing pipeline...`);
-  const basePath = options.baseUrl || input;
-  logger.debug(`Using base path for asset resolution: ${basePath}`);
+  logger.info(`Processing local file: ${input}`);
   try {
+    const baseUrl = options.baseUrl || input;
     const parsed = await parseHTML(input, logger);
-    const enriched = await extractAssets(parsed, options.embedAssets ?? true, basePath, logger);
+    const enriched = await extractAssets(parsed, options.embedAssets ?? true, baseUrl, logger);
     const minified = await minifyAssets(enriched, options, logger);
     const finalHtml = packHTML(minified, logger);
     const metadata = timer.finish(finalHtml, {
       assetCount: minified.assets.length
-      // FIX: Removed incorrect attempt to get errors from logger
-      // Errors collected by the timer itself (via timer.addError) will be included automatically.
     });
-    logger.info(`Local processing complete. Input: ${input}, Size: ${metadata.outputSize} bytes, Assets: ${metadata.assetCount}, Time: ${metadata.buildTimeMs}ms`);
-    if (metadata.errors && metadata.errors.length > 0) {
-      logger.warn(`Completed with ${metadata.errors.length} warning(s) logged in metadata.`);
-    }
+    logger.info(`Finished processing local file: ${input}`);
     return { html: finalHtml, metadata };
   } catch (error) {
-    logger.error(`Error during local processing for ${input}: ${error.message}`);
+    logger.error(`Error processing local file ${input}: ${error.message}`);
     throw error;
   }
 }
 async function generateRecursivePortableHTML(url, depth = 1, options = {}, loggerInstance) {
   const logger = loggerInstance || new Logger(options.logLevel);
-  logger.info(`Generating recursive portable HTML for: ${url}, Max Depth: ${depth}`);
   const timer = new BuildTimer(url);
   if (!/^https?:\/\//i.test(url)) {
-    const errMsg = `Invalid input URL for recursive bundling: ${url}. Must start with http(s)://`;
-    logger.error(errMsg);
-    throw new Error(errMsg);
+    const errorMsg = `Invalid URL for recursive bundling. Must start with http:// or https://. Received: ${url}`;
+    logger.error(errorMsg);
+    throw new Error(errorMsg);
   }
-  const internalOutputPathPlaceholder = `${new URL(url).hostname}_recursive.html`;
+  logger.info(`Starting recursive bundle for ${url} up to depth ${depth}`);
   try {
-    const { html, pages } = await recursivelyBundleSite(url, internalOutputPathPlaceholder, depth);
-    logger.info(`Recursive crawl complete. Discovered and bundled ${pages} pages.`);
+    const { html, pages } = await recursivelyBundleSite(url, "output.html", depth, logger);
     timer.setPageCount(pages);
     const metadata = timer.finish(html, {
       assetCount: 0,
-      // NOTE: Asset count across multiple pages is not currently aggregated.
       pagesBundled: pages
-      // TODO: Potentially collect errors from the core function if it returns them
     });
-    logger.info(`Recursive bundling complete. Input: ${url}, Size: ${metadata.outputSize} bytes, Pages: ${metadata.pagesBundled}, Time: ${metadata.buildTimeMs}ms`);
-    if (metadata.errors && metadata.errors.length > 0) {
-      logger.warn(`Completed with ${metadata.errors.length} warning(s) logged in metadata.`);
-    }
+    logger.info(`Finished recursive bundle for ${url}. Bundled ${pages} pages.`);
     return { html, metadata };
   } catch (error) {
-    logger.error(`Error during recursive generation for ${url}: ${error.message}`);
-    if (error.cause instanceof Error) {
-      logger.error(`Cause: ${error.cause.message}`);
-    }
-    throw error;
-  }
-}
-async function fetchAndPackWebPage2(url, options = {}, loggerInstance) {
-  const logger = loggerInstance || new Logger(options.logLevel);
-  logger.info(`Workspaceing single remote page: ${url}`);
-  const timer = new BuildTimer(url);
-  if (!/^https?:\/\//i.test(url)) {
-    const errMsg = `Invalid input URL for fetchAndPackWebPage: ${url}. Must start with http(s)://`;
-    logger.error(errMsg);
-    throw new Error(errMsg);
-  }
-  try {
-    const result = await fetchAndPackWebPage(url, logger);
-    const metadata = timer.finish(result.html, {
-      // Use assetCount and errors from core metadata if available
-      assetCount: result.metadata?.assetCount ?? 0,
-      errors: result.metadata?.errors ?? []
-      // Ensure errors array exists
-    });
-    logger.info(`Single page fetch complete. Input: ${url}, Size: ${metadata.outputSize} bytes, Assets: ${metadata.assetCount}, Time: ${metadata.buildTimeMs}ms`);
-    if (metadata.errors && metadata.errors.length > 0) {
-      logger.warn(`Completed with ${metadata.errors.length} warning(s) logged in metadata.`);
-    }
-    return { html: result.html, metadata };
-  } catch (error) {
-    logger.error(`Error during single page fetch for ${url}: ${error.message}`);
+    logger.error(`Error during recursive bundle for ${url}: ${error.message}`);
     throw error;
   }
 }
 var init_src = __esm({
   "src/index.ts"() {
     "use strict";
+    init_web_fetcher();
     init_parser();
     init_extractor();
     init_minifier();
     init_packer();
-    init_web_fetcher();
     init_bundler();
+    init_logger();
     init_meta();
     init_logger();
-    init_types();
   }
 });
 
@@ -1575,20 +1693,15 @@ __export(cli_exports, {
   main: () => main,
   runCli: () => runCli
 });
-import fs3 from "fs";
-import path3 from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
 function getPackageJson() {
   try {
-    const __filename = fileURLToPath2(import.meta.url);
-    const __dirname = path3.dirname(__filename);
-    const pkgPath = path3.resolve(__dirname, "../../package.json");
-    if (fs3.existsSync(pkgPath)) {
-      return JSON.parse(fs3.readFileSync(pkgPath, "utf-8"));
-    }
-  } catch (_) {
+    const searchPath = typeof __dirname !== "undefined" ? import_path3.default.join(__dirname, "..", "..") : process.cwd();
+    const pkgJsonPath = require.resolve("portapack/package.json", { paths: [searchPath] });
+    return require(pkgJsonPath);
+  } catch (err) {
+    console.error("Warning: Could not dynamically load package.json for version.", err);
+    return { version: "0.0.0-unknown" };
   }
-  return { version: "0.1.0" };
 }
 async function runCli(argv = process.argv) {
   let stdout = "";
@@ -1597,6 +1710,11 @@ async function runCli(argv = process.argv) {
   const originalLog = console.log;
   const originalErr = console.error;
   const originalWarn = console.warn;
+  const restoreConsole = () => {
+    console.log = originalLog;
+    console.error = originalErr;
+    console.warn = originalWarn;
+  };
   console.log = (...args) => {
     stdout += args.join(" ") + "\n";
   };
@@ -1606,40 +1724,38 @@ async function runCli(argv = process.argv) {
   console.warn = (...args) => {
     stderr += args.join(" ") + "\n";
   };
-  let opts;
+  let cliOptions;
   try {
-    opts = parseOptions(argv);
-    const version = getPackageJson().version || "0.1.0";
-    if (opts.verbose) {
+    cliOptions = parseOptions(argv);
+    const version = getPackageJson().version || "0.0.0";
+    if (cliOptions.verbose) {
       console.log(`\u{1F4E6} PortaPack v${version}`);
     }
-    if (!opts.input) {
+    if (!cliOptions.input) {
       console.error("\u274C Missing input file or URL");
-      console.log = originalLog;
-      console.error = originalErr;
-      console.warn = originalWarn;
+      restoreConsole();
       return { stdout, stderr, exitCode: 1 };
     }
-    const outputPath = opts.output ?? `${path3.basename(opts.input).split(".")[0] || "output"}.packed.html`;
-    if (opts.verbose) {
-      console.log(`\u{1F4E5} Input: ${opts.input}`);
+    const inputBasename = import_path3.default.basename(cliOptions.input);
+    const outputDefaultBase = inputBasename.includes(".") ? inputBasename.substring(0, inputBasename.lastIndexOf(".")) : inputBasename;
+    const outputPath = cliOptions.output ?? `${outputDefaultBase || "output"}.packed.html`;
+    if (cliOptions.verbose) {
+      console.log(`\u{1F4E5} Input: ${cliOptions.input}`);
       console.log(`\u{1F4E4} Output: ${outputPath}`);
-      console.log(`   Recursive: ${opts.recursive ?? false}`);
-      console.log(`   Embed Assets: ${opts.embedAssets}`);
-      console.log(`   Minify HTML: ${opts.minifyHtml}`);
-      console.log(`   Minify CSS: ${opts.minifyCss}`);
-      console.log(`   Minify JS: ${opts.minifyJs}`);
-      console.log(`   Log Level: ${LogLevel[opts.logLevel ?? 3 /* INFO */]}`);
+      console.log(`  Recursive: ${cliOptions.recursive ?? false}`);
+      console.log(`  Embed Assets: ${cliOptions.embedAssets}`);
+      console.log(`  Minify HTML: ${cliOptions.minifyHtml}`);
+      console.log(`  Minify CSS: ${cliOptions.minifyCss}`);
+      console.log(`  Minify JS: ${cliOptions.minifyJs}`);
+      console.log(`  Log Level: ${cliOptions.logLevel}`);
     }
-    if (opts.dryRun) {
+    if (cliOptions.dryRun) {
       console.log("\u{1F4A1} Dry run mode \u2014 no output will be written");
-      console.log = originalLog;
-      console.error = originalErr;
-      console.warn = originalWarn;
+      restoreConsole();
       return { stdout, stderr, exitCode: 0 };
     }
-    const result = opts.recursive ? await generateRecursivePortableHTML(opts.input, typeof opts.recursive === "boolean" ? 1 : opts.recursive, opts) : await generatePortableHTML(opts.input, opts);
-    fs3.writeFileSync(outputPath, result.html, "utf-8");
+    const result = await pack(cliOptions.input, cliOptions);
+    import_fs.default.writeFileSync(outputPath, result.html, "utf-8");
     const meta = result.metadata;
     console.log(`\u2705 Packed: ${meta.input} \u2192 ${outputPath}`);
     console.log(`\u{1F4E6} Size: ${(meta.outputSize / 1024).toFixed(2)} KB`);
@@ -1648,7 +1764,7 @@ async function runCli(argv = process.argv) {
     if (meta.pagesBundled && meta.pagesBundled > 0) {
       console.log(`\u{1F9E9} Pages: ${meta.pagesBundled}`);
     }
-    if (meta.errors && meta.errors.length > 0) {
+    if (meta.errors?.length) {
       console.warn(`
 \u26A0\uFE0F  ${meta.errors.length} warning(s):`);
       for (const err of meta.errors) {
@@ -1658,37 +1774,49 @@ async function runCli(argv = process.argv) {
   } catch (err) {
     console.error(`
 \u{1F4A5} Error: ${err?.message || "Unknown failure"}`);
-    if (err?.stack && opts?.verbose) {
+    if (err?.stack && cliOptions?.verbose) {
       console.error(err.stack);
     }
     exitCode = 1;
   } finally {
-    console.log = originalLog;
-    console.error = originalErr;
-    console.warn = originalWarn;
+    restoreConsole();
   }
   return { stdout, stderr, exitCode };
 }
-var main;
+var import_fs, import_path3, main;
 var init_cli = __esm({
   "src/cli/cli.ts"() {
     "use strict";
+    import_fs = __toESM(require("fs"), 1);
+    import_path3 = __toESM(require("path"), 1);
     init_options();
     init_src();
-    init_types();
     main = runCli;
   }
 });
 
 // src/cli/cli-entry.ts
+var cli_entry_exports = {};
+__export(cli_entry_exports, {
+  startCLI: () => startCLI
+});
+module.exports = __toCommonJS(cli_entry_exports);
 var startCLI = async () => {
   const { main: main2 } = await Promise.resolve().then(() => (init_cli(), cli_exports));
   return await main2(process.argv);
 };
-if (import.meta.url === `file://${process.argv[1]}`) {
-  startCLI().then(({ exitCode }) => process.exit(Number(exitCode)));
+if (require.main === module) {
+  startCLI().then(({ stdout, stderr, exitCode }) => {
+    if (stdout) process.stdout.write(stdout);
+    if (stderr) process.stderr.write(stderr);
+    process.exit(Number(exitCode));
+  }).catch((err) => {
+    console.error("\u{1F4A5} Unhandled CLI error:", err);
+    process.exit(1);
+  });
 }
-export {
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
   startCLI
-};
-//# sourceMappingURL=cli-entry.js.map
+});
+//# sourceMappingURL=cli-entry.cjs.map