portapack 0.2.1

package/dist/index.js

@@ -0,0 +1,1405 @@
+// src/core/parser.ts
+import { readFile } from "fs/promises";
+import * as cheerio from "cheerio";
+
+// src/utils/mime.ts
+import path from "path";
+var MIME_MAP = {
+  // CSS
+  ".css": { mime: "text/css", assetType: "css" },
+  // JavaScript
+  ".js": { mime: "application/javascript", assetType: "js" },
+  ".mjs": { mime: "application/javascript", assetType: "js" },
+  // Images
+  ".png": { mime: "image/png", assetType: "image" },
+  ".jpg": { mime: "image/jpeg", assetType: "image" },
+  ".jpeg": { mime: "image/jpeg", assetType: "image" },
+  ".gif": { mime: "image/gif", assetType: "image" },
+  ".svg": { mime: "image/svg+xml", assetType: "image" },
+  ".webp": { mime: "image/webp", assetType: "image" },
+  ".ico": { mime: "image/x-icon", assetType: "image" },
+  ".avif": { mime: "image/avif", assetType: "image" },
+  // Fonts
+  ".woff": { mime: "font/woff", assetType: "font" },
+  ".woff2": { mime: "font/woff2", assetType: "font" },
+  ".ttf": { mime: "font/ttf", assetType: "font" },
+  ".otf": { mime: "font/otf", assetType: "font" },
+  ".eot": { mime: "application/vnd.ms-fontobject", assetType: "font" },
+  // Audio/Video (add more as needed)
+  ".mp3": { mime: "audio/mpeg", assetType: "other" },
+  ".ogg": { mime: "audio/ogg", assetType: "other" },
+  ".wav": { mime: "audio/wav", assetType: "other" },
+  ".mp4": { mime: "video/mp4", assetType: "other" },
+  ".webm": { mime: "video/webm", assetType: "other" },
+  // Other common web types
+  ".json": { mime: "application/json", assetType: "other" },
+  ".webmanifest": { mime: "application/manifest+json", assetType: "other" },
+  ".xml": { mime: "application/xml", assetType: "other" },
+  ".html": { mime: "text/html", assetType: "other" },
+  // Usually not needed as asset, but for completeness
+  ".txt": { mime: "text/plain", assetType: "other" }
+};
+var DEFAULT_MIME_TYPE = {
+  mime: "application/octet-stream",
+  assetType: "other"
+  // Explicit cast needed
+};
+function guessMimeType(urlOrPath) {
+  if (!urlOrPath) {
+    return DEFAULT_MIME_TYPE;
+  }
+  let ext = "";
+  try {
+    const parsedUrl = new URL(urlOrPath);
+    ext = path.extname(parsedUrl.pathname).toLowerCase();
+  } catch {
+    ext = path.extname(urlOrPath).toLowerCase();
+  }
+  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;
+function isUtf8DecodingLossy(originalBuffer, decodedString) {
+  try {
+    const reEncodedBuffer = Buffer.from(decodedString, "utf-8");
+    return !originalBuffer.equals(reEncodedBuffer);
+  } catch (e) {
+    return true;
+  }
+}
+function determineBaseUrl(inputPathOrUrl, logger) {
+  logger?.debug(`Determining base URL for input: ${inputPathOrUrl}`);
+  if (!inputPathOrUrl) {
+    logger?.warn("Cannot determine base URL: inputPathOrUrl is empty or invalid.");
+    return void 0;
+  }
+  try {
+    if (/^https?:\/\//i.test(inputPathOrUrl)) {
+      const url = new URL2(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}`);
+      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.`);
+      return void 0;
+    } else {
+      let absolutePath;
+      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;
+        }
+      } 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.`);
+        }
+        isDirectory = false;
+      }
+      const dirPath = isDirectory ? absolutePath : path2.dirname(absolutePath);
+      let normalizedPathForURL = dirPath.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 += "/";
+      }
+      logger?.debug(`Determined local base URL: ${fileUrlString} (from: ${inputPathOrUrl}, resolved dir: ${dirPath}, isDir: ${isDirectory})`);
+      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}` : ""}`);
+    return void 0;
+  }
+}
+function resolveAssetUrl(assetUrl, baseContextUrl, logger) {
+  const trimmedUrl = assetUrl?.trim();
+  if (!trimmedUrl || trimmedUrl.startsWith("data:") || trimmedUrl.startsWith("#")) {
+    return null;
+  }
+  let resolvableUrl = trimmedUrl;
+  if (resolvableUrl.startsWith("//") && baseContextUrl) {
+    try {
+      const base = new URL2(baseContextUrl);
+      resolvableUrl = base.protocol + resolvableUrl;
+    } catch (e) {
+      logger?.warn(`Could not extract protocol from base "${baseContextUrl}" for protocol-relative URL "${trimmedUrl}". Skipping.`);
+      return null;
+    }
+  }
+  try {
+    const resolved = new URL2(resolvableUrl, baseContextUrl);
+    return resolved;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (!/^[a-z]+:/i.test(resolvableUrl) && !resolvableUrl.startsWith("/") && !baseContextUrl) {
+      logger?.warn(`Cannot resolve relative URL "${resolvableUrl}" - Base context URL was not provided or determined.`);
+    } else {
+      logger?.warn(`\u26A0\uFE0F Failed to parse/resolve URL "${resolvableUrl}" ${baseContextUrl ? 'against base "' + baseContextUrl + '"' : "(no base provided)"}: ${message}`);
+    }
+    return null;
+  }
+}
+function resolveCssRelativeUrl(relativeUrl, cssBaseContextUrl, logger) {
+  if (!relativeUrl || relativeUrl.startsWith("data:")) {
+    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;
+    }
+  } catch (error) {
+    logger?.warn(
+      `Failed to resolve CSS URL: "${relativeUrl}" against "${cssBaseContextUrl}": ${String(error)}`
+    );
+    return null;
+  }
+}
+async function fetchAsset(resolvedUrl, logger, timeout = 1e4) {
+  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, {
+        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)`);
+      return Buffer.from(response.data);
+    } else if (protocol === "file:") {
+      let filePath;
+      try {
+        filePath = fileURLToPath(resolvedUrl);
+      } catch (e) {
+        logger?.error(`Could not convert file URL to path: ${resolvedUrl.href}. Error: ${e.message}`);
+        return null;
+      }
+      const data = await readFile2(filePath);
+      logger?.debug(`Read local file ${filePath} (${data.byteLength} bytes)`);
+      return data;
+    } else {
+      logger?.warn(`Unsupported protocol "${protocol}" in URL: ${resolvedUrl.href}`);
+      return null;
+    }
+  } catch (error) {
+    if ((protocol === "http:" || protocol === "https:") && axios.default.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:") {
+      let failedPath = resolvedUrl.href;
+      try {
+        failedPath = fileURLToPath(resolvedUrl);
+      } catch {
+      }
+      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}.`);
+      } else if (error instanceof Error) {
+        logger?.warn(`\u26A0\uFE0F Failed to read local asset ${failedPath}: ${error.message}`);
+      } else {
+        logger?.warn(`\u26A0\uFE0F An unknown error occurred while reading local asset ${failedPath}: ${String(error)}`);
+      }
+    } else if (error instanceof Error) {
+      logger?.warn(`\u26A0\uFE0F An unexpected error occurred processing asset ${resolvedUrl.href}: ${error.message}`);
+    } else {
+      logger?.warn(`\u26A0\uFE0F An unknown and unexpected error occurred processing asset ${resolvedUrl.href}: ${String(error)}`);
+    }
+    return null;
+  }
+}
+function extractUrlsFromCSS(cssContent, cssBaseContextUrl, logger) {
+  const newlyDiscovered = [];
+  const processedInThisParse = /* @__PURE__ */ new Set();
+  const urlRegex = /url\(\s*(['"]?)(.*?)\1\s*\)/gi;
+  const importRegex = /@import\s+(?:url\(\s*(['"]?)(.*?)\1\s*\)|(['"])(.*?)\3)\s*;/gi;
+  const processFoundUrl = (rawUrl, ruleType) => {
+    if (!rawUrl || rawUrl.trim() === "" || rawUrl.startsWith("data:")) return;
+    const resolvedUrl = resolveCssRelativeUrl(rawUrl, cssBaseContextUrl, logger);
+    if (resolvedUrl && !processedInThisParse.has(resolvedUrl)) {
+      processedInThisParse.add(resolvedUrl);
+      const { assetType } = guessMimeType(resolvedUrl);
+      newlyDiscovered.push({
+        type: assetType,
+        url: resolvedUrl,
+        // The resolved URL string
+        content: void 0
+      });
+      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()");
+  }
+  importRegex.lastIndex = 0;
+  while ((match = importRegex.exec(cssContent)) !== null) {
+    processFoundUrl(match[2] || match[4], "@import");
+  }
+  return newlyDiscovered;
+}
+async function extractAssets(parsed, embedAssets = true, inputPathOrUrl, logger) {
+  logger?.info(`\u{1F680} Starting asset extraction! Embed: ${embedAssets}. Input: ${inputPathOrUrl || "(HTML content only)"}`);
+  const initialAssets = parsed.assets || [];
+  const finalAssetsMap = /* @__PURE__ */ new Map();
+  let assetsToProcess = [];
+  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 (!urlToQueue.startsWith("data:") && !processedOrQueuedUrls.has(urlToQueue)) {
+      processedOrQueuedUrls.add(urlToQueue);
+      const { assetType: guessedType } = guessMimeType(urlToQueue);
+      const initialType = asset.type ?? guessedType;
+      assetsToProcess.push({
+        url: urlToQueue,
+        type: initialType,
+        content: void 0
+      });
+      logger?.debug(` -> Queued initial asset: ${urlToQueue} (Original raw: ${asset.url})`);
+    } else if (urlToQueue.startsWith("data:")) {
+      logger?.debug(` -> Skipping data URI: ${urlToQueue.substring(0, 50)}...`);
+    } else {
+      logger?.debug(` -> Skipping already queued initial asset: ${urlToQueue}`);
+    }
+  }
+  let iterationCount = 0;
+  while (assetsToProcess.length > 0) {
+    iterationCount++;
+    if (iterationCount > MAX_ASSET_EXTRACTION_ITERATIONS) {
+      logger?.error(`\u{1F6D1} Asset extraction loop limit hit (${MAX_ASSET_EXTRACTION_ITERATIONS})! Aborting.`);
+      const remainingUrls = assetsToProcess.map((a) => a.url).slice(0, 10).join(", ");
+      logger?.error(`Remaining queue sample (${assetsToProcess.length} items): ${remainingUrls}...`);
+      assetsToProcess.forEach((asset) => {
+        if (!finalAssetsMap.has(asset.url)) {
+          finalAssetsMap.set(asset.url, { ...asset, content: void 0 });
+        }
+      });
+      assetsToProcess = [];
+      break;
+    }
+    const currentBatch = [...assetsToProcess];
+    assetsToProcess = [];
+    logger?.debug(`--- Processing batch ${iterationCount}: ${currentBatch.length} asset(s) ---`);
+    for (const asset of currentBatch) {
+      if (finalAssetsMap.has(asset.url)) {
+        logger?.debug(`Skipping asset already in final map: ${asset.url}`);
+        continue;
+      }
+      let assetContentBuffer = null;
+      let finalContent = void 0;
+      let cssContentForParsing = void 0;
+      const needsFetching = embedAssets || asset.type === "css";
+      let assetUrlObj = null;
+      if (needsFetching) {
+        try {
+          assetUrlObj = new URL2(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 });
+          continue;
+        }
+        if (assetUrlObj) {
+          assetContentBuffer = await fetchAsset(assetUrlObj, logger);
+        }
+      }
+      if (needsFetching && assetContentBuffer === null) {
+        logger?.debug(`Storing asset ${asset.url} without content due to fetch failure.`);
+        finalAssetsMap.set(asset.url, { ...asset, content: void 0 });
+        continue;
+      }
+      if (assetContentBuffer) {
+        const mimeInfo = guessMimeType(asset.url);
+        const effectiveMime = mimeInfo.mime || "application/octet-stream";
+        if (TEXT_ASSET_TYPES.has(asset.type)) {
+          let textContent;
+          let wasLossy = false;
+          try {
+            textContent = assetContentBuffer.toString("utf-8");
+            wasLossy = isUtf8DecodingLossy(assetContentBuffer, textContent);
+          } catch (e) {
+            textContent = void 0;
+            wasLossy = true;
+          }
+          if (!wasLossy && textContent !== void 0) {
+            if (embedAssets) {
+              finalContent = textContent;
+            } else {
+              finalContent = void 0;
+            }
+            if (asset.type === "css") {
+              cssContentForParsing = textContent;
+            }
+          } else {
+            logger?.warn(`Could not decode ${asset.type} ${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")}`;
+            } else {
+              finalContent = void 0;
+            }
+          }
+        } else if (BINARY_ASSET_TYPES.has(asset.type)) {
+          if (embedAssets) {
+            finalContent = `data:${effectiveMime};base64,${assetContentBuffer.toString("base64")}`;
+          } else {
+            finalContent = void 0;
+          }
+          cssContentForParsing = void 0;
+        } else {
+          cssContentForParsing = void 0;
+          if (embedAssets) {
+            try {
+              const attemptedTextContent = assetContentBuffer.toString("utf-8");
+              if (isUtf8DecodingLossy(assetContentBuffer, attemptedTextContent)) {
+                logger?.warn(`Couldn't embed unclassified asset ${asset.url} as text due to invalid UTF-8 sequences. Falling back to base64 (octet-stream).`);
+                finalContent = `data:application/octet-stream;base64,${assetContentBuffer.toString("base64")}`;
+              } else {
+                finalContent = attemptedTextContent;
+                logger?.debug(`Successfully embedded unclassified asset ${asset.url} as text.`);
+              }
+            } catch (decodeError) {
+              logger?.warn(`Error during text decoding for unclassified asset ${asset.url}: ${decodeError instanceof Error ? decodeError.message : String(decodeError)}. Falling back to base64.`);
+              finalContent = `data:application/octet-stream;base64,${assetContentBuffer.toString("base64")}`;
+            }
+          } else {
+            finalContent = void 0;
+          }
+        }
+      } else {
+        finalContent = void 0;
+        cssContentForParsing = void 0;
+      }
+      finalAssetsMap.set(asset.url, { ...asset, url: asset.url, content: finalContent });
+      if (asset.type === "css" && cssContentForParsing) {
+        const cssBaseContextUrl = determineBaseUrl(asset.url, logger);
+        logger?.debug(`CSS base context for resolving nested assets within ${asset.url}: ${cssBaseContextUrl}`);
+        if (cssBaseContextUrl) {
+          const newlyDiscoveredAssets = extractUrlsFromCSS(
+            cssContentForParsing,
+            cssBaseContextUrl,
+            logger
+          );
+          if (newlyDiscoveredAssets.length > 0) {
+            logger?.debug(`Discovered ${newlyDiscoveredAssets.length} nested assets in CSS ${asset.url}. Checking against queue...`);
+            for (const newAsset of newlyDiscoveredAssets) {
+              if (!processedOrQueuedUrls.has(newAsset.url)) {
+                processedOrQueuedUrls.add(newAsset.url);
+                assetsToProcess.push(newAsset);
+                logger?.debug(` -> Queued new nested asset: ${newAsset.url}`);
+              } else {
+                logger?.debug(` -> Skipping already processed/queued nested asset: ${newAsset.url}`);
+              }
+            }
+          }
+        } else {
+          logger?.warn(`Could not determine base URL context for CSS file ${asset.url}. Cannot resolve nested relative paths within it.`);
+        }
+      }
+    }
+  }
+  const finalIterationCount = iterationCount > MAX_ASSET_EXTRACTION_ITERATIONS ? "MAX+" : iterationCount;
+  logger?.info(`\u2705 Asset extraction COMPLETE! Found ${finalAssetsMap.size} unique assets in ${finalIterationCount} iterations.`);
+  return {
+    htmlContent: parsed.htmlContent,
+    assets: Array.from(finalAssetsMap.values())
+  };
+}
+
+// src/core/minifier.ts
+import { minify as htmlMinify } from "html-minifier-terser";
+import CleanCSS from "clean-css";
+import { minify as jsMinify } from "terser";
+var HTML_MINIFY_OPTIONS = {
+  collapseWhitespace: true,
+  removeComments: true,
+  conservativeCollapse: true,
+  minifyCSS: false,
+  // Handled separately
+  minifyJS: false,
+  // Handled separately
+  removeAttributeQuotes: false,
+  removeRedundantAttributes: true,
+  removeScriptTypeAttributes: true,
+  removeStyleLinkTypeAttributes: true,
+  useShortDoctype: true
+};
+var CSS_MINIFY_OPTIONS = {
+  returnPromise: false,
+  // <<< *** Ensures sync operation at runtime ***
+  level: {
+    1: {
+      // Level 1 optimizations (safe transformations)
+      optimizeBackground: true,
+      optimizeBorderRadius: true,
+      optimizeFilter: true,
+      optimizeFontWeight: true,
+      optimizeOutline: true
+    },
+    2: {
+      // Level 2 optimizations (structural changes, generally safe)
+      mergeMedia: true,
+      mergeNonAdjacentRules: true,
+      removeDuplicateFontRules: true,
+      removeDuplicateMediaBlocks: true,
+      removeDuplicateRules: true,
+      restructureRules: true
+    }
+  }
+  // Note: Type checking based on these options seems problematic with current @types/clean-css
+};
+var JS_MINIFY_OPTIONS = {
+  compress: {
+    dead_code: true,
+    drop_console: false,
+    drop_debugger: true,
+    ecma: 2020,
+    keep_classnames: true,
+    keep_fnames: true
+  },
+  mangle: {
+    keep_classnames: true,
+    keep_fnames: true
+  },
+  format: { comments: false }
+};
+async function minifyAssets(parsed, options = {}, logger) {
+  const { htmlContent, assets } = parsed;
+  const currentHtmlContent = htmlContent ?? "";
+  const currentAssets = assets ?? [];
+  if (!currentHtmlContent && currentAssets.length === 0) {
+    logger?.debug("Minification skipped: No content.");
+    return { htmlContent: currentHtmlContent, assets: currentAssets };
+  }
+  const minifyFlags = {
+    minifyHtml: options.minifyHtml !== false,
+    minifyCss: options.minifyCss !== false,
+    minifyJs: options.minifyJs !== false
+  };
+  logger?.debug(`Minification flags: ${JSON.stringify(minifyFlags)}`);
+  const minifiedAssets = await Promise.all(
+    currentAssets.map(async (asset) => {
+      let processedAsset = { ...asset };
+      if (typeof processedAsset.content !== "string" || processedAsset.content.length === 0) {
+        return processedAsset;
+      }
+      let newContent = processedAsset.content;
+      const assetIdentifier = processedAsset.url || `inline ${processedAsset.type}`;
+      try {
+        if (minifyFlags.minifyCss && processedAsset.type === "css") {
+          logger?.debug(`Minifying CSS: ${assetIdentifier}`);
+          const cssMinifier = new CleanCSS(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(", ")}`);
+          } else {
+            if (result.warnings && result.warnings.length > 0) {
+              logger?.debug(`CleanCSS warnings for ${assetIdentifier}: ${result.warnings.join(", ")}`);
+            }
+            if (result.styles) {
+              newContent = result.styles;
+              logger?.debug(`CSS minified successfully: ${assetIdentifier}`);
+            } else {
+              logger?.warn(`\u26A0\uFE0F CleanCSS produced no styles but reported no errors for ${assetIdentifier}. Keeping original.`);
+            }
+          }
+        }
+        if (minifyFlags.minifyJs && processedAsset.type === "js") {
+          logger?.debug(`Minifying JS: ${assetIdentifier}`);
+          const result = await jsMinify(processedAsset.content, JS_MINIFY_OPTIONS);
+          if (result.code) {
+            newContent = result.code;
+            logger?.debug(`JS minified successfully: ${assetIdentifier}`);
+          } else {
+            const terserError = result.error;
+            if (terserError) {
+              logger?.warn(`\u26A0\uFE0F Terser failed for ${assetIdentifier}: ${terserError.message || terserError}`);
+            } else {
+              logger?.warn(`\u26A0\uFE0F Terser produced no code but reported no errors for ${assetIdentifier}. Keeping original.`);
+            }
+          }
+        }
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : String(err);
+        logger?.warn(`\u26A0\uFE0F Failed to minify asset ${assetIdentifier} (${processedAsset.type}): ${errorMessage}`);
+      }
+      processedAsset.content = newContent;
+      return processedAsset;
+    })
+  );
+  let finalHtml = currentHtmlContent;
+  if (minifyFlags.minifyHtml && finalHtml.length > 0) {
+    logger?.debug("Minifying HTML content...");
+    try {
+      finalHtml = await htmlMinify(finalHtml, {
+        ...HTML_MINIFY_OPTIONS,
+        minifyCSS: minifyFlags.minifyCss,
+        minifyJS: minifyFlags.minifyJs
+      });
+      logger?.debug("HTML minified successfully.");
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      logger?.warn(`\u26A0\uFE0F HTML minification failed: ${errorMessage}`);
+    }
+  } else if (finalHtml.length > 0) {
+    logger?.debug("HTML minification skipped (disabled).");
+  }
+  return {
+    htmlContent: finalHtml,
+    assets: minifiedAssets
+    // The array of processed asset copies
+  };
+}
+
+// src/core/packer.ts
+import * as cheerio2 from "cheerio";
+function escapeScriptContent(code) {
+  return code.replace(/<\/(script)/gi, "<\\/$1");
+}
+function ensureBaseTag($, logger) {
+  let head = $("head");
+  if (head.length === 0) {
+    logger?.debug("No <head> tag found. Creating <head> and ensuring <html> exists.");
+    let htmlElement = $("html");
+    if (htmlElement.length === 0) {
+      logger?.debug("No <html> tag found. Wrapping content in <html><body>...");
+      const bodyContent = $.root().html() || "";
+      $.root().empty();
+      htmlElement = $("<html>").appendTo($.root());
+      head = $("<head>").appendTo(htmlElement);
+      $("<body>").html(bodyContent).appendTo(htmlElement);
+    } else {
+      head = $("<head>").prependTo(htmlElement);
+    }
+  }
+  if (head && head.length > 0 && head.find("base[href]").length === 0) {
+    logger?.debug('Prepending <base href="./"> to <head>.');
+    head.prepend('<base href="./">');
+  }
+}
+function inlineAssets($, assets, logger) {
+  logger?.debug(`Inlining ${assets.filter((a) => a.content).length} assets with content...`);
+  const assetMap = new Map(assets.map((asset) => [asset.url, asset]));
+  $('link[rel="stylesheet"][href]').each((_, el) => {
+    const link = $(el);
+    const href = link.attr("href");
+    const asset = href ? assetMap.get(href) : void 0;
+    if (asset?.content && typeof asset.content === "string") {
+      if (asset.content.startsWith("data:")) {
+        logger?.debug(`Replacing link with style tag using existing data URI: ${asset.url}`);
+        const styleTag = $("<style>").text(`@import url("${asset.content}");`);
+        link.replaceWith(styleTag);
+      } else {
+        logger?.debug(`Inlining CSS: ${asset.url}`);
+        const styleTag = $("<style>").text(asset.content);
+        link.replaceWith(styleTag);
+      }
+    } else if (href) {
+      logger?.warn(`Could not inline CSS: ${href}. Content missing or invalid.`);
+    }
+  });
+  $("script[src]").each((_, el) => {
+    const script = $(el);
+    const src = script.attr("src");
+    const asset = src ? assetMap.get(src) : void 0;
+    if (asset?.content && typeof asset.content === "string") {
+      logger?.debug(`Inlining JS: ${asset.url}`);
+      const inlineScript = $("<script>");
+      inlineScript.text(escapeScriptContent(asset.content));
+      Object.entries(script.attr() || {}).forEach(([key, value]) => {
+        if (key.toLowerCase() !== "src") inlineScript.attr(key, value);
+      });
+      script.replaceWith(inlineScript);
+    } else if (src) {
+      logger?.warn(`Could not inline JS: ${src}. Content missing or not string.`);
+    }
+  });
+  $('img[src], video[poster], input[type="image"][src]').each((_, el) => {
+    const element = $(el);
+    const srcAttr = element.is("video") ? "poster" : "src";
+    const src = element.attr(srcAttr);
+    const asset = src ? assetMap.get(src) : void 0;
+    if (asset?.content && typeof asset.content === "string" && asset.content.startsWith("data:")) {
+      logger?.debug(`Inlining image via ${srcAttr}: ${asset.url}`);
+      element.attr(srcAttr, asset.content);
+    } else if (src) {
+      logger?.warn(`Could not inline image via ${srcAttr}: ${src}. Content missing or not a data URI.`);
+    }
+  });
+  $("img[srcset], source[srcset]").each((_, el) => {
+    const element = $(el);
+    const srcset = element.attr("srcset");
+    if (!srcset) return;
+    const newSrcsetParts = [];
+    let changed = false;
+    srcset.split(",").forEach((part) => {
+      const trimmedPart = part.trim();
+      const [url, descriptor] = trimmedPart.split(/\s+/, 2);
+      const asset = url ? assetMap.get(url) : void 0;
+      if (asset?.content && typeof asset.content === "string" && asset.content.startsWith("data:")) {
+        newSrcsetParts.push(`${asset.content}${descriptor ? " " + descriptor : ""}`);
+        changed = true;
+      } else {
+        newSrcsetParts.push(trimmedPart);
+      }
+    });
+    if (changed) {
+      element.attr("srcset", newSrcsetParts.join(", "));
+    }
+  });
+  $("video[src], audio[src], video > source[src], audio > source[src]").each((_, el) => {
+    const element = $(el);
+    const src = element.attr("src");
+    const asset = src ? assetMap.get(src) : void 0;
+    if (asset?.content && typeof asset.content === "string" && asset.content.startsWith("data:")) {
+      logger?.debug(`Inlining media source: ${asset.url}`);
+      element.attr("src", asset.content);
+    }
+  });
+  logger?.debug("Asset inlining process complete.");
+}
+function packHTML(parsed, logger) {
+  const { htmlContent, assets } = parsed;
+  if (!htmlContent || typeof htmlContent !== "string") {
+    logger?.warn("Packer received empty or invalid htmlContent. Returning minimal HTML shell.");
+    return '<!DOCTYPE html><html><head><base href="./"></head><body></body></html>';
+  }
+  logger?.debug("Loading HTML content into Cheerio for packing...");
+  const $ = cheerio2.load(htmlContent);
+  logger?.debug("Ensuring <base> tag exists...");
+  ensureBaseTag($, logger);
+  logger?.debug("Starting asset inlining...");
+  inlineAssets($, assets, logger);
+  logger?.debug("Generating final packed HTML string...");
+  const finalHtml = $.html();
+  logger?.debug(`Packing complete. Final size: ${Buffer.byteLength(finalHtml)} bytes.`);
+  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";
+  let cleaned = url.trim();
+  let pathAndSearch = "";
+  try {
+    const urlObj = new URL(url, "https://placeholder.base");
+    pathAndSearch = (urlObj.pathname ?? "") + (urlObj.search ?? "");
+  } catch {
+    pathAndSearch = cleaned.split("#")[0];
+  }
+  try {
+    cleaned = decodeURIComponent(pathAndSearch);
+  } catch (e) {
+    cleaned = pathAndSearch;
+  }
+  cleaned = cleaned.replace(/\.(html?|php|aspx?|jsp)$/i, "").replace(/[\s/?=&\\]+/g, "-").replace(/[^\w._-]+/g, "").replace(/-+/g, "-").replace(/^-+|-+$/g, "").toLowerCase();
+  return cleaned || "index";
+}
+function sanitizeSlug(rawUrl) {
+  return slugify(rawUrl);
+}
+
+// src/core/bundler.ts
+function bundleMultiPageHTML(pages, logger) {
+  if (!Array.isArray(pages)) {
+    const errorMsg = "Input pages must be an array of PageEntry objects";
+    logger?.error(errorMsg);
+    throw new Error(errorMsg);
+  }
+  logger?.info(`Bundling ${pages.length} pages into a multi-page HTML document.`);
+  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");
+    return isValid;
+  });
+  if (validPages.length === 0) {
+    const errorMsg = "No valid page entries found in input array";
+    logger?.error(errorMsg);
+    throw new Error(errorMsg);
+  }
+  const slugMap = /* @__PURE__ */ new Map();
+  const usedSlugs = /* @__PURE__ */ new Set();
+  for (const page of validPages) {
+    const baseSlug = sanitizeSlug(page.url);
+    let slug = baseSlug;
+    let counter = 1;
+    while (usedSlugs.has(slug)) {
+      slug = `${baseSlug}-${counter++}`;
+      logger?.warn(`Slug collision detected for "${page.url}". Using "${slug}" instead.`);
+    }
+    usedSlugs.add(slug);
+    slugMap.set(page.url, slug);
+  }
+  const defaultPageSlug = slugMap.get(validPages[0].url);
+  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>
+</head>
+<body>
+    <nav id="main-nav">
+        ${validPages.map((p) => {
+    const slug = slugMap.get(p.url);
+    const label = p.url.split("/").pop()?.split(".")[0] || "Page";
+    return `<a href="#${slug}" data-page="${slug}">${label}</a>`;
+  }).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")}
+    <script id="router-script">
+        document.addEventListener('DOMContentLoaded', function() {
+            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 (window.location.hash.substring(1) !== slug) {
+                    history.pushState(null, '', '#' + slug);
+                }
+            }
+
+            window.addEventListener('hashchange', () => {
+                const slug = window.location.hash.substring(1);
+                if (document.getElementById('page-' + slug)) navigateTo(slug);
+            });
+
+            document.querySelectorAll('#main-nav a').forEach(link => {
+                link.addEventListener('click', function(e) {
+                    e.preventDefault();
+                    const slug = this.getAttribute('data-page');
+                    navigateTo(slug);
+                });
+            });
+
+            const initial = window.location.hash.substring(1);
+            navigateTo(document.getElementById('page-' + initial) ? initial : '${defaultPageSlug}');
+        });
+    </script>
+</body>
+</html>`;
+  logger?.info(`Multi-page bundle generated. Size: ${Buffer.byteLength(output, "utf-8")} bytes.`);
+  return output;
+}
+
+// src/core/web-fetcher.ts
+async function fetchAndPackWebPage(url, logger, timeout = 3e4) {
+  let browser = null;
+  const start = Date.now();
+  logger?.debug(`Initiating fetch for single page: ${url}`);
+  try {
+    browser = await puppeteer.launch({ headless: true });
+    logger?.debug(`Browser launched for ${url}`);
+    const page = await browser.newPage();
+    logger?.debug(`Page created for ${url}`);
+    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}`);
+      const metadata = {
+        input: url,
+        outputSize: Buffer.byteLength(html, "utf-8"),
+        assetCount: 0,
+        // Basic fetch doesn't track assets
+        buildTimeMs: Date.now() - start,
+        errors: []
+        // No errors if we reached this point
+      };
+      await page.close();
+      logger?.debug(`Page closed for ${url}`);
+      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;
+      }
+      throw pageError;
+    }
+  } catch (launchError) {
+    logger?.error(`Critical error during browser launch or page creation for ${url}: ${launchError.message}`);
+    if (browser) {
+      try {
+        await browser.close();
+      } catch (closeErr) {
+      }
+    }
+    throw launchError;
+  } finally {
+    if (browser) {
+      logger?.warn(`Closing browser in final cleanup for ${url}. This might indicate an unusual error path.`);
+      try {
+        await browser.close();
+      } catch (closeErr) {
+      }
+    }
+  }
+}
+async function crawlWebsite(startUrl, maxDepth, logger) {
+  logger?.info(`Starting crawl for ${startUrl} with maxDepth ${maxDepth}`);
+  if (maxDepth <= 0) {
+    logger?.info("maxDepth is 0 or negative, no pages will be crawled.");
+    return [];
+  }
+  const browser = await puppeteer.launch({ headless: true });
+  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 {
+          }
+        }
+        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}`);
+        }
+      }
+    }
+  }
+  logger?.info(`Crawl finished. Closing browser.`);
+  await browser.close();
+  logger?.info(`Found ${results.length} pages.`);
+  return results;
+}
+async function recursivelyBundleSite(startUrl, outputFile, maxDepth = 1) {
+  const logger = new Logger();
+  logger.info(`Starting recursive site bundle for ${startUrl} to ${outputFile} (maxDepth: ${maxDepth})`);
+  try {
+    const pages = await crawlWebsite(startUrl, maxDepth, logger);
+    if (pages.length === 0) {
+      logger.warn("Crawl completed but found 0 pages. Output file may be empty or reflect an empty bundle.");
+    } else {
+      logger.info(`Crawl successful, found ${pages.length} pages. Starting bundling.`);
+    }
+    const bundledHtml = bundleMultiPageHTML(pages, logger);
+    logger.info(`Bundling complete. Output size: ${Buffer.byteLength(bundledHtml, "utf-8")} bytes.`);
+    logger.info(`Writing bundled HTML to ${outputFile}`);
+    await fs2.writeFile(outputFile, bundledHtml, "utf-8");
+    logger.info(`Successfully wrote bundled output to ${outputFile}`);
+    return {
+      pages: pages.length,
+      html: bundledHtml
+    };
+  } catch (error) {
+    logger.error(`Error during recursive site bundle: ${error.message}`);
+    if (error.stack) {
+      logger.error(`Stack trace: ${error.stack}`);
+    }
+    throw error;
+  }
+}
+
+// src/utils/meta.ts
+var BuildTimer = class {
+  startTime;
+  input;
+  pagesBundled;
+  // Tracks pages for recursive bundles
+  assetCount = 0;
+  // Tracks discovered/processed assets
+  errors = [];
+  // Collects warnings/errors
+  /**
+   * Creates and starts a build timer session for a given input.
+   *
+   * @param {string} input - The source file path or URL being processed.
+   */
+  constructor(input) {
+    this.startTime = Date.now();
+    this.input = input;
+  }
+  /**
+   * Explicitly sets the number of assets discovered or processed.
+   * This might be called after asset extraction/minification.
+   *
+   * @param {number} count - The total number of assets.
+   */
+  setAssetCount(count) {
+    this.assetCount = count;
+  }
+  /**
+   * Records a warning or error message encountered during the build.
+   * These are added to the final metadata.
+   *
+   * @param {string} message - The warning or error description.
+   */
+  addError(message) {
+    this.errors.push(message);
+  }
+  /**
+   * Sets the number of pages bundled, typically used in multi-page
+   * or recursive bundling scenarios.
+   *
+   * @param {number} count - The number of HTML pages included in the bundle.
+   */
+  setPageCount(count) {
+    this.pagesBundled = count;
+  }
+  /**
+   * Stops the timer, calculates final metrics, and returns the complete
+   * BundleMetadata object. Merges any explicitly provided metadata
+   * (like assetCount calculated elsewhere) with the timer's tracked data.
+   *
+   * @param {string} finalHtml - The final generated HTML string, used to calculate output size.
+   * @param {Partial<BundleMetadata>} [extra] - Optional object containing metadata fields
+   * (like assetCount or pre-calculated errors) that should override the timer's internal values.
+   * @returns {BundleMetadata} The finalized metadata object for the build process.
+   */
+  finish(html, extra) {
+    const buildTimeMs = Date.now() - this.startTime;
+    const outputSize = Buffer.byteLength(html || "", "utf-8");
+    const combinedErrors = Array.from(/* @__PURE__ */ new Set([...this.errors, ...extra?.errors ?? []]));
+    const finalMetadata = {
+      input: this.input,
+      outputSize,
+      buildTimeMs,
+      assetCount: extra?.assetCount ?? this.assetCount,
+      pagesBundled: extra?.pagesBundled ?? this.pagesBundled,
+      // Assign the combined errors array
+      errors: combinedErrors
+    };
+    if (finalMetadata.pagesBundled === void 0) {
+      delete finalMetadata.pagesBundled;
+    }
+    if (finalMetadata.errors?.length === 0) {
+      delete finalMetadata.errors;
+    }
+    return finalMetadata;
+  }
+};
+
+// src/index.ts
+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...`);
+    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;
+    } catch (error) {
+      logger.error(`Failed to fetch remote URL ${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}`);
+  try {
+    const parsed = await parseHTML(input, logger);
+    const enriched = await extractAssets(parsed, options.embedAssets ?? true, basePath, 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.`);
+    }
+    return { html: finalHtml, metadata };
+  } catch (error) {
+    logger.error(`Error during local processing for ${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 internalOutputPathPlaceholder = `${new URL(url).hostname}_recursive.html`;
+  try {
+    const { html, pages } = await recursivelyBundleSite(url, internalOutputPathPlaceholder, depth);
+    logger.info(`Recursive crawl complete. Discovered and bundled ${pages} pages.`);
+    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.`);
+    }
+    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}`);
+    throw error;
+  }
+}
+export {
+  LogLevel,
+  bundleMultiPageHTML2 as bundleMultiPageHTML,
+  fetchAndPackWebPage2 as fetchAndPackWebPage,
+  generatePortableHTML,
+  generateRecursivePortableHTML
+};
+//# sourceMappingURL=index.js.map