@addfox/core 0.1.1-beta.2

package/dist/esm/index.js

@@ -0,0 +1,1521 @@
+import { createRequire } from "module";
+import { basename as external_path_basename, dirname, extname, resolve } from "path";
+import { existsSync, readFileSync, readdirSync, statSync } from "fs";
+import { ADDFOX_ERROR_CODES, AddfoxError, logDoneTimed, logEntriesTable } from "@addfox/common";
+import { createRequire as external_node_module_createRequire } from "node:module";
+import { existsSync as external_node_fs_existsSync, readFileSync as external_node_fs_readFileSync } from "node:fs";
+import { dirname as external_node_path_dirname, join, resolve as external_node_path_resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+function defineConfig(config) {
+    return config;
+}
+const CONFIG_FILES = [
+    "addfox.config.ts",
+    "addfox.config.js",
+    "addfox.config.mjs"
+];
+const SCRIPT_EXTS = [
+    ".js",
+    ".jsx",
+    ".ts",
+    ".tsx"
+];
+const RESERVED_ENTRY_NAMES = [
+    "popup",
+    "options",
+    "sidepanel",
+    "offscreen",
+    "sandbox",
+    "newtab",
+    "bookmarks",
+    "history",
+    "background",
+    "devtools",
+    "content"
+];
+const HTML_ENTRY_NAMES = [
+    "popup",
+    "options",
+    "sidepanel",
+    "devtools",
+    "offscreen",
+    "sandbox",
+    "newtab",
+    "bookmarks",
+    "history"
+];
+const SCRIPT_ONLY_ENTRY_NAMES = [
+    "background",
+    "content"
+];
+const RELOAD_MANAGER_ENTRY_NAMES = new Set(SCRIPT_ONLY_ENTRY_NAMES);
+const ADDFOX_OUTPUT_ROOT = ".addfox";
+const DEFAULT_OUT_DIR = "extension";
+const DEFAULT_ENV_PREFIXES = [
+    "ADDFOX_PUBLIC_"
+];
+const DEFAULT_BROWSER = "chromium";
+const SUPPORTED_BROWSERS = [
+    "chromium",
+    "firefox"
+];
+const BROWSER_OUTPUT_PREFIX = "extension";
+function getBrowserOutputDir(browser) {
+    return `${BROWSER_OUTPUT_PREFIX}-${browser}`;
+}
+const SUPPORTED_LAUNCH_TARGETS = [
+    "chrome",
+    "chromium",
+    "edge",
+    "brave",
+    "vivaldi",
+    "opera",
+    "santa",
+    "arc",
+    "yandex",
+    "browseros",
+    "custom",
+    "firefox"
+];
+const CLI_COMMANDS = [
+    "dev",
+    "build",
+    "test"
+];
+const RSTEST_CONFIG_FILES = [
+    "rstest.config.cts",
+    "rstest.config.mts",
+    "rstest.config.cjs",
+    "rstest.config.js",
+    "rstest.config.ts",
+    "rstest.config.mjs"
+];
+const MANIFEST_DIR = "manifest";
+const MANIFEST_FILE_NAMES = {
+    base: "manifest.json",
+    chromium: "manifest.chromium.json",
+    firefox: "manifest.firefox.json"
+};
+const MANIFEST_ENTRY_PATHS = {
+    background: "background/index.js",
+    content: "content/index.js",
+    popup: "popup/index.html",
+    options: "options/index.html",
+    sidepanel: "sidepanel/index.html",
+    devtools: "devtools/index.html",
+    offscreen: "offscreen/index.html",
+    sandbox: "sandbox/index.html",
+    newtab: "newtab/index.html",
+    bookmarks: "bookmarks/index.html",
+    history: "history/index.html"
+};
+const MANIFEST_ENTRY_KEYS = Object.keys(MANIFEST_ENTRY_PATHS);
+function isScriptSrcRelative(src) {
+    const t = src.trim();
+    if (t.startsWith("/") || t.startsWith("\\")) return false;
+    if (/^[a-z][a-z0-9+.-]*:\/\//i.test(t)) return false;
+    return true;
+}
+const ENTRY_SCRIPT_REGEX = /<script\b[^>]*data-addfox-entry[^>]*>[\s\S]*?<\/script>/gi;
+const HEAD_CLOSE_REGEX = /<\/head\s*>/i;
+const SCRIPT_WITH_SRC_REGEX = /<script\b[^>]*\ssrc\s*=\s*["']([^"']+)["'][^>]*>[\s\S]*?<\/script>/gi;
+function findFirstScriptWithRelativeSrc(html) {
+    const reg = new RegExp(SCRIPT_WITH_SRC_REGEX.source, "gi");
+    let match;
+    while(null !== (match = reg.exec(html))){
+        const src = match[1];
+        if (!isScriptSrcRelative(src)) continue;
+        return {
+            src,
+            fullTag: match[0],
+            tagStartIndex: match.index
+        };
+    }
+}
+function parseAddfoxEntryFromHtml(htmlPath) {
+    const raw = readFileSync(htmlPath, "utf-8");
+    const reg = new RegExp(ENTRY_SCRIPT_REGEX.source, "gi");
+    const match = reg.exec(raw);
+    if (match) {
+        const tag = match[0];
+        const tagStartIndex = match.index;
+        const srcMatch = tag.match(/src\s*=\s*["']([^"']+)["']/i);
+        if (srcMatch?.[1] && isScriptSrcRelative(srcMatch[1])) {
+            const src = srcMatch[1];
+            const headCloseMatch = raw.match(HEAD_CLOSE_REGEX);
+            const headCloseIndex = headCloseMatch?.index ?? -1;
+            const inject = headCloseIndex >= 0 && tagStartIndex < headCloseIndex ? "head" : "body";
+            const strippedHtml = raw.replace(ENTRY_SCRIPT_REGEX, "").trimEnd();
+            return {
+                src,
+                inject,
+                strippedHtml
+            };
+        }
+    }
+    const fallback = findFirstScriptWithRelativeSrc(raw);
+    if (!fallback) return;
+    const headCloseMatch = raw.match(HEAD_CLOSE_REGEX);
+    const headCloseIndex = headCloseMatch?.index ?? -1;
+    const inject = headCloseIndex >= 0 && fallback.tagStartIndex < headCloseIndex ? "head" : "body";
+    const strippedHtml = raw.replace(fallback.fullTag, "").trimEnd();
+    return {
+        src: fallback.src,
+        inject,
+        strippedHtml
+    };
+}
+function getScriptInjectIfMatches(htmlPath, scriptPath) {
+    try {
+        const parsed = parseAddfoxEntryFromHtml(htmlPath);
+        if (!parsed) return;
+        const resolvedFromHtml = resolve(dirname(htmlPath), parsed.src);
+        return resolvedFromHtml === scriptPath ? parsed.inject : void 0;
+    } catch  {
+        return;
+    }
+}
+function resolveScriptFromHtmlStrict(htmlPath) {
+    const parsed = parseAddfoxEntryFromHtml(htmlPath);
+    if (!parsed) throw new Error("data-addfox-entry script must have a src attribute (relative path)");
+    if (!isScriptSrcRelative(parsed.src)) throw new Error(`data-addfox-entry src must be relative, got: ${JSON.stringify(parsed.src)}`);
+    const scriptPath = resolve(dirname(htmlPath), parsed.src);
+    if (!existsSync(scriptPath)) throw new Error(`Entry script not found: ${scriptPath}`);
+    return {
+        scriptPath,
+        inject: parsed.inject
+    };
+}
+function readDirContents(dir) {
+    try {
+        const entries = readdirSync(dir, {
+            withFileTypes: true
+        });
+        return {
+            files: new Set(entries.filter((e)=>e.isFile()).map((e)=>e.name)),
+            dirs: new Set(entries.filter((e)=>e.isDirectory()).map((e)=>e.name))
+        };
+    } catch  {
+        return null;
+    }
+}
+function findScriptInDir(dir, scriptExts) {
+    const contents = readDirContents(dir);
+    if (!contents) return;
+    for (const ext of scriptExts)if (contents.files.has(`index${ext}`)) return resolve(dir, `index${ext}`);
+}
+function findScriptInDirFromContents(dirPath, contents, scriptExts) {
+    if (!contents) return findScriptInDir(dirPath, scriptExts);
+    for (const ext of scriptExts)if (contents.files.has(`index${ext}`)) return resolve(dirPath, `index${ext}`);
+}
+function findNamedScript(baseDir, name, scriptExts, baseContents) {
+    if (baseContents) {
+        for (const ext of scriptExts)if (baseContents.files.has(`${name}${ext}`)) return resolve(baseDir, `${name}${ext}`);
+        return;
+    }
+    for (const ext of scriptExts){
+        const p = resolve(baseDir, `${name}${ext}`);
+        if (existsSync(p)) return p;
+    }
+}
+function findNamedHtml(baseDir, name, baseContents) {
+    if (baseContents) return baseContents.files.has(`${name}.html`) ? resolve(baseDir, `${name}.html`) : void 0;
+    const p = resolve(baseDir, `${name}.html`);
+    return existsSync(p) ? p : void 0;
+}
+function isValidScriptExt(pathStr, scriptExts) {
+    const lower = pathStr.trim().toLowerCase();
+    return scriptExts.some((ext)=>lower.endsWith(ext));
+}
+function resolveScriptFromHtmlWithInjectStrict(htmlPath, scriptExts) {
+    const resolved = resolveScriptFromHtmlStrict(htmlPath);
+    if (!isValidScriptExt(resolved.scriptPath, scriptExts)) throw new AddfoxError({
+        code: ADDFOX_ERROR_CODES.ENTRY_SCRIPT_FROM_HTML,
+        message: "Invalid data-addfox-entry script in HTML",
+        details: `HTML: ${htmlPath}. Resolved path is not a supported script: ${resolved.scriptPath}`,
+        hint: "data-addfox-entry script must have a relative src and the file must exist"
+    });
+    return resolved;
+}
+function tryResolveEntryFromHtml(htmlPath, scriptExts) {
+    try {
+        const parsed = parseAddfoxEntryFromHtml(htmlPath);
+        if (!parsed) return;
+        return resolveScriptFromHtmlWithInjectStrict(htmlPath, scriptExts);
+    } catch (e) {
+        throw new AddfoxError({
+            code: ADDFOX_ERROR_CODES.ENTRY_SCRIPT_FROM_HTML,
+            message: "Invalid data-addfox-entry script in HTML",
+            details: `HTML: ${htmlPath}. ${e instanceof Error ? e.message : String(e)}`,
+            hint: "data-addfox-entry script must have a relative src and the file must exist"
+        });
+    }
+}
+function buildHtmlEntryInfo(name, htmlPath, conventionalScriptPath, scriptExts) {
+    const fromHtml = tryResolveEntryFromHtml(htmlPath, scriptExts);
+    if (fromHtml) return {
+        name,
+        scriptPath: fromHtml.scriptPath,
+        htmlPath,
+        html: true,
+        scriptInject: fromHtml.inject,
+        outputFollowsScriptPath: true
+    };
+    if (!conventionalScriptPath) return null;
+    return {
+        name,
+        scriptPath: conventionalScriptPath,
+        htmlPath,
+        html: true,
+        scriptInject: getScriptInjectIfMatches(htmlPath, conventionalScriptPath)
+    };
+}
+function discoverScriptOnlyEntry(baseDir, name, contents, options) {
+    const singleScript = findNamedScript(baseDir, name, options.scriptExts, contents);
+    if (singleScript) return {
+        name,
+        scriptPath: singleScript,
+        html: false
+    };
+    if (!contents?.dirs.has(name)) return null;
+    const scriptPath = findScriptInDir(resolve(baseDir, name), options.scriptExts);
+    return scriptPath ? {
+        name,
+        scriptPath,
+        html: false
+    } : null;
+}
+function discoverHtmlEntryFromFlat(baseDir, name, contents, options) {
+    const singleScript = findNamedScript(baseDir, name, options.scriptExts, contents);
+    const singleHtml = findNamedHtml(baseDir, name, contents);
+    if (singleScript && singleHtml) return buildHtmlEntryInfo(name, singleHtml, singleScript, options.scriptExts);
+    if (singleHtml) {
+        const conventional = findNamedScript(baseDir, name, options.scriptExts, contents);
+        return buildHtmlEntryInfo(name, singleHtml, conventional, options.scriptExts);
+    }
+    return null;
+}
+function discoverHtmlEntryFromDir(baseDir, name, contents, options) {
+    if (!contents?.dirs.has(name)) return null;
+    const dirPath = resolve(baseDir, name);
+    const subContents = readDirContents(dirPath);
+    const htmlPath = subContents?.files.has("index.html") ? resolve(dirPath, "index.html") : void 0;
+    const scriptPath = findScriptInDirFromContents(dirPath, subContents, options.scriptExts);
+    if (scriptPath && htmlPath) return buildHtmlEntryInfo(name, htmlPath, scriptPath, options.scriptExts);
+    if (scriptPath) return {
+        name,
+        scriptPath,
+        htmlPath,
+        html: true,
+        scriptInject: htmlPath ? getScriptInjectIfMatches(htmlPath, scriptPath) : void 0
+    };
+    if (!htmlPath) return null;
+    return buildHtmlEntryInfo(name, htmlPath, void 0, options.scriptExts);
+}
+function discoverHtmlEntry(baseDir, name, contents, options) {
+    return discoverHtmlEntryFromFlat(baseDir, name, contents, options) ?? discoverHtmlEntryFromDir(baseDir, name, contents, options);
+}
+function discoverEntriesInternal(baseDir, options) {
+    const contents = readDirContents(baseDir);
+    const entries = [];
+    for (const name of options.scriptOnlyNames){
+        const entry = discoverScriptOnlyEntry(baseDir, name, contents, options);
+        if (entry) entries.push(entry);
+    }
+    for (const name of options.htmlEntryNames){
+        const entry = discoverHtmlEntry(baseDir, name, contents, options);
+        if (entry) entries.push(entry);
+    }
+    return entries;
+}
+function createOptions(options = {}) {
+    return {
+        scriptExts: options.scriptExts ?? SCRIPT_EXTS,
+        scriptOnlyNames: options.scriptOnlyNames ?? SCRIPT_ONLY_ENTRY_NAMES,
+        htmlEntryNames: options.htmlEntryNames ?? HTML_ENTRY_NAMES
+    };
+}
+function discoverEntries(baseDir, options) {
+    return discoverEntriesInternal(baseDir, createOptions(options));
+}
+function getHtmlEntryNames(options) {
+    return [
+        ...options?.htmlEntryNames ?? HTML_ENTRY_NAMES
+    ];
+}
+function getScriptOnlyEntryNames(options) {
+    return [
+        ...options?.scriptOnlyNames ?? SCRIPT_ONLY_ENTRY_NAMES
+    ];
+}
+function getAllEntryNames(options) {
+    return [
+        ...getHtmlEntryNames(options),
+        ...getScriptOnlyEntryNames(options)
+    ];
+}
+function isSourceFilePath(path) {
+    const lower = path.trim().toLowerCase();
+    return /\.(ts|tsx|js|jsx)$/.test(lower) && !lower.includes("/dist/") && !lower.includes("\\dist\\");
+}
+function inferEntryNameFromPath(path) {
+    const cleanPath = path.replace(/^\.\/|^\//, "");
+    const firstSegment = cleanPath.split(/[\/\\]/)[0];
+    if (MANIFEST_ENTRY_KEYS.includes(firstSegment)) return firstSegment;
+    return null;
+}
+function extractServiceWorker(manifest, browser) {
+    const bg = manifest.background;
+    if (!bg) return null;
+    const serviceWorker = bg.service_worker;
+    if ("string" == typeof serviceWorker && isSourceFilePath(serviceWorker)) {
+        const entryName = inferEntryNameFromPath(serviceWorker) ?? "background";
+        return {
+            name: entryName,
+            value: serviceWorker.replace(/^\.\//, ""),
+            manifestPath: "background.service_worker"
+        };
+    }
+    const scripts = bg.scripts;
+    if (Array.isArray(scripts) && scripts.length > 0) {
+        const firstScript = scripts[0];
+        if ("string" == typeof firstScript && isSourceFilePath(firstScript)) {
+            const entryName = inferEntryNameFromPath(firstScript) ?? "background";
+            return {
+                name: entryName,
+                value: firstScript.replace(/^\.\//, ""),
+                manifestPath: "background.scripts[0]"
+            };
+        }
+    }
+    const page = bg.page;
+    if ("string" == typeof page && isSourceFilePath(page)) {
+        const entryName = inferEntryNameFromPath(page) ?? "background";
+        return {
+            name: entryName,
+            value: page.replace(/^\.\//, ""),
+            manifestPath: "background.page"
+        };
+    }
+    return null;
+}
+function extractPopup(manifest, browser) {
+    const mv = 2 === manifest.manifest_version ? 2 : 3;
+    let popupPath;
+    let manifestPath;
+    if (3 === mv) {
+        const action = manifest.action;
+        const defaultPopup = action?.default_popup;
+        if ("string" == typeof defaultPopup) {
+            popupPath = defaultPopup;
+            manifestPath = "action.default_popup";
+        }
+    } else {
+        const browserAction = manifest.browser_action;
+        const defaultPopup = browserAction?.default_popup;
+        if ("string" == typeof defaultPopup) {
+            popupPath = defaultPopup;
+            manifestPath = "browser_action.default_popup";
+        }
+    }
+    if (popupPath && isSourceFilePath(popupPath)) {
+        const entryName = inferEntryNameFromPath(popupPath) ?? "popup";
+        return {
+            name: entryName,
+            value: popupPath.replace(/^\.\//, ""),
+            manifestPath: manifestPath
+        };
+    }
+    return null;
+}
+function extractOptions(manifest) {
+    const mv = 2 === manifest.manifest_version ? 2 : 3;
+    let optionsPath;
+    let manifestPath;
+    if (3 === mv) {
+        const optionsUi = manifest.options_ui;
+        const page = optionsUi?.page;
+        if ("string" == typeof page) {
+            optionsPath = page;
+            manifestPath = "options_ui.page";
+        }
+    } else {
+        const optionsPage = manifest.options_page;
+        if ("string" == typeof optionsPage) {
+            optionsPath = optionsPage;
+            manifestPath = "options_page";
+        }
+    }
+    if (optionsPath && isSourceFilePath(optionsPath)) {
+        const entryName = inferEntryNameFromPath(optionsPath) ?? "options";
+        return {
+            name: entryName,
+            value: optionsPath.replace(/^\.\//, ""),
+            manifestPath: manifestPath
+        };
+    }
+    return null;
+}
+function extractDevtools(manifest) {
+    const devtoolsPage = manifest.devtools_page;
+    if ("string" == typeof devtoolsPage && isSourceFilePath(devtoolsPage)) {
+        const entryName = inferEntryNameFromPath(devtoolsPage) ?? "devtools";
+        return {
+            name: entryName,
+            value: devtoolsPage.replace(/^\.\//, ""),
+            manifestPath: "devtools_page"
+        };
+    }
+    return null;
+}
+function extractSidepanel(manifest) {
+    const sidePanel = manifest.side_panel;
+    const defaultPath = sidePanel?.default_path;
+    if ("string" == typeof defaultPath && isSourceFilePath(defaultPath)) {
+        const entryName = inferEntryNameFromPath(defaultPath) ?? "sidepanel";
+        return {
+            name: entryName,
+            value: defaultPath.replace(/^\.\//, ""),
+            manifestPath: "side_panel.default_path"
+        };
+    }
+    return null;
+}
+function extractSandbox(manifest) {
+    const sandbox = manifest.sandbox;
+    const pages = sandbox?.pages;
+    if (Array.isArray(pages) && pages.length > 0) {
+        const firstPage = pages[0];
+        if ("string" == typeof firstPage && isSourceFilePath(firstPage)) {
+            const entryName = inferEntryNameFromPath(firstPage) ?? "sandbox";
+            return {
+                name: entryName,
+                value: firstPage.replace(/^\.\//, ""),
+                manifestPath: "sandbox.pages[0]"
+            };
+        }
+    }
+    return null;
+}
+function extractOverrides(manifest) {
+    const entries = [];
+    const overrides = manifest.chrome_url_overrides;
+    if (!overrides) return entries;
+    const overrideKeys = [
+        "newtab",
+        "bookmarks",
+        "history"
+    ];
+    for (const key of overrideKeys){
+        const path = overrides[key];
+        if ("string" == typeof path && isSourceFilePath(path)) {
+            const entryName = inferEntryNameFromPath(path) ?? key;
+            entries.push({
+                name: entryName,
+                value: path.replace(/^\.\//, ""),
+                manifestPath: `chrome_url_overrides.${key}`
+            });
+        }
+    }
+    return entries;
+}
+function extractContentScripts(manifest) {
+    const contentScripts = manifest.content_scripts;
+    if (!Array.isArray(contentScripts) || 0 === contentScripts.length) return null;
+    for(let i = 0; i < contentScripts.length; i++){
+        const cs = contentScripts[i];
+        const js = cs.js;
+        if (Array.isArray(js) && js.length > 0) for(let j = 0; j < js.length; j++){
+            const path = js[j];
+            if ("string" == typeof path && isSourceFilePath(path)) {
+                const entryName = inferEntryNameFromPath(path) ?? "content";
+                return {
+                    name: entryName,
+                    value: path.replace(/^\.\//, ""),
+                    manifestPath: `content_scripts[${i}].js[${j}]`
+                };
+            }
+        }
+    }
+    return null;
+}
+function extractEntriesFromManifest(manifest, browser) {
+    const entries = {};
+    const replacementMap = new Map();
+    const extractors = [
+        ()=>extractServiceWorker(manifest, browser),
+        ()=>extractPopup(manifest, browser),
+        ()=>extractOptions(manifest),
+        ()=>extractDevtools(manifest),
+        ()=>extractSidepanel(manifest),
+        ()=>extractSandbox(manifest),
+        ()=>extractContentScripts(manifest),
+        ()=>extractOverrides(manifest)
+    ];
+    for (const extractor of extractors){
+        const result = extractor();
+        if (result) if (Array.isArray(result)) for (const entry of result){
+            entries[entry.name] = entry.value;
+            replacementMap.set(entry.manifestPath, entry.name);
+        }
+        else {
+            entries[result.name] = result.value;
+            replacementMap.set(result.manifestPath, result.name);
+        }
+    }
+    return {
+        entries,
+        replacementMap
+    };
+}
+const HTML_ENTRY_SET = new Set(HTML_ENTRY_NAMES);
+function isHtmlPath(pathStr) {
+    return pathStr.trim().toLowerCase().endsWith(".html");
+}
+function isScriptPath(pathStr) {
+    const lower = pathStr.trim().toLowerCase();
+    return SCRIPT_EXTS.some((ext)=>lower.endsWith(ext));
+}
+function resolver_findScriptInDir(dir) {
+    for (const ext of SCRIPT_EXTS){
+        const p = resolve(dir, `index${ext}`);
+        if (existsSync(p)) return p;
+    }
+}
+function findScriptForHtmlDir(dir, htmlFilename) {
+    const stem = external_path_basename(htmlFilename, ".html");
+    for (const ext of SCRIPT_EXTS){
+        const p = resolve(dir, `${stem}${ext}`);
+        if (existsSync(p)) return p;
+    }
+    return resolver_findScriptInDir(dir);
+}
+function isEntryConfigObject(value) {
+    return "object" == typeof value && null !== value && "src" in value;
+}
+function resolveHtmlPath(baseDir, htmlValue) {
+    if (!htmlValue) return;
+    const resolved = resolve(baseDir, htmlValue);
+    if (!isHtmlPath(resolved)) return;
+    return existsSync(resolved) ? resolved : void 0;
+}
+function resolveHtmlFlag(entryName, htmlValue, hasTemplate) {
+    if (false === htmlValue) return false;
+    if (true === htmlValue) return true;
+    if ("string" == typeof htmlValue) return hasTemplate;
+    return isHtmlEntryName(entryName);
+}
+function isHtmlEntryName(entryName) {
+    return HTML_ENTRY_SET.has(entryName);
+}
+function enrichEntryWithScriptInject(entry) {
+    if (!entry.htmlPath || !entry.scriptPath) return entry;
+    const scriptInject = getScriptInjectIfMatches(entry.htmlPath, entry.scriptPath);
+    return scriptInject ? {
+        ...entry,
+        scriptInject
+    } : entry;
+}
+function inferHtmlPathForReservedName(entryName, scriptPath) {
+    if (!HTML_ENTRY_SET.has(entryName)) return;
+    const dir = dirname(scriptPath);
+    const htmlPath = resolve(dir, "index.html");
+    return existsSync(htmlPath) ? htmlPath : void 0;
+}
+function resolveEntryFromObject(baseDir, name, value) {
+    const scriptPath = resolve(baseDir, value.src);
+    if (!existsSync(scriptPath) || !isScriptPath(scriptPath)) return null;
+    const htmlPath = resolveHtmlPath(baseDir, "string" == typeof value.html ? value.html : void 0);
+    if ("string" == typeof value.html && !htmlPath) return null;
+    const inferredHtml = htmlPath ?? inferHtmlPathForReservedName(name, scriptPath);
+    const html = resolveHtmlFlag(name, value.html, Boolean(htmlPath));
+    return enrichEntryWithScriptInject({
+        name,
+        scriptPath,
+        htmlPath: inferredHtml,
+        html
+    });
+}
+function resolveEntryFromHtml(baseDir, name, pathStr) {
+    const htmlPath = resolve(baseDir, pathStr);
+    const dir = dirname(htmlPath);
+    let parsed;
+    try {
+        parsed = parseAddfoxEntryFromHtml(htmlPath);
+    } catch  {
+        parsed = void 0;
+    }
+    let scriptPath;
+    if (parsed) try {
+        scriptPath = resolveScriptFromHtmlStrict(htmlPath).scriptPath;
+    } catch (e) {
+        throw new AddfoxError({
+            code: ADDFOX_ERROR_CODES.ENTRY_SCRIPT_FROM_HTML,
+            message: "Invalid data-addfox-entry script in HTML",
+            details: `HTML: ${htmlPath}. ${e instanceof Error ? e.message : String(e)}`,
+            hint: "data-addfox-entry script must have a relative src and the file must exist"
+        });
+    }
+    else scriptPath = findScriptForHtmlDir(dir, external_path_basename(htmlPath));
+    if (!scriptPath) return null;
+    return enrichEntryWithScriptInject({
+        name,
+        scriptPath,
+        htmlPath,
+        html: true,
+        outputFollowsScriptPath: Boolean(parsed)
+    });
+}
+function resolveEntryFromScript(baseDir, name, pathStr) {
+    const scriptPath = resolve(baseDir, pathStr);
+    if (!existsSync(scriptPath)) return null;
+    const htmlPath = inferHtmlPathForReservedName(name, scriptPath);
+    const html = isHtmlEntryName(name);
+    return enrichEntryWithScriptInject({
+        name,
+        scriptPath,
+        htmlPath,
+        html
+    });
+}
+function resolveSingleEntry(baseDir, name, value) {
+    if (isEntryConfigObject(value)) return resolveEntryFromObject(baseDir, name, value);
+    const resolved = resolve(baseDir, value);
+    if (!existsSync(resolved)) return null;
+    if (isHtmlPath(value)) return resolveEntryFromHtml(baseDir, name, value);
+    if (isScriptPath(value)) return resolveEntryFromScript(baseDir, name, value);
+    return null;
+}
+function resolveEntries(config, _root, baseDir, manifest, options) {
+    const browser = options?.browser ?? "chromium";
+    const defaultEntries = discoverEntries(baseDir, options?.entryDiscovererOptions);
+    const entryMap = new Map(defaultEntries.map((e)=>[
+            e.name,
+            e
+        ]));
+    let manifestReplacementMap;
+    const entryConfig = config.entry;
+    const hasExplicitEntryConfig = entryConfig && Object.keys(entryConfig).length > 0;
+    if (manifest && !hasExplicitEntryConfig) {
+        const manifestResult = extractEntriesFromManifest(manifest, browser);
+        manifestReplacementMap = manifestResult.replacementMap;
+        for (const [name, pathStr] of Object.entries(manifestResult.entries)){
+            const resolved = resolveSingleEntry(baseDir, name, pathStr);
+            if (resolved) entryMap.set(name, resolved);
+        }
+    }
+    if (hasExplicitEntryConfig) for (const [name, pathStr] of Object.entries(entryConfig)){
+        const resolved = resolveSingleEntry(baseDir, name, pathStr);
+        if (resolved) entryMap.set(name, resolved);
+        else entryMap.delete(name);
+    }
+    return {
+        entries: Array.from(entryMap.values()),
+        manifestReplacementMap
+    };
+}
+class ManifestLoader {
+    readManifestJson(filePath) {
+        if (!existsSync(filePath)) return null;
+        try {
+            const raw = readFileSync(filePath, "utf-8");
+            const data = JSON.parse(raw);
+            return "object" == typeof data && null !== data ? data : null;
+        } catch  {
+            return null;
+        }
+    }
+    isManifestPathConfig(m) {
+        if (!m || "object" != typeof m) return false;
+        const c = m;
+        return ("string" == typeof c.chromium || "string" == typeof c.firefox) && !("manifest_version" in c) && !("name" in c && "version" in c);
+    }
+    isChromiumFirefoxObject(m) {
+        return isChromiumFirefoxObjectValue(m);
+    }
+    deepMerge(base, override) {
+        const out = {
+            ...base
+        };
+        for (const key of Object.keys(override)){
+            const b = base[key];
+            const o = override[key];
+            if (null === o || "object" != typeof o || Array.isArray(o) || null === b || "object" != typeof b || Array.isArray(b)) out[key] = o;
+            else out[key] = this.deepMerge(b, o);
+        }
+        return out;
+    }
+    loadFromDir(dir) {
+        const basePath = resolve(dir, MANIFEST_FILE_NAMES.base);
+        const chromPath = resolve(dir, MANIFEST_FILE_NAMES.chromium);
+        const firefoxPath = resolve(dir, MANIFEST_FILE_NAMES.firefox);
+        return {
+            base: this.readManifestJson(basePath),
+            chromium: this.readManifestJson(chromPath),
+            firefox: this.readManifestJson(firefoxPath)
+        };
+    }
+    hasAnyManifest(files) {
+        return null !== files.base || null !== files.chromium || null !== files.firefox;
+    }
+    buildConfigFromFiles(files) {
+        const base = files.base ?? files.chromium ?? files.firefox ?? null;
+        if (!base) return null;
+        const chromium = files.chromium ? this.deepMerge(base, files.chromium) : base;
+        const firefox = files.firefox ? this.deepMerge(base, files.firefox) : base;
+        return {
+            chromium,
+            firefox
+        };
+    }
+    resolve(input, root, appDir) {
+        if (null == input) {
+            const manifestSubdir = resolve(appDir, MANIFEST_DIR);
+            const baseInApp = resolve(appDir, MANIFEST_FILE_NAMES.base);
+            const baseInSub = resolve(manifestSubdir, MANIFEST_FILE_NAMES.base);
+            const dir = existsSync(baseInApp) ? appDir : existsSync(baseInSub) ? manifestSubdir : null;
+            if (null !== dir) {
+                const files = this.loadFromDir(dir);
+                if (this.hasAnyManifest(files)) return validateAndReturn(this.buildConfigFromFiles(files));
+            }
+            return null;
+        }
+        if (this.isManifestPathConfig(input)) {
+            const result = {};
+            if (input.chromium) {
+                const obj = this.readManifestJson(resolve(appDir, input.chromium));
+                if (obj) result.chromium = obj;
+            }
+            if (input.firefox) {
+                const obj = this.readManifestJson(resolve(appDir, input.firefox));
+                if (obj) result.firefox = obj;
+            }
+            const chrom = result.chromium ?? result.firefox;
+            const ff = result.firefox ?? result.chromium;
+            if (!chrom && !ff) return null;
+            return validateAndReturn({
+                chromium: chrom ?? {},
+                firefox: ff ?? {}
+            });
+        }
+        this.isChromiumFirefoxObject(input);
+        return validateAndReturn(input);
+    }
+}
+const defaultLoader = new ManifestLoader();
+function resolveManifestInput(input, root, appDir) {
+    return defaultLoader.resolve(input, root, appDir);
+}
+function validateAndReturn(config) {
+    if (!config) return null;
+    validateManifestSchema(config);
+    return config;
+}
+function validateManifestSchema(config) {
+    if (isChromiumFirefoxObjectValue(config)) {
+        if (config.chromium) validateManifestRecord(config.chromium, "chromium");
+        if (config.firefox) validateManifestRecord(config.firefox, "firefox");
+        return;
+    }
+    validateManifestRecord(config);
+}
+function isChromiumFirefoxObjectValue(m) {
+    return "object" == typeof m && null !== m && ("chromium" in m || "firefox" in m);
+}
+function validateManifestRecord(manifest, target) {
+    const mv = getManifestVersion(manifest);
+    if (null == mv) throw new Error("manifest_version must be 2 or 3");
+    const errors = 2 === mv ? validateMv2(manifest) : validateMv3(manifest, target);
+    if (errors.length > 0) throw new Error(errors.join("; "));
+}
+function getManifestVersion(manifest) {
+    const mv = manifest.manifest_version;
+    if (2 === mv || 3 === mv) return mv;
+    return null;
+}
+function validateMv2(manifest) {
+    const errors = [];
+    if (null != manifest.action) errors.push('MV2 does not support "action"; use "browser_action" or "page_action"');
+    if (null != manifest.host_permissions) errors.push('MV2 does not support "host_permissions"; use "permissions"');
+    errors.push(...validateBackgroundMv2(manifest.background));
+    errors.push(...validatePermissionsList(manifest.permissions, "permissions"));
+    return errors;
+}
+function validateMv3(manifest, target) {
+    const errors = [];
+    if (null != manifest.browser_action || null != manifest.page_action) errors.push('MV3 does not support "browser_action" or "page_action"; use "action"');
+    const bgErrors = "firefox" === target ? validateBackgroundMv3Firefox(manifest.background) : validateBackgroundMv3Chrome(manifest.background);
+    errors.push(...bgErrors);
+    errors.push(...validatePermissionsList(manifest.permissions, "permissions"));
+    errors.push(...validatePermissionsList(manifest.host_permissions, "host_permissions"));
+    errors.push(...validateAction(manifest.action));
+    return errors;
+}
+function validateBackgroundMv2(background) {
+    const errors = [];
+    if (!background) return errors;
+    if ("object" != typeof background) {
+        errors.push('MV2 "background" must be an object');
+        return errors;
+    }
+    const bg = background;
+    if (null != bg.service_worker) errors.push('MV2 "background.service_worker" is not allowed');
+    if (null != bg.scripts && !isStringArray(bg.scripts)) errors.push('MV2 "background.scripts" must be string[]');
+    if (null != bg.page && "string" != typeof bg.page) errors.push('MV2 "background.page" must be a string');
+    return errors;
+}
+function validateBackgroundMv3Chrome(background) {
+    const errors = [];
+    if (!background) return errors;
+    if ("object" != typeof background) {
+        errors.push('MV3 (Chrome) "background" must be an object');
+        return errors;
+    }
+    const bg = background;
+    if (null != bg.scripts) errors.push('MV3 (Chrome) "background.scripts" is not allowed; use "service_worker"');
+    if (null != bg.page) errors.push('MV3 (Chrome) "background.page" is not allowed; use "service_worker"');
+    if (null != bg.service_worker && "string" != typeof bg.service_worker) errors.push('MV3 (Chrome) "background.service_worker" must be a string');
+    return errors;
+}
+function validateBackgroundMv3Firefox(background) {
+    const errors = [];
+    if (!background) return errors;
+    if ("object" != typeof background) {
+        errors.push('MV3 (Firefox) "background" must be an object');
+        return errors;
+    }
+    const bg = background;
+    const hasScripts = null != bg.scripts;
+    const hasPage = null != bg.page;
+    const hasServiceWorker = null != bg.service_worker;
+    if (!hasScripts && !hasPage && !hasServiceWorker) return errors;
+    if (hasScripts && !isStringArray(bg.scripts)) errors.push('MV3 (Firefox) "background.scripts" must be string[]');
+    if (hasPage && "string" != typeof bg.page) errors.push('MV3 (Firefox) "background.page" must be a string');
+    if (hasServiceWorker && "string" != typeof bg.service_worker) errors.push('MV3 (Firefox) "background.service_worker" must be a string when present');
+    if (hasPage && hasScripts) errors.push('MV3 (Firefox) "background" cannot have both "page" and "scripts"');
+    return errors;
+}
+function validateAction(action) {
+    if (null == action) return [];
+    if ("object" != typeof action) return [
+        '"action" must be an object'
+    ];
+    const act = action;
+    if (null != act.default_popup && "string" != typeof act.default_popup) return [
+        '"action.default_popup" must be a string'
+    ];
+    return [];
+}
+function validatePermissionsList(value, key) {
+    if (null == value) return [];
+    return isStringArray(value) ? [] : [
+        `"${key}" must be string[]`
+    ];
+}
+function isStringArray(value) {
+    return Array.isArray(value) && value.every((item)=>"string" == typeof item);
+}
+const loader_require = createRequire("u" > typeof __filename ? __filename : import.meta.url);
+function loadWithJiti(root, configPath) {
+    const isConfigRestart = "1" === process.env.ADDFOX_CONFIG_RESTART;
+    const jitiOptions = {
+        esmResolve: true
+    };
+    if (isConfigRestart) {
+        jitiOptions.moduleCache = false;
+        jitiOptions.requireCache = false;
+    }
+    const jitiFn = loader_require("jiti")(root, jitiOptions);
+    return jitiFn(configPath);
+}
+function loadNativeJs(configPath) {
+    const mod = loader_require(configPath);
+    return mod?.default ?? mod;
+}
+function unwrapConfig(mod) {
+    if (null == mod) return {};
+    if ("object" == typeof mod && "default" in mod && void 0 !== mod.default) return mod.default ?? {};
+    return mod ?? {};
+}
+function loadConfigModule(root, configPath, file) {
+    const isNativeJs = file.endsWith(".js") || file.endsWith(".mjs");
+    if (isNativeJs) try {
+        return unwrapConfig(loadNativeJs(configPath));
+    } catch  {}
+    return unwrapConfig(loadWithJiti(root, configPath));
+}
+function findConfigFile(root, configFiles) {
+    for (const file of configFiles){
+        const p = resolve(root, file);
+        if (existsSync(p)) return p;
+    }
+    return null;
+}
+function loadConfigAtPath(root, configPath, file) {
+    try {
+        return loadConfigModule(root, configPath, file);
+    } catch (e) {
+        const message = e instanceof Error ? e.message : String(e);
+        throw new AddfoxError({
+            code: ADDFOX_ERROR_CODES.CONFIG_LOAD_FAILED,
+            message: "Failed to load config file",
+            details: `File: ${configPath}, error: ${message}`,
+            hint: "Check addfox.config syntax and dependencies",
+            cause: e instanceof Error ? e : void 0
+        });
+    }
+}
+function loadConfigFile(root, configFiles = CONFIG_FILES) {
+    for (const file of configFiles){
+        const p = resolve(root, file);
+        if (existsSync(p)) return loadConfigAtPath(root, p, file);
+    }
+    return null;
+}
+function getResolvedConfigFilePath(root, configFiles = CONFIG_FILES) {
+    return findConfigFile(root, configFiles);
+}
+function resolveAppDir(root, userConfig) {
+    return resolve(root, userConfig.appDir ?? "app");
+}
+function validateAppDir(appDir, entryDisabled) {
+    if (entryDisabled) return;
+    if (!existsSync(appDir) || !statSync(appDir).isDirectory()) throw new AddfoxError({
+        code: ADDFOX_ERROR_CODES.APP_DIR_MISSING,
+        message: "App directory not found",
+        details: `Missing appDir: ${appDir}`,
+        hint: "Create the directory or set appDir to an existing folder (default is app/)"
+    });
+}
+function createResolvedConfig(userConfig, root, appDir, manifest) {
+    return {
+        ...userConfig,
+        manifest,
+        appDir,
+        outDir: userConfig.outDir ?? DEFAULT_OUT_DIR,
+        envPrefix: userConfig.envPrefix ?? [
+            ...DEFAULT_ENV_PREFIXES
+        ],
+        outputRoot: ADDFOX_OUTPUT_ROOT,
+        root
+    };
+}
+function discoverAndResolveEntries(userConfig, root, appDir, manifest, entryDiscovererOptions, entryResolverOptions) {
+    const baseEntries = discoverEntries(appDir, entryDiscovererOptions);
+    const result = resolveEntries(userConfig, root, appDir, manifest ?? void 0, entryResolverOptions);
+    return {
+        baseEntries,
+        entries: result.entries
+    };
+}
+function resolveAddfoxConfig(root, options = {}) {
+    const t0 = performance.now();
+    const userConfig = loadConfigFile(root, options.configFiles);
+    if (!userConfig) throw new AddfoxError({
+        code: ADDFOX_ERROR_CODES.CONFIG_NOT_FOUND,
+        message: "Addfox config file not found",
+        details: `No addfox.config.ts, addfox.config.js or addfox.config.mjs found under ${root}`,
+        hint: "Run the command from project root or create addfox.config.ts / addfox.config.js"
+    });
+    const appDir = resolveAppDir(root, userConfig);
+    const entryDisabled = false === userConfig.entry;
+    validateAppDir(appDir, entryDisabled);
+    const manifest = resolveManifestInput(userConfig.manifest, root, appDir);
+    if (!manifest) throw new AddfoxError({
+        code: ADDFOX_ERROR_CODES.MANIFEST_MISSING,
+        message: "Manifest config or file not found",
+        details: "Configure manifest in addfox.config, or place manifest.json / manifest.chromium.json / manifest.firefox.json under appDir or appDir/manifest",
+        hint: "Option 1: manifest: { name, version, ... } in addfox.config; Option 2: manifest.json under appDir or appDir/manifest; Option 3: manifest: { chromium: 'path/to/manifest.json' } (path relative to appDir)"
+    });
+    const config = createResolvedConfig(userConfig, root, appDir, manifest);
+    const manifestForEntry = "object" == typeof manifest && null !== manifest ? manifest.chromium ?? manifest.firefox ?? manifest : null;
+    const { baseEntries, entries } = entryDisabled ? {
+        baseEntries: [],
+        entries: []
+    } : discoverAndResolveEntries(userConfig, root, appDir, manifestForEntry, options.entryDiscovererOptions, options.entryResolverOptions);
+    if (!entryDisabled && 0 === entries.length) throw new AddfoxError({
+        code: ADDFOX_ERROR_CODES.NO_ENTRIES,
+        message: "No entries discovered",
+        details: `No background, content, popup, options or sidepanel entry found under ${appDir}`,
+        hint: "At least one such directory with index.ts / index.js etc. is required"
+    });
+    logDoneTimed("Parse config", Math.round(performance.now() - t0));
+    logEntriesTable(entries, {
+        root
+    });
+    return {
+        config,
+        baseEntries,
+        entries
+    };
+}
+function clearConfigCache(configFilePath) {
+    try {
+        delete loader_require.cache[configFilePath];
+    } catch  {}
+    for (const key of Object.keys(loader_require.cache)){
+        const mod = loader_require.cache[key];
+        if (mod?.filename === configFilePath) try {
+            delete loader_require.cache[key];
+        } catch  {}
+    }
+}
+function getResolvedRstestConfigFilePath(root) {
+    for (const file of RSTEST_CONFIG_FILES){
+        const p = resolve(root, file);
+        if (existsSync(p)) return p;
+    }
+    return null;
+}
+const ADDFOX_PLACEHOLDER_REGEX = /\[addfox\.([a-z]+)\]/g;
+const CONTENT_PLACEHOLDER = "[addfox.content]";
+const CONTENT_PLACEHOLDER_LEGACY = "[addfox.content]";
+const SCRIPT_KEYS_SET = new Set(SCRIPT_ONLY_ENTRY_NAMES);
+function builder_isSourceFilePath(path) {
+    const lower = path.trim().toLowerCase();
+    return /\.(ts|tsx|js|jsx)$/.test(lower);
+}
+function isChromiumFirefoxManifest(m) {
+    return "object" == typeof m && null !== m && ("chromium" in m || "firefox" in m);
+}
+function isEntryFieldEmpty(value) {
+    if (null == value) return true;
+    if ("string" == typeof value) return "" === value.trim();
+    if (Array.isArray(value)) return 0 === value.length;
+    return false;
+}
+function hasNonEmptyStringArray(value) {
+    return Array.isArray(value) && value.length > 0;
+}
+function isManifestRecord(value) {
+    return null !== value && "object" == typeof value && !Array.isArray(value);
+}
+function getManifestRecordForTarget(config, target) {
+    return pickManifestForTarget(config, target).manifest;
+}
+function pickManifestForTarget(config, target) {
+    if (!isChromiumFirefoxManifest(config)) return {
+        manifest: config
+    };
+    const hasChromium = null != config.chromium && "object" == typeof config.chromium;
+    const hasFirefox = null != config.firefox && "object" == typeof config.firefox;
+    if (hasChromium && hasFirefox) {
+        const match = config[target];
+        if (null != match && "object" == typeof match) return {
+            manifest: match
+        };
+        const fallback = "firefox" === target ? config.chromium : config.firefox;
+        return {
+            manifest: fallback,
+            warnMessage: `Build target is ${target} but manifest.${target} is missing; using ${"firefox" === target ? "chromium" : "firefox"} manifest.`
+        };
+    }
+    if (hasChromium) return {
+        manifest: config.chromium,
+        warnMessage: "firefox" === target ? "Build target is firefox but manifest only has chromium; using chromium manifest." : void 0
+    };
+    if (hasFirefox) return {
+        manifest: config.firefox,
+        warnMessage: "chromium" === target ? "Build target is chromium but manifest only has firefox; using firefox manifest." : void 0
+    };
+    return {
+        manifest: config.chromium ?? config.firefox ?? {},
+        warnMessage: "Manifest has no chromium or firefox object; using fallback."
+    };
+}
+function buildScriptOutputPath(entry) {
+    const scriptStem = external_path_basename(entry.scriptPath, extname(entry.scriptPath));
+    return scriptStem === entry.name ? `${entry.name}.js` : `${entry.name}/index.js`;
+}
+function buildHtmlOutputPath(entry, fallback) {
+    if (!entry.htmlPath) return fallback;
+    const htmlFile = external_path_basename(entry.htmlPath).toLowerCase();
+    return htmlFile === `${entry.name}.html` ? `${entry.name}.html` : fallback;
+}
+function buildPlaceholderMap(entries) {
+    const map = {};
+    for (const key of MANIFEST_ENTRY_KEYS){
+        const entry = entries.find((e)=>e.name === key);
+        if (entry) map[key] = SCRIPT_KEYS_SET.has(key) ? buildScriptOutputPath(entry) : buildHtmlOutputPath(entry, MANIFEST_ENTRY_PATHS[key]);
+    }
+    return map;
+}
+function buildSourceToOutputMap(entries) {
+    const map = new Map();
+    const placeholderMap = buildPlaceholderMap(entries);
+    for (const key of MANIFEST_ENTRY_KEYS){
+        const entry = entries.find((e)=>e.name === key);
+        if (!entry) continue;
+        const sourcePath = entry.scriptPath;
+        const outputPath = placeholderMap[key];
+        if (sourcePath && outputPath) {
+            map.set(sourcePath, outputPath);
+            const basename = sourcePath.split(/[\\/]/).pop();
+            if (basename) {
+                map.set(basename, outputPath);
+                map.set(`./${basename}`, outputPath);
+            }
+            const entryDir = key;
+            const entryIndexPath = `${entryDir}/${basename}`;
+            map.set(entryIndexPath, outputPath);
+            map.set(`./${entryIndexPath}`, outputPath);
+        }
+    }
+    return map;
+}
+function shouldUseServiceWorker(mv, browser) {
+    return 3 === mv && "chromium" === browser;
+}
+function isChromiumOnlyAutofillKey(key) {
+    return "sidepanel" === key || "newtab" === key || "bookmarks" === key || "history" === key;
+}
+const fillers = {
+    background: (mv, browser)=>(out, path)=>{
+            const bg = out.background ?? {};
+            if (shouldUseServiceWorker(mv, browser)) {
+                if (isEntryFieldEmpty(bg.service_worker)) out.background = {
+                    ...bg,
+                    service_worker: path
+                };
+            } else {
+                const scripts = bg.scripts;
+                if (!Array.isArray(scripts) || 0 === scripts.length) out.background = {
+                    ...bg,
+                    scripts: [
+                        path
+                    ]
+                };
+            }
+        },
+    popup: (mv)=>(out, path)=>{
+            if (3 === mv) {
+                const action = out.action ?? {};
+                if (isEntryFieldEmpty(action.default_popup)) out.action = {
+                    ...action,
+                    default_popup: path
+                };
+            } else {
+                const ba = out.browser_action ?? {};
+                if (isEntryFieldEmpty(ba.default_popup)) out.browser_action = {
+                    ...ba,
+                    default_popup: path
+                };
+            }
+        },
+    options: (mv)=>(out, path)=>{
+            if (3 === mv) {
+                const opt = out.options_ui ?? {};
+                if (isEntryFieldEmpty(opt.page)) out.options_ui = {
+                    ...opt,
+                    page: path
+                };
+            } else if (isEntryFieldEmpty(out.options_page)) out.options_page = path;
+        },
+    devtools: ()=>(out, path)=>{
+            if (isEntryFieldEmpty(out.devtools_page)) out.devtools_page = path;
+        },
+    sandbox: ()=>(out, path)=>{
+            const sandbox = out.sandbox;
+            if (null === sandbox || "object" != typeof sandbox || Array.isArray(sandbox)) {
+                out.sandbox = {
+                    pages: [
+                        path
+                    ]
+                };
+                return;
+            }
+            const pages = sandbox.pages;
+            if (!Array.isArray(pages) || 0 === pages.length) out.sandbox = {
+                ...sandbox,
+                pages: [
+                    path
+                ]
+            };
+        },
+    content: ()=>(out, path)=>{
+            const cs = out.content_scripts;
+            if (!Array.isArray(cs) || 0 === cs.length) out.content_scripts = [
+                {
+                    matches: [
+                        "<all_urls>"
+                    ],
+                    js: [
+                        path
+                    ],
+                    run_at: "document_idle"
+                }
+            ];
+        },
+    newtab: ()=>(out, path)=>{
+            const overrides = out.chrome_url_overrides ?? {};
+            if (isEntryFieldEmpty(overrides.newtab)) out.chrome_url_overrides = {
+                ...overrides,
+                newtab: path
+            };
+        },
+    bookmarks: ()=>(out, path)=>{
+            const overrides = out.chrome_url_overrides ?? {};
+            if (isEntryFieldEmpty(overrides.bookmarks)) out.chrome_url_overrides = {
+                ...overrides,
+                bookmarks: path
+            };
+            ensurePermission(out, "bookmarks");
+        },
+    history: ()=>(out, path)=>{
+            const overrides = out.chrome_url_overrides ?? {};
+            if (isEntryFieldEmpty(overrides.history)) out.chrome_url_overrides = {
+                ...overrides,
+                history: path
+            };
+            ensurePermission(out, "history");
+        },
+    sidepanel: ()=>(out, path)=>{
+            const sp = out.side_panel ?? {};
+            if (isEntryFieldEmpty(sp.default_path)) out.side_panel = {
+                ...sp,
+                default_path: path
+            };
+        }
+};
+function ensurePermission(out, permission) {
+    const current = out.permissions;
+    if (!Array.isArray(current)) {
+        out.permissions = [
+            permission
+        ];
+        return;
+    }
+    if (!current.includes(permission)) out.permissions = [
+        ...current,
+        permission
+    ];
+}
+function buildAutoFillers(mv, browser) {
+    const result = {};
+    for (const [key, factory] of Object.entries(fillers))if ("sidepanel" !== key || 3 === mv) {
+        if (!("firefox" === browser && isChromiumOnlyAutofillKey(key))) result[key] = factory(mv, browser);
+    }
+    return result;
+}
+function needsSidePanelPermission(out, placeholderMap, browser) {
+    if ("chromium" !== browser) return false;
+    if (null != placeholderMap.sidepanel) return true;
+    const sp = out.side_panel;
+    if (null == sp || "object" != typeof sp || Array.isArray(sp)) return false;
+    const path = sp.default_path;
+    return "string" == typeof path && "" !== path.trim();
+}
+function autoFillEntryFields(manifest, placeholderMap, browser) {
+    const mv = 2 === manifest.manifest_version ? 2 : 3;
+    const out = {
+        ...manifest
+    };
+    const autoFillers = buildAutoFillers(mv, browser);
+    for (const [key, path] of Object.entries(placeholderMap))autoFillers[key]?.(out, path);
+    if (3 === mv && needsSidePanelPermission(out, placeholderMap, browser)) ensurePermission(out, "sidePanel");
+    return out;
+}
+function replacePlaceholderInString(str, placeholderMap) {
+    return str.replace(ADDFOX_PLACEHOLDER_REGEX, (_, key)=>key in placeholderMap ? placeholderMap[key] : `[addfox.${key}]`);
+}
+function replacePlaceholdersInValue(value, placeholderMap) {
+    if ("string" == typeof value) return replacePlaceholderInString(value, placeholderMap);
+    if (Array.isArray(value)) return value.map((item)=>replacePlaceholdersInValue(item, placeholderMap));
+    if (null !== value && "object" == typeof value) {
+        const out = {};
+        for (const [k, v] of Object.entries(value))out[k] = replacePlaceholdersInValue(v, placeholderMap);
+        return out;
+    }
+    return value;
+}
+function replaceSourcePathsWithOutput(value, sourceToOutputMap) {
+    if ("string" == typeof value) {
+        if (builder_isSourceFilePath(value)) {
+            const outputPath = sourceToOutputMap.get(value);
+            if (outputPath) return outputPath;
+            const basename = value.split(/[\\/]/).pop();
+            if (basename) {
+                const fromBasename = sourceToOutputMap.get(basename);
+                if (fromBasename) return fromBasename;
+                const fromDotSlash = sourceToOutputMap.get(`./${basename}`);
+                if (fromDotSlash) return fromDotSlash;
+            }
+        }
+        return value;
+    }
+    if (Array.isArray(value)) return value.map((item)=>replaceSourcePathsWithOutput(item, sourceToOutputMap));
+    if (null !== value && "object" == typeof value) {
+        const out = {};
+        for (const [k, v] of Object.entries(value))out[k] = replaceSourcePathsWithOutput(v, sourceToOutputMap);
+        return out;
+    }
+    return value;
+}
+function resolveContentScriptsPlaceholders(manifest, placeholderMap, contentScriptOutput) {
+    const contentScripts = manifest.content_scripts;
+    if (!Array.isArray(contentScripts)) return manifest;
+    const defaultContentJs = placeholderMap.content ? [
+        placeholderMap.content
+    ] : [];
+    const shouldAutoFillCss = contentScriptOutput?.autoFillCssInManifest !== false;
+    const resolved = contentScripts.map((item)=>{
+        if (null === item || "object" != typeof item || Array.isArray(item)) return item;
+        const obj = item;
+        const out = {
+            ...obj
+        };
+        if (Array.isArray(obj.js)) {
+            const jsReplacement = contentScriptOutput?.js ?? defaultContentJs;
+            out.js = obj.js.flatMap((el)=>el === CONTENT_PLACEHOLDER || el === CONTENT_PLACEHOLDER_LEGACY ? jsReplacement : [
+                    el
+                ]);
+        }
+        if (Array.isArray(obj.css)) {
+            const cssReplacement = contentScriptOutput?.css ?? [];
+            const resolvedCss = obj.css.flatMap((el)=>el === CONTENT_PLACEHOLDER || el === CONTENT_PLACEHOLDER_LEGACY ? cssReplacement : [
+                    el
+                ]);
+            if (resolvedCss.length > 0) out.css = resolvedCss;
+            else delete out.css;
+        }
+        const hadJs = hasNonEmptyStringArray(out.js);
+        const hadCss = hasNonEmptyStringArray(out.css);
+        if (!hadJs && !hadCss && placeholderMap.content) out.js = contentScriptOutput?.js ?? defaultContentJs;
+        const hasJs = hasNonEmptyStringArray(out.js);
+        const isContentItem = hasJs && null != placeholderMap.content && out.js.includes(placeholderMap.content);
+        if (shouldAutoFillCss && isContentItem && contentScriptOutput?.css?.length && !hasNonEmptyStringArray(out.css)) out.css = contentScriptOutput.css;
+        return out;
+    });
+    return {
+        ...manifest,
+        content_scripts: resolved
+    };
+}
+function replaceContentScriptSourcePaths(manifest, sourceToOutputMap) {
+    const contentScripts = manifest.content_scripts;
+    if (!Array.isArray(contentScripts)) return manifest;
+    const resolved = contentScripts.map((item)=>{
+        if (null === item || "object" != typeof item || Array.isArray(item)) return item;
+        const obj = item;
+        const out = {
+            ...obj
+        };
+        if (Array.isArray(obj.js)) out.js = obj.js.map((path)=>{
+            if ("string" == typeof path && builder_isSourceFilePath(path)) {
+                const outputPath = sourceToOutputMap.get(path);
+                if (outputPath) return outputPath;
+                const basename = path.split(/[\\/]/).pop();
+                if (basename) {
+                    const fromBasename = sourceToOutputMap.get(basename);
+                    if (fromBasename) return fromBasename;
+                }
+            }
+            return path;
+        });
+        return out;
+    });
+    return {
+        ...manifest,
+        content_scripts: resolved
+    };
+}
+function buildManifest(manifest, entries, browser, contentScriptOutput) {
+    const placeholderMap = buildPlaceholderMap(entries);
+    const sourceToOutputMap = buildSourceToOutputMap(entries);
+    const pipeline = [
+        (m)=>autoFillEntryFields(m, placeholderMap, browser),
+        (m)=>resolveContentScriptsPlaceholders(m, placeholderMap, contentScriptOutput),
+        (m)=>replaceSourcePathsWithOutput(m, sourceToOutputMap),
+        (m)=>replaceContentScriptSourcePaths(m, sourceToOutputMap),
+        (m)=>replacePlaceholdersInValue(m, placeholderMap)
+    ];
+    const result = pipeline.reduce((acc, fn)=>fn(acc), {
+        ...manifest
+    });
+    return isManifestRecord(result) ? result : manifest;
+}
+function buildForBrowser(config, entries, browser, onWarn, contentScriptOutput) {
+    const { manifest, warnMessage } = pickManifestForTarget(config, browser);
+    if (warnMessage) onWarn?.(warnMessage);
+    return buildManifest(manifest, entries, browser, contentScriptOutput);
+}
+function resolveManifestChromium(config, entries) {
+    return buildForBrowser(config, entries, "chromium");
+}
+function resolveManifestFirefox(config, entries) {
+    return buildForBrowser(config, entries, "firefox");
+}
+function resolveManifestForTarget(config, entries, target, onWarn, contentScriptOutput) {
+    return buildForBrowser(config, entries, target, onWarn, contentScriptOutput);
+}
+function toReloadManagerEntries(entries, root) {
+    return entries.filter((e)=>RELOAD_MANAGER_ENTRY_NAMES.has(e.name)).map((e)=>({
+            name: e.name,
+            path: resolve(root, e.scriptPath)
+        }));
+}
+const version_require = external_node_module_createRequire(import.meta.url);
+function findPackageJson() {
+    const __dirname = external_node_path_dirname(fileURLToPath(import.meta.url));
+    const distPath = external_node_path_resolve(__dirname, "../../package.json");
+    if (external_node_fs_existsSync(distPath)) return version_require(distPath);
+    const srcPath = external_node_path_resolve(__dirname, "../package.json");
+    if (external_node_fs_existsSync(srcPath)) return version_require(srcPath);
+    return {};
+}
+const version_pkg = findPackageJson();
+function getAddfoxVersion() {
+    return version_pkg?.version ?? "0.0.0";
+}
+const FRAMEWORK_KEYS = [
+    {
+        pkg: "solid-js",
+        name: "Solid"
+    },
+    {
+        pkg: "svelte",
+        name: "Svelte"
+    },
+    {
+        pkg: "vue",
+        name: "Vue"
+    },
+    {
+        pkg: "preact",
+        name: "Preact"
+    },
+    {
+        pkg: "react",
+        name: "React"
+    }
+];
+function readPackageJson(root) {
+    const path = join(root, "package.json");
+    if (!external_node_fs_existsSync(path)) return null;
+    try {
+        const raw = external_node_fs_readFileSync(path, "utf-8");
+        return JSON.parse(raw);
+    } catch  {
+        return null;
+    }
+}
+function hasDep(pkg, key) {
+    const deps = pkg.dependencies;
+    const devDeps = pkg.devDependencies;
+    if (deps && "string" == typeof deps[key]) return true;
+    if (devDeps && "string" == typeof devDeps[key]) return true;
+    return false;
+}
+function detectFrontendFramework(root) {
+    if (!root || "string" != typeof root) return "Vanilla";
+    const pkg = readPackageJson(root);
+    if (!pkg) return "Vanilla";
+    for (const { pkg: key, name } of FRAMEWORK_KEYS)if (hasDep(pkg, key)) return name;
+    return "Vanilla";
+}
+var src_DEFAULT_APP_DIR = "app";
+var src_HMR_WS_PORT = 23333;
+export { Pipeline } from "./434.js";
+export { ADDFOX_OUTPUT_ROOT, BROWSER_OUTPUT_PREFIX, CLI_COMMANDS, CONFIG_FILES, DEFAULT_BROWSER, DEFAULT_ENV_PREFIXES, DEFAULT_OUT_DIR, HTML_ENTRY_NAMES, MANIFEST_DIR, MANIFEST_ENTRY_KEYS, MANIFEST_ENTRY_PATHS, MANIFEST_FILE_NAMES, ManifestLoader, RELOAD_MANAGER_ENTRY_NAMES, RESERVED_ENTRY_NAMES, RSTEST_CONFIG_FILES, SCRIPT_EXTS, SCRIPT_ONLY_ENTRY_NAMES, SUPPORTED_BROWSERS, SUPPORTED_LAUNCH_TARGETS, buildForBrowser, clearConfigCache, defineConfig, detectFrontendFramework, discoverEntries, extractEntriesFromManifest, getAddfoxVersion, getAllEntryNames, getBrowserOutputDir, getHtmlEntryNames, getManifestRecordForTarget, getResolvedConfigFilePath, getResolvedRstestConfigFilePath, getScriptInjectIfMatches, getScriptOnlyEntryNames, isScriptSrcRelative, loadConfigFile, parseAddfoxEntryFromHtml, resolveAddfoxConfig, resolveEntries, resolveManifestChromium, resolveManifestFirefox, resolveManifestForTarget, resolveManifestInput, resolveScriptFromHtmlStrict, src_DEFAULT_APP_DIR as DEFAULT_APP_DIR, src_HMR_WS_PORT as HMR_WS_PORT, toReloadManagerEntries };
+
+//# sourceMappingURL=index.js.map