portapack 0.2.1 → 0.3.0

package/dist/index.js

@@ -1,6 +1,129 @@
-// src/core/parser.ts
+// src/core/web-fetcher.ts
+import * as puppeteer from "puppeteer";
+import * as fs2 from "fs/promises";
+
+// src/types.ts
+var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
+  LogLevel2[LogLevel2["NONE"] = 0] = "NONE";
+  LogLevel2[LogLevel2["ERROR"] = 1] = "ERROR";
+  LogLevel2[LogLevel2["WARN"] = 2] = "WARN";
+  LogLevel2[LogLevel2["INFO"] = 3] = "INFO";
+  LogLevel2[LogLevel2["DEBUG"] = 4] = "DEBUG";
+  return LogLevel2;
+})(LogLevel || {});
+
+// src/utils/logger.ts
+var 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/core/extractor.ts
 import { readFile } from "fs/promises";
-import * as cheerio from "cheerio";
+import * as fs from "fs";
+import path2 from "path";
+import { fileURLToPath, URL as URL2 } from "url";
+import * as axiosNs from "axios";
 
 // src/utils/mime.ts
 import path from "path";
@@ -58,76 +181,7 @@ function guessMimeType(urlOrPath) {
   return MIME_MAP[ext] || DEFAULT_MIME_TYPE;
 }
 
-// src/core/parser.ts
-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 };
-}
-
 // 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";
 var TEXT_ASSET_TYPES = /* @__PURE__ */ new Set(["css", "js"]);
 var BINARY_ASSET_TYPES = /* @__PURE__ */ new Set(["image", "font", "video", "audio"]);
 var MAX_ASSET_EXTRACTION_ITERATIONS = 1e3;
@@ -140,6 +194,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.");
@@ -153,49 +208,46 @@ function determineBaseUrl(inputPathOrUrl, logger) {
       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 = 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 = path2.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 : path2.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 URL2("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;
   }
 }
@@ -216,6 +268,10 @@ function resolveAssetUrl(assetUrl, baseContextUrl, logger) {
   }
   try {
     const resolved = new URL2(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);
@@ -228,83 +284,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 URL2(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);
       } 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 = path2.normalize(filePath);
+      console.log(`[DEBUG fetchAsset] Attempting readFile with path: "${normalizedForLog}" (Original from URL: "${filePath}")`);
+      const data = await 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:" ? path2.normalize(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);
       } catch {
       }
+      failedPath = path2.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 {
@@ -332,14 +383,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()");
@@ -355,23 +405,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
       });
@@ -379,7 +434,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;
@@ -450,7 +505,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")}`;
@@ -497,6 +552,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) {
@@ -671,7 +727,7 @@ async function minifyAssets(parsed, options = {}, logger) {
 }
 
 // src/core/packer.ts
-import * as cheerio2 from "cheerio";
+import * as cheerio from "cheerio";
 function escapeScriptContent(code) {
   return code.replace(/<\/(script)/gi, "<\\/$1");
 }
@@ -784,7 +840,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...");
@@ -795,126 +851,6 @@ function packHTML(parsed, logger) {
   return finalHtml;
 }
 
-// src/core/web-fetcher.ts
-import * as puppeteer from "puppeteer";
-import * as fs2 from "fs/promises";
-
-// src/types.ts
-var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
-  LogLevel2[LogLevel2["NONE"] = 0] = "NONE";
-  LogLevel2[LogLevel2["ERROR"] = 1] = "ERROR";
-  LogLevel2[LogLevel2["WARN"] = 2] = "WARN";
-  LogLevel2[LogLevel2["INFO"] = 3] = "INFO";
-  LogLevel2[LogLevel2["DEBUG"] = 4] = "DEBUG";
-  return LogLevel2;
-})(LogLevel || {});
-
-// src/utils/logger.ts
-var 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/slugify.ts
 function slugify(url) {
   if (!url || typeof url !== "string") return "index";
@@ -946,9 +882,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) {
@@ -958,70 +896,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>
@@ -1031,51 +1036,74 @@ function bundleMultiPageHTML(pages, logger) {
 }
 
 // src/core/web-fetcher.ts
-async function fetchAndPackWebPage(url, logger, timeout = 3e4) {
+var PUPPETEER_LAUNCH_OPTIONS = {
+  headless: true,
+  args: [
+    "--no-sandbox",
+    // Often required in containerized environments
+    "--disable-setuid-sandbox",
+    "--disable-dev-shm-usage"
+    // Recommended for Docker/CI
+  ]
+};
+var DEFAULT_PAGE_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 {
@@ -1088,99 +1116,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 {
@@ -1204,6 +1256,72 @@ async function recursivelyBundleSite(startUrl, outputFile, maxDepth = 1) {
   }
 }
 
+// src/core/parser.ts
+import { readFile as readFile2 } from "fs/promises";
+import * as cheerio2 from "cheerio";
+async function parseHTML(entryFilePath, logger) {
+  logger?.debug(`Parsing HTML file: ${entryFilePath}`);
+  let htmlContent;
+  try {
+    htmlContent = await readFile2(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 };
+}
+
 // src/utils/meta.ts
 var BuildTimer = class {
   startTime;
@@ -1284,122 +1402,84 @@ var BuildTimer = class {
 };
 
 // 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}`);
-    throw error;
-  }
-}
-function bundleMultiPageHTML2(pages, options = {}, loggerInstance) {
-  const logger = loggerInstance || new Logger(options.logLevel);
-  logger.info(`Bundling ${pages.length} provided pages into multi-page HTML...`);
-  try {
-    const bundledHtml = bundleMultiPageHTML(pages, logger);
-    logger.info(`Multi-page bundling complete.`);
-    return bundledHtml;
-  } catch (error) {
-    logger.error(`Error during multi-page bundling: ${error.message}`);
+    logger.error(`Error during recursive bundle for ${url}: ${error.message}`);
     throw error;
   }
 }
 export {
-  LogLevel,
-  bundleMultiPageHTML2 as bundleMultiPageHTML,
-  fetchAndPackWebPage2 as fetchAndPackWebPage,
+  Logger,
+  bundleMultiPageHTML,
   generatePortableHTML,
-  generateRecursivePortableHTML
+  generateRecursivePortableHTML,
+  pack
 };
 //# sourceMappingURL=index.js.map