portapack 0.2.1

package/dist/cli/cli-entry.js

@@ -0,0 +1,1694 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/types.ts
+var LogLevel;
+var init_types = __esm({
+  "src/types.ts"() {
+    "use strict";
+    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/cli/options.ts
+import { Command, Option } from "commander";
+function parseRecursiveValue(val) {
+  if (val === void 0) return true;
+  const parsed = parseInt(val, 10);
+  return isNaN(parsed) || parsed < 0 ? true : parsed;
+}
+function parseOptions(argv = process.argv) {
+  const program = new Command();
+  program.name("portapack").version("0.0.0").description("\u{1F4E6} Bundle HTML and its dependencies into a portable file").argument("[input]", "Input HTML file or URL").option("-o, --output <file>", "Output file path").option("-m, --minify", "Enable all minification (HTML, CSS, JS)").option("--no-minify", "Disable all minification").option("--no-minify-html", "Disable HTML minification").option("--no-minify-css", "Disable CSS minification").option("--no-minify-js", "Disable JavaScript minification").option("-e, --embed-assets", "Embed assets as data URIs").option("--no-embed-assets", "Keep asset links relative/absolute").option("-r, --recursive [depth]", "Recursively crawl site (optional depth)", parseRecursiveValue).option("--max-depth <n>", "Set max depth for recursive crawl (alias for -r <n>)", parseInt).option("-b, --base-url <url>", "Base URL for resolving relative links").option("-d, --dry-run", "Run without writing output file").option("-v, --verbose", "Enable verbose (debug) logging").addOption(new Option("--log-level <level>", "Set logging level").choices(logLevels));
+  program.parse(argv);
+  const opts = program.opts();
+  const inputArg = program.args.length > 0 ? program.args[0] : void 0;
+  let finalLogLevel;
+  const cliLogLevel = opts.logLevel;
+  if (cliLogLevel) {
+    switch (cliLogLevel) {
+      case "debug":
+        finalLogLevel = 4 /* DEBUG */;
+        break;
+      case "info":
+        finalLogLevel = 3 /* INFO */;
+        break;
+      case "warn":
+        finalLogLevel = 2 /* WARN */;
+        break;
+      case "error":
+        finalLogLevel = 1 /* ERROR */;
+        break;
+      case "silent":
+      case "none":
+        finalLogLevel = 0 /* NONE */;
+        break;
+      default:
+        finalLogLevel = 3 /* INFO */;
+    }
+  } else if (opts.verbose) {
+    finalLogLevel = 4 /* DEBUG */;
+  } else {
+    finalLogLevel = 3 /* INFO */;
+  }
+  let embedAssets = true;
+  if (argv.includes("--no-embed-assets")) {
+    embedAssets = false;
+  } else if (opts.embedAssets === true) {
+    embedAssets = true;
+  }
+  let minifyHtml = opts.minifyHtml !== false;
+  let minifyCss = opts.minifyCss !== false;
+  let minifyJs = opts.minifyJs !== false;
+  if (opts.minify === false) {
+    minifyHtml = false;
+    minifyCss = false;
+    minifyJs = false;
+  }
+  let recursiveOpt = opts.recursive;
+  if (opts.maxDepth !== void 0 && !isNaN(opts.maxDepth) && opts.maxDepth >= 0) {
+    recursiveOpt = opts.maxDepth;
+  }
+  return {
+    // Pass through directly parsed options
+    baseUrl: opts.baseUrl,
+    dryRun: opts.dryRun ?? false,
+    // Ensure boolean, default false
+    output: opts.output,
+    verbose: opts.verbose ?? false,
+    // Ensure boolean, default false
+    // Set calculated/processed options
+    input: inputArg,
+    logLevel: finalLogLevel,
+    recursive: recursiveOpt,
+    // Final calculated value for recursion
+    embedAssets,
+    // Final calculated value
+    minifyHtml,
+    // Final calculated value
+    minifyCss,
+    // Final calculated value
+    minifyJs
+    // Final calculated value
+    // Exclude intermediate commander properties like:
+    // minify, logLevel (string version), maxDepth,
+    // minifyHtml, minifyCss, minifyJs (commander's raw boolean flags)
+  };
+}
+var logLevels;
+var init_options = __esm({
+  "src/cli/options.ts"() {
+    "use strict";
+    init_types();
+    logLevels = ["debug", "info", "warn", "error", "silent", "none"];
+  }
+});
+
+// src/utils/mime.ts
+import path from "path";
+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;
+}
+var MIME_MAP, DEFAULT_MIME_TYPE;
+var init_mime = __esm({
+  "src/utils/mime.ts"() {
+    "use strict";
+    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" }
+    };
+    DEFAULT_MIME_TYPE = {
+      mime: "application/octet-stream",
+      assetType: "other"
+      // Explicit cast needed
+    };
+  }
+});
+
+// src/core/parser.ts
+import { readFile } from "fs/promises";
+import * as cheerio from "cheerio";
+async function parseHTML(entryFilePath, logger) {
+  logger?.debug(`Parsing HTML file: ${entryFilePath}`);
+  let htmlContent;
+  try {
+    htmlContent = await readFile(entryFilePath, "utf-8");
+    logger?.debug(`Successfully read HTML file (${Buffer.byteLength(htmlContent)} bytes).`);
+  } catch (err) {
+    logger?.error(`Failed to read HTML file "${entryFilePath}": ${err.message}`);
+    throw new Error(`Could not read input HTML file: ${entryFilePath}`, { cause: err });
+  }
+  const $ = cheerio.load(htmlContent);
+  const assets = [];
+  const addedUrls = /* @__PURE__ */ new Set();
+  const addAsset = (url, forcedType) => {
+    if (!url || url.trim() === "" || url.startsWith("data:")) {
+      return;
+    }
+    if (!addedUrls.has(url)) {
+      addedUrls.add(url);
+      const mimeInfo = guessMimeType(url);
+      const type = forcedType ?? mimeInfo.assetType;
+      assets.push({ type, url });
+      logger?.debug(`Discovered asset: Type='${type}', URL='${url}'`);
+    } else {
+      logger?.debug(`Skipping duplicate asset URL: ${url}`);
+    }
+  };
+  logger?.debug("Extracting assets from HTML tags...");
+  $('link[rel="stylesheet"][href]').each((_, el) => {
+    addAsset($(el).attr("href"), "css");
+  });
+  $("script[src]").each((_, el) => {
+    addAsset($(el).attr("src"), "js");
+  });
+  $("img[src]").each((_, el) => addAsset($(el).attr("src"), "image"));
+  $('input[type="image"][src]').each((_, el) => addAsset($(el).attr("src"), "image"));
+  $("img[srcset], picture source[srcset]").each((_, el) => {
+    const srcset = $(el).attr("srcset");
+    srcset?.split(",").forEach((entry) => {
+      const [url] = entry.trim().split(/\s+/);
+      addAsset(url, "image");
+    });
+  });
+  $("video[src]").each((_, el) => addAsset($(el).attr("src"), "video"));
+  $("video[poster]").each((_, el) => addAsset($(el).attr("poster"), "image"));
+  $("audio[src]").each((_, el) => addAsset($(el).attr("src"), "audio"));
+  $("video > source[src]").each((_, el) => addAsset($(el).attr("src"), "video"));
+  $("audio > source[src]").each((_, el) => addAsset($(el).attr("src"), "audio"));
+  $("link[href]").filter((_, el) => {
+    const rel = $(el).attr("rel")?.toLowerCase() ?? "";
+    return ["icon", "shortcut icon", "apple-touch-icon", "manifest"].includes(rel);
+  }).each((_, el) => {
+    const rel = $(el).attr("rel")?.toLowerCase() ?? "";
+    const isIcon = ["icon", "shortcut icon", "apple-touch-icon"].includes(rel);
+    addAsset($(el).attr("href"), isIcon ? "image" : void 0);
+  });
+  $('link[rel="preload"][as="font"][href]').each((_, el) => {
+    addAsset($(el).attr("href"), "font");
+  });
+  logger?.info(`HTML parsing complete. Discovered ${assets.length} unique asset links.`);
+  return { htmlContent, assets };
+}
+var init_parser = __esm({
+  "src/core/parser.ts"() {
+    "use strict";
+    init_mime();
+  }
+});
+
+// src/core/extractor.ts
+import { readFile as readFile2 } from "fs/promises";
+import * as fs from "fs";
+import path2 from "path";
+import { fileURLToPath, URL as URL2 } from "url";
+import * as axios from "axios";
+function isUtf8DecodingLossy(originalBuffer, decodedString) {
+  try {
+    const reEncodedBuffer = Buffer.from(decodedString, "utf-8");
+    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())
+  };
+}
+var TEXT_ASSET_TYPES, BINARY_ASSET_TYPES, MAX_ASSET_EXTRACTION_ITERATIONS;
+var init_extractor = __esm({
+  "src/core/extractor.ts"() {
+    "use strict";
+    init_mime();
+    TEXT_ASSET_TYPES = /* @__PURE__ */ new Set(["css", "js"]);
+    BINARY_ASSET_TYPES = /* @__PURE__ */ new Set(["image", "font", "video", "audio"]);
+    MAX_ASSET_EXTRACTION_ITERATIONS = 1e3;
+  }
+});
+
+// src/core/minifier.ts
+import { minify as htmlMinify } from "html-minifier-terser";
+import CleanCSS from "clean-css";
+import { minify as jsMinify } from "terser";
+async function minifyAssets(parsed, options = {}, logger) {
+  const { htmlContent, assets } = parsed;
+  const currentHtmlContent = htmlContent ?? "";
+  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
+  };
+}
+var HTML_MINIFY_OPTIONS, CSS_MINIFY_OPTIONS, JS_MINIFY_OPTIONS;
+var init_minifier = __esm({
+  "src/core/minifier.ts"() {
+    "use strict";
+    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
+    };
+    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
+    };
+    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 }
+    };
+  }
+});
+
+// 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;
+}
+var init_packer = __esm({
+  "src/core/packer.ts"() {
+    "use strict";
+  }
+});
+
+// src/utils/logger.ts
+var Logger;
+var init_logger = __esm({
+  "src/utils/logger.ts"() {
+    "use strict";
+    init_types();
+    Logger = class _Logger {
+      /** The current minimum log level required for a message to be output. */
+      level;
+      /**
+       * Creates a new Logger instance.
+       * Defaults to LogLevel.INFO if no level is provided.
+       *
+       * @param {LogLevel} [level=LogLevel.INFO] - The initial log level for this logger instance.
+       * Must be one of the values from the LogLevel enum.
+       */
+      constructor(level = 3 /* INFO */) {
+        this.level = level !== void 0 && LogLevel[level] !== void 0 ? level : 3 /* INFO */;
+      }
+      /**
+       * Updates the logger's current level. Messages below this level will be suppressed.
+       *
+       * @param {LogLevel} level - The new log level to set. Must be a LogLevel enum member.
+       */
+      setLevel(level) {
+        this.level = level;
+      }
+      /**
+       * Logs a debug message if the current log level is DEBUG or higher.
+       *
+       * @param {string} message - The debug message string.
+       */
+      debug(message) {
+        if (this.level >= 4 /* DEBUG */) {
+          console.debug(`[DEBUG] ${message}`);
+        }
+      }
+      /**
+       * Logs an informational message if the current log level is INFO or higher.
+       *
+       * @param {string} message - The informational message string.
+       */
+      info(message) {
+        if (this.level >= 3 /* INFO */) {
+          console.info(`[INFO] ${message}`);
+        }
+      }
+      /**
+       * Logs a warning message if the current log level is WARN or higher.
+       *
+       * @param {string} message - The warning message string.
+       */
+      warn(message) {
+        if (this.level >= 2 /* WARN */) {
+          console.warn(`[WARN] ${message}`);
+        }
+      }
+      /**
+       * Logs an error message if the current log level is ERROR or higher.
+       *
+       * @param {string} message - The error message string.
+       */
+      error(message) {
+        if (this.level >= 1 /* ERROR */) {
+          console.error(`[ERROR] ${message}`);
+        }
+      }
+      /**
+       * Static factory method to create a Logger instance based on a simple boolean `verbose` flag.
+       *
+       * @static
+       * @param {{ verbose?: boolean }} [options={}] - An object potentially containing a `verbose` flag.
+       * @returns {Logger} A new Logger instance set to LogLevel.DEBUG if options.verbose is true,
+       * otherwise set to LogLevel.INFO.
+       */
+      static fromVerboseFlag(options = {}) {
+        return new _Logger(options.verbose ? 4 /* DEBUG */ : 3 /* INFO */);
+      }
+      /**
+       * Static factory method to create a Logger instance based on a LogLevel string name.
+       * Useful for creating a logger from config files or environments variables.
+       *
+       * @static
+       * @param {string | undefined} levelName - The name of the log level (e.g., 'debug', 'info', 'warn', 'error', 'silent'/'none'). Case-insensitive.
+       * @param {LogLevel} [defaultLevel=LogLevel.INFO] - The level to use if levelName is invalid or undefined.
+       * @returns {Logger} A new Logger instance set to the corresponding LogLevel.
+       */
+      static fromLevelName(levelName, defaultLevel = 3 /* INFO */) {
+        if (!levelName) {
+          return new _Logger(defaultLevel);
+        }
+        switch (levelName.toLowerCase()) {
+          // Return enum members
+          case "debug":
+            return new _Logger(4 /* DEBUG */);
+          case "info":
+            return new _Logger(3 /* INFO */);
+          case "warn":
+            return new _Logger(2 /* WARN */);
+          case "error":
+            return new _Logger(1 /* ERROR */);
+          case "silent":
+          case "none":
+            return new _Logger(0 /* NONE */);
+          default:
+            console.warn(`[Logger] Invalid log level name "${levelName}". Defaulting to ${LogLevel[defaultLevel]}.`);
+            return new _Logger(defaultLevel);
+        }
+      }
+    };
+  }
+});
+
+// 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);
+}
+var init_slugify = __esm({
+  "src/utils/slugify.ts"() {
+    "use strict";
+  }
+});
+
+// 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;
+}
+var init_bundler = __esm({
+  "src/core/bundler.ts"() {
+    "use strict";
+    init_extractor();
+    init_minifier();
+    init_packer();
+    init_slugify();
+  }
+});
+
+// src/core/web-fetcher.ts
+import * as puppeteer from "puppeteer";
+import * as fs2 from "fs/promises";
+async function fetchAndPackWebPage(url, logger, timeout = 3e4) {
+  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;
+  }
+}
+var init_web_fetcher = __esm({
+  "src/core/web-fetcher.ts"() {
+    "use strict";
+    init_logger();
+    init_bundler();
+  }
+});
+
+// src/utils/meta.ts
+var BuildTimer;
+var init_meta = __esm({
+  "src/utils/meta.ts"() {
+    "use strict";
+    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;
+  }
+}
+var init_src = __esm({
+  "src/index.ts"() {
+    "use strict";
+    init_parser();
+    init_extractor();
+    init_minifier();
+    init_packer();
+    init_web_fetcher();
+    init_bundler();
+    init_meta();
+    init_logger();
+    init_types();
+  }
+});
+
+// src/cli/cli.ts
+var cli_exports = {};
+__export(cli_exports, {
+  main: () => main,
+  runCli: () => runCli
+});
+import fs3 from "fs";
+import path3 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+function getPackageJson() {
+  try {
+    const __filename = fileURLToPath2(import.meta.url);
+    const __dirname = path3.dirname(__filename);
+    const pkgPath = path3.resolve(__dirname, "../../package.json");
+    if (fs3.existsSync(pkgPath)) {
+      return JSON.parse(fs3.readFileSync(pkgPath, "utf-8"));
+    }
+  } catch (_) {
+  }
+  return { version: "0.1.0" };
+}
+async function runCli(argv = process.argv) {
+  let stdout = "";
+  let stderr = "";
+  let exitCode = 0;
+  const originalLog = console.log;
+  const originalErr = console.error;
+  const originalWarn = console.warn;
+  console.log = (...args) => {
+    stdout += args.join(" ") + "\n";
+  };
+  console.error = (...args) => {
+    stderr += args.join(" ") + "\n";
+  };
+  console.warn = (...args) => {
+    stderr += args.join(" ") + "\n";
+  };
+  let opts;
+  try {
+    opts = parseOptions(argv);
+    const version = getPackageJson().version || "0.1.0";
+    if (opts.verbose) {
+      console.log(`\u{1F4E6} PortaPack v${version}`);
+    }
+    if (!opts.input) {
+      console.error("\u274C Missing input file or URL");
+      console.log = originalLog;
+      console.error = originalErr;
+      console.warn = originalWarn;
+      return { stdout, stderr, exitCode: 1 };
+    }
+    const outputPath = opts.output ?? `${path3.basename(opts.input).split(".")[0] || "output"}.packed.html`;
+    if (opts.verbose) {
+      console.log(`\u{1F4E5} Input: ${opts.input}`);
+      console.log(`\u{1F4E4} Output: ${outputPath}`);
+      console.log(`   Recursive: ${opts.recursive ?? false}`);
+      console.log(`   Embed Assets: ${opts.embedAssets}`);
+      console.log(`   Minify HTML: ${opts.minifyHtml}`);
+      console.log(`   Minify CSS: ${opts.minifyCss}`);
+      console.log(`   Minify JS: ${opts.minifyJs}`);
+      console.log(`   Log Level: ${LogLevel[opts.logLevel ?? 3 /* INFO */]}`);
+    }
+    if (opts.dryRun) {
+      console.log("\u{1F4A1} Dry run mode \u2014 no output will be written");
+      console.log = originalLog;
+      console.error = originalErr;
+      console.warn = originalWarn;
+      return { stdout, stderr, exitCode: 0 };
+    }
+    const result = opts.recursive ? await generateRecursivePortableHTML(opts.input, typeof opts.recursive === "boolean" ? 1 : opts.recursive, opts) : await generatePortableHTML(opts.input, opts);
+    fs3.writeFileSync(outputPath, result.html, "utf-8");
+    const meta = result.metadata;
+    console.log(`\u2705 Packed: ${meta.input} \u2192 ${outputPath}`);
+    console.log(`\u{1F4E6} Size: ${(meta.outputSize / 1024).toFixed(2)} KB`);
+    console.log(`\u23F1\uFE0F Time: ${meta.buildTimeMs} ms`);
+    console.log(`\u{1F5BC}\uFE0F Assets: ${meta.assetCount}`);
+    if (meta.pagesBundled && meta.pagesBundled > 0) {
+      console.log(`\u{1F9E9} Pages: ${meta.pagesBundled}`);
+    }
+    if (meta.errors && meta.errors.length > 0) {
+      console.warn(`
+\u26A0\uFE0F  ${meta.errors.length} warning(s):`);
+      for (const err of meta.errors) {
+        console.warn(`  - ${err}`);
+      }
+    }
+  } catch (err) {
+    console.error(`
+\u{1F4A5} Error: ${err?.message || "Unknown failure"}`);
+    if (err?.stack && opts?.verbose) {
+      console.error(err.stack);
+    }
+    exitCode = 1;
+  } finally {
+    console.log = originalLog;
+    console.error = originalErr;
+    console.warn = originalWarn;
+  }
+  return { stdout, stderr, exitCode };
+}
+var main;
+var init_cli = __esm({
+  "src/cli/cli.ts"() {
+    "use strict";
+    init_options();
+    init_src();
+    init_types();
+    main = runCli;
+  }
+});
+
+// src/cli/cli-entry.ts
+var startCLI = async () => {
+  const { main: main2 } = await Promise.resolve().then(() => (init_cli(), cli_exports));
+  return await main2(process.argv);
+};
+if (import.meta.url === `file://${process.argv[1]}`) {
+  startCLI().then(({ exitCode }) => process.exit(Number(exitCode)));
+}
+export {
+  startCLI
+};
+//# sourceMappingURL=cli-entry.js.map