firefox-css-theme 0.2.0

package/dist/commands/start.js

@@ -0,0 +1,89 @@
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { firefoxManager } from "../firefox.js";
+import { compileCssFile } from "../processor.js";
+import { resolveProfileDirectoryByName } from "../profiles.js";
+import { ROOT_USER_CHROME_ID, ROOT_USER_CONTENT_ID } from "../registry.js";
+import { fileWatcher } from "../watcher.js";
+async function processAndInjectCss(srcPath, destPath, id, target) {
+    if (!existsSync(srcPath)) {
+        if (target === "content") {
+            await firefoxManager.removeContentStyle(id).catch(() => { });
+        }
+        else {
+            await firefoxManager.removeChromeStyle(id).catch(() => { });
+        }
+        return undefined;
+    }
+    try {
+        const compilationResult = await compileCssFile(srcPath, destPath);
+        if (target === "content") {
+            await firefoxManager.injectContentStyle(compilationResult.css, id, srcPath);
+        }
+        else {
+            await firefoxManager.injectChromeStyle(compilationResult.css, id, srcPath);
+        }
+        console.log(`\x1b[32m[reloaded]\x1b[0m ${id} (${srcPath})`);
+        return compilationResult.importedFiles;
+    }
+    catch (error) {
+        console.error(`\x1b[31m[build error]\x1b[0m ${srcPath}:`, error instanceof Error ? error.message : error);
+        return undefined;
+    }
+}
+/**
+ * Starts a Firefox instance, compiles and injects theme stylesheets, and
+ * initiates live watching.
+ */
+export async function startCommand(options = {}) {
+    let profileDirectory;
+    if (options.profileName) {
+        profileDirectory = resolveProfileDirectoryByName(options.profileName);
+        console.log(`Using profile: \x1b[1m${options.profileName}\x1b[0m`);
+    }
+    else {
+        console.log("Using temporary profile.");
+    }
+    const destChromePath = path.resolve(process.cwd(), ".dist", "userChrome.css");
+    const destContentPath = path.resolve(process.cwd(), ".dist", "userContent.css");
+    const srcChromePath = path.resolve(process.cwd(), options.chromePath || "userChrome.css");
+    const srcContentPath = path.resolve(process.cwd(), options.contentPath || "userContent.css");
+    const chromeTarget = {
+        filePaths: [srcChromePath],
+        onChange: async () => {
+            const importedFiles = await processAndInjectCss(srcChromePath, destChromePath, ROOT_USER_CHROME_ID, "chrome");
+            fileWatcher.updateFilePaths(chromeTarget, [
+                srcChromePath,
+                ...(importedFiles || []),
+            ]);
+        },
+    };
+    fileWatcher.addTarget(chromeTarget);
+    const contentTarget = {
+        filePaths: [srcContentPath],
+        onChange: async () => {
+            const importedFiles = await processAndInjectCss(srcContentPath, destContentPath, ROOT_USER_CONTENT_ID, "content");
+            fileWatcher.updateFilePaths(contentTarget, [
+                srcContentPath,
+                ...(importedFiles || []),
+            ]);
+        },
+    };
+    fileWatcher.addTarget(contentTarget);
+    console.log("Launching Firefox instance...");
+    await firefoxManager.initialiseBrowser(options.binaryPath, options.profileName, options.headless, options.novaUi);
+    if (options.watch !== false) {
+        await fileWatcher.start();
+        console.log("Live watcher active. Press Ctrl+C to quit.\n");
+    }
+    await chromeTarget.onChange();
+    await contentTarget.onChange();
+    const handleShutdown = async () => {
+        console.log("\nShutting down Firefox...");
+        await fileWatcher.close().catch(() => { });
+        await firefoxManager.terminateBrowser().catch(() => { });
+        process.exit(0);
+    };
+    process.on("SIGINT", handleShutdown);
+    process.on("SIGTERM", handleShutdown);
+}

package/dist/commands/styles.js

@@ -0,0 +1 @@
+export {};

package/dist/firefox.js

@@ -0,0 +1,366 @@
+import { Builder, By } from "selenium-webdriver";
+import * as firefox from "selenium-webdriver/firefox.js";
+import { resolveProfileDirectoryByName } from "./profiles.js";
+import { styleRegistry } from "./registry.js";
+export class FirefoxManager {
+    driver = null;
+    async initialiseBrowser(binaryPath, profileName, headless, novaUi) {
+        if (this.driver)
+            return;
+        const isNovaUiEnabled = novaUi ?? process.argv.includes("--nova-ui");
+        const isHeadlessEnabled = headless ?? process.argv.includes("--headless");
+        const options = new firefox.Options();
+        options.addArguments("-no-remote", "-new-instance");
+        if (isHeadlessEnabled)
+            options.addArguments("-headless");
+        options.setPreference("devtools.chrome.enabled", true);
+        options.setPreference("devtools.debugger.remote-enabled", true);
+        options.setPreference("devtools.debugger.prompt-connection", false);
+        options.setPreference("toolkit.legacyUserProfileCustomizations.stylesheets", true);
+        options.setPreference("marionette.allow-system-access", true);
+        options.setPreference("remote.allow-system-access", true);
+        options.setPreference("browser.nova.enabled", isNovaUiEnabled);
+        options.setPreference("browser.newtabpage.activity-stream.nova.enabled", isNovaUiEnabled);
+        if (binaryPath)
+            options.setBinary(binaryPath);
+        if (profileName) {
+            const profileDirectory = resolveProfileDirectoryByName(profileName);
+            options.setProfile(profileDirectory);
+        }
+        const service = new firefox.ServiceBuilder()
+            .enableVerboseLogging(true)
+            .addArguments("--allow-system-access");
+        try {
+            this.driver = await new Builder()
+                .forBrowser("firefox")
+                .setFirefoxOptions(options)
+                .setFirefoxService(service)
+                .build();
+            await this.ensureChromeContext();
+            if (!isHeadlessEnabled) {
+                await this.openBrowserToolbox().catch(() => { });
+            }
+        }
+        catch (error) {
+            if (this.driver) {
+                await this.driver.quit().catch(() => { });
+                this.driver = null;
+            }
+            throw error;
+        }
+    }
+    async terminateBrowser() {
+        if (!this.driver)
+            return;
+        await this.driver.quit();
+        this.driver = null;
+    }
+    async ensureChromeContext() {
+        if (!this.driver) {
+            throw new Error("Firefox driver instance is not initialised.");
+        }
+        await this.driver.setContext("chrome");
+    }
+    async executeChromeScript(script, ...argumentsList) {
+        await this.ensureChromeContext();
+        return (await this.driver.executeScript(script, ...argumentsList));
+    }
+    async queryElements(selector) {
+        await this.ensureChromeContext();
+        return await this.executeChromeScript((querySelector) => {
+            const matchedElements = Array.from(document.querySelectorAll(querySelector));
+            return matchedElements.map((element) => {
+                const attributeMap = {};
+                for (const attribute of Array.from(element.attributes)) {
+                    attributeMap[attribute.name] = attribute.value;
+                }
+                return {
+                    tagName: element.tagName.toLowerCase(),
+                    id: element.id || "",
+                    className: element.className || "",
+                    childCount: element.children.length,
+                    textContent: (element.textContent || "")
+                        .trim()
+                        .slice(0, 100),
+                    attributes: attributeMap,
+                };
+            });
+        }, selector);
+    }
+    async getComputedStyles(selector, stylePropertyNames) {
+        await this.ensureChromeContext();
+        return await this.executeChromeScript((targetSelector, requestedProperties) => {
+            const targetElement = document.querySelector(targetSelector);
+            if (!targetElement) {
+                throw new Error("Element not found for selector: " + targetSelector);
+            }
+            const computedStyleDeclaration = window.getComputedStyle(targetElement);
+            const styleResult = {};
+            if (Array.isArray(requestedProperties) &&
+                requestedProperties.length > 0) {
+                for (const propertyName of requestedProperties) {
+                    styleResult[propertyName] =
+                        computedStyleDeclaration.getPropertyValue(propertyName);
+                }
+            }
+            else {
+                for (let index = 0; index < computedStyleDeclaration.length; index++) {
+                    const propertyName = computedStyleDeclaration[index];
+                    styleResult[propertyName] =
+                        computedStyleDeclaration.getPropertyValue(propertyName);
+                }
+            }
+            return styleResult;
+        }, selector, stylePropertyNames);
+    }
+    async getUiTree(rootSelector = "window", maxDepth = 3) {
+        await this.ensureChromeContext();
+        return await this.executeChromeScript((targetSelector, maximumTraversalDepth) => {
+            const rootTarget = targetSelector === "window"
+                ? document.documentElement
+                : document.querySelector(targetSelector);
+            if (!rootTarget) {
+                throw new Error("Root element not found for selector: " +
+                    targetSelector);
+            }
+            const rootNodeHierarchy = {
+                tagName: rootTarget.tagName.toLowerCase(),
+                id: rootTarget.id || "",
+                className: rootTarget.className || "",
+                attributes: {},
+                children: [],
+            };
+            for (const attribute of Array.from(rootTarget.attributes)) {
+                rootNodeHierarchy.attributes[attribute.name] =
+                    attribute.value;
+            }
+            const nodeQueue = [
+                {
+                    domNode: rootTarget,
+                    hierarchyNode: rootNodeHierarchy,
+                    currentDepth: 0,
+                },
+            ];
+            while (nodeQueue.length > 0) {
+                const queueItem = nodeQueue.shift();
+                if (!queueItem ||
+                    queueItem.currentDepth >= maximumTraversalDepth) {
+                    continue;
+                }
+                for (const childElement of Array.from(queueItem.domNode.children)) {
+                    const childAttributes = {};
+                    for (const attribute of Array.from(childElement.attributes)) {
+                        childAttributes[attribute.name] = attribute.value;
+                    }
+                    const childHierarchyNode = {
+                        tagName: childElement.tagName.toLowerCase(),
+                        id: childElement.id || "",
+                        className: childElement.className || "",
+                        attributes: childAttributes,
+                        children: [],
+                    };
+                    queueItem.hierarchyNode.children.push(childHierarchyNode);
+                    nodeQueue.push({
+                        domNode: childElement,
+                        hierarchyNode: childHierarchyNode,
+                        currentDepth: queueItem.currentDepth + 1,
+                    });
+                }
+            }
+            return rootNodeHierarchy;
+        }, rootSelector, maxDepth);
+    }
+    async customiseToolbar(action = "enter") {
+        await this.ensureChromeContext();
+        return await this.executeChromeScript(async (requestedAction) => {
+            const customizeMode = window.gCustomizeMode;
+            const documentElement = document.documentElement;
+            if (!customizeMode) {
+                const customizeCommand = document.getElementById("cmd_CustomizeToolbars");
+                if (customizeCommand) {
+                    customizeCommand.doCommand();
+                    return {
+                        isCustomising: documentElement.hasAttribute("customizing"),
+                        success: true,
+                    };
+                }
+                throw new Error("Customise toolbar mode is not available in the current context.");
+            }
+            const isCurrentlyCustomising = documentElement.hasAttribute("customizing") ||
+                Boolean(customizeMode.visible);
+            const shouldEnter = requestedAction === "enter";
+            if (shouldEnter !== isCurrentlyCustomising) {
+                const transitionEventName = shouldEnter
+                    ? "customizationready"
+                    : "aftercustomization";
+                await new Promise((resolve) => {
+                    const timeout = setTimeout(resolve, 5000);
+                    window.addEventListener(transitionEventName, () => {
+                        clearTimeout(timeout);
+                        resolve();
+                    }, { once: true });
+                    customizeMode[requestedAction]();
+                });
+            }
+            return {
+                isCustomising: documentElement.hasAttribute("customizing") ||
+                    Boolean(customizeMode.visible),
+                success: true,
+            };
+        }, action);
+    }
+    async customizeToolbar(action = "enter") {
+        return this.customiseToolbar(action);
+    }
+    async injectChromeStyle(css, id = "mcp-injected-style", srcPath) {
+        await this.ensureChromeContext();
+        const result = await this.executeChromeScript((id, cssSource) => {
+            let existingStyleElement = document.getElementById(id);
+            if (!existingStyleElement) {
+                existingStyleElement = document.createElement("style");
+                existingStyleElement.id = id;
+                existingStyleElement.setAttribute("type", "text/css");
+                document.documentElement.appendChild(existingStyleElement);
+            }
+            existingStyleElement.textContent = cssSource;
+            return { id: id, success: true };
+        }, id, css);
+        styleRegistry.register(id, srcPath, "chrome");
+        return result;
+    }
+    async injectContentStyle(css, id = "mcp-injected-content-style", srcPath) {
+        await this.ensureChromeContext();
+        const result = await this.executeChromeScript((id, cssSource) => {
+            const win = window;
+            win.__injectedContentSheets =
+                win.__injectedContentSheets || new Map();
+            const prevUriStr = win.__injectedContentSheets.get(id);
+            const sss = globalThis.Cc["@mozilla.org/content/style-sheet-service;1"].getService(globalThis.Ci.nsIStyleSheetService);
+            const ioService = globalThis.Cc["@mozilla.org/network/io-service;1"].getService(globalThis.Ci.nsIIOService);
+            if (prevUriStr) {
+                try {
+                    const prevUri = ioService.newURI(prevUriStr);
+                    if (sss.sheetRegistered(prevUri, sss.USER_SHEET)) {
+                        sss.unregisterSheet(prevUri, sss.USER_SHEET);
+                    }
+                }
+                catch { }
+            }
+            const newUriStr = "data:text/css;charset=utf-8," +
+                encodeURIComponent(cssSource);
+            const newUri = ioService.newURI(newUriStr);
+            if (!sss.sheetRegistered(newUri, sss.USER_SHEET)) {
+                sss.loadAndRegisterSheet(newUri, sss.USER_SHEET);
+            }
+            win.__injectedContentSheets.set(id, newUriStr);
+            return { id: id, success: true };
+        }, id, css);
+        styleRegistry.register(id, srcPath, "content");
+        return result;
+    }
+    async removeChromeStyle(id) {
+        await this.ensureChromeContext();
+        const result = await this.executeChromeScript((id) => {
+            const targetStyleElement = document.getElementById(id);
+            if (targetStyleElement) {
+                targetStyleElement.remove();
+                return { id: id, removed: true };
+            }
+            return { id: id, removed: false };
+        }, id);
+        styleRegistry.unregister(id);
+        return result;
+    }
+    async removeContentStyle(id) {
+        await this.ensureChromeContext();
+        const result = await this.executeChromeScript((id) => {
+            let removed = false;
+            const win = window;
+            if (win.__injectedContentSheets?.has(id)) {
+                const uriStr = win.__injectedContentSheets.get(id);
+                try {
+                    const sss = globalThis.Cc["@mozilla.org/content/style-sheet-service;1"].getService(globalThis.Ci.nsIStyleSheetService);
+                    const ioService = globalThis.Cc["@mozilla.org/network/io-service;1"].getService(globalThis.Ci.nsIIOService);
+                    const uri = ioService.newURI(uriStr);
+                    if (sss.sheetRegistered(uri, sss.USER_SHEET)) {
+                        sss.unregisterSheet(uri, sss.USER_SHEET);
+                    }
+                    removed = true;
+                }
+                catch { }
+                win.__injectedContentSheets.delete(id);
+            }
+            return { id: id, removed: removed };
+        }, id);
+        styleRegistry.unregister(id);
+        return result;
+    }
+    async listChromeStyles() {
+        await this.ensureChromeContext();
+        const domStyles = await this.executeChromeScript(() => {
+            const styleElements = Array.from(document.querySelectorAll("style[id]"));
+            return styleElements.map((element) => ({
+                id: element.id,
+                length: element.textContent ? element.textContent.length : 0,
+            }));
+        });
+        return domStyles.map((item) => {
+            const registration = styleRegistry.get(item.id);
+            return {
+                id: item.id,
+                length: item.length,
+                srcPath: registration?.srcPath,
+                target: "chrome",
+            };
+        });
+    }
+    async listContentStyles() {
+        await this.ensureChromeContext();
+        const contentStyles = await this.executeChromeScript(() => {
+            const win = window;
+            const styles = [];
+            if (win.__injectedContentSheets) {
+                for (const [id, uriStr,] of win.__injectedContentSheets.entries()) {
+                    styles.push({
+                        id: id,
+                        length: decodeURIComponent(uriStr.replace(/^data:text\/css;charset=utf-8,/, "")).length,
+                    });
+                }
+            }
+            return styles;
+        });
+        return contentStyles.map((item) => {
+            const registration = styleRegistry.get(item.id);
+            return {
+                id: item.id,
+                length: item.length,
+                srcPath: registration?.srcPath,
+                target: "content",
+            };
+        });
+    }
+    async getScreenshot(targetSelector) {
+        await this.ensureChromeContext();
+        if (targetSelector) {
+            const targetWebElement = await this.driver.findElement(By.css(targetSelector));
+            const elementScreenshotBase64 = await targetWebElement.takeScreenshot();
+            return { base64Image: elementScreenshotBase64, format: "png" };
+        }
+        const fullWindowScreenshotBase64 = await this.driver.takeScreenshot();
+        return { base64Image: fullWindowScreenshotBase64, format: "png" };
+    }
+    async openBrowserToolbox() {
+        await this.ensureChromeContext();
+        return await this.executeChromeScript(() => {
+            try {
+                const { BrowserToolboxLauncher } = ChromeUtils.importESModule("resource://devtools/client/framework/browser-toolbox/Launcher.sys.mjs");
+                BrowserToolboxLauncher.init();
+                return { success: true };
+            }
+            catch {
+                return { success: false };
+            }
+        });
+    }
+}
+export const firefoxManager = new FirefoxManager();

package/dist/index.js

@@ -0,0 +1,11 @@
+export * from "./types.js";
+export { FirefoxManager, firefoxManager } from "./firefox.js";
+export { compileCssFile, compileCssString } from "./processor.js";
+export { ROOT_USER_CHROME_ID, ROOT_USER_CONTENT_ID, StyleRegistry, styleRegistry, } from "./registry.js";
+export { getFirefoxConfigurationDirectory, listFirefoxProfiles, resolveProfileDirectoryByName, } from "./profiles.js";
+export { FileWatcher, fileWatcher } from "./watcher.js";
+export { createCommand } from "./commands/create.js";
+export { startCommand } from "./commands/start.js";
+export { saveCommand } from "./commands/save.js";
+export { profilesCommand } from "./commands/profiles.js";
+export { startMcpServer } from "./commands/mcp.js";

package/dist/processor.js

@@ -0,0 +1,37 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import postcss from "postcss";
+import postcssImport from "postcss-import";
+/** Compiles a CSS string using PostCSS and inlines @import dependencies. */
+export async function compileCssString(css, basePath = path.resolve(process.cwd(), "style.css")) {
+    const processor = postcss([postcssImport()]);
+    const output = await processor.process(css, { from: basePath });
+    const importedFiles = [];
+    for (const message of output.messages) {
+        if (message.type === "dependency" && typeof message.file === "string") {
+            importedFiles.push(message.file);
+        }
+    }
+    return { css: output.css, importedFiles: importedFiles };
+}
+/**
+ * Compiles a CSS file, inlines @import rules via PostCSS, and optionally writes
+ * the output bundle to a destination path.
+ */
+export async function compileCssFile(srcPath, destPath) {
+    const absoluteSrcPath = path.resolve(process.cwd(), srcPath);
+    if (!existsSync(absoluteSrcPath)) {
+        throw new Error(`Stylesheet file does not exist at path: ${absoluteSrcPath}`);
+    }
+    const sourceContent = readFileSync(absoluteSrcPath, "utf8");
+    const result = await compileCssString(sourceContent, absoluteSrcPath);
+    if (destPath) {
+        const absoluteDestPath = path.resolve(process.cwd(), destPath);
+        const destDir = path.dirname(absoluteDestPath);
+        if (!existsSync(destDir)) {
+            mkdirSync(destDir, { recursive: true });
+        }
+        writeFileSync(absoluteDestPath, result.css, "utf8");
+    }
+    return result;
+}

package/dist/profiles.js

@@ -0,0 +1,98 @@
+import { existsSync, readFileSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+/**
+ * Discovers the platform-specific directory where Firefox configuration and
+ * profiles are located.
+ */
+export function getFirefoxConfigurationDirectory() {
+    const platformName = process.platform;
+    if (platformName === "darwin") {
+        return path.join(os.homedir(), "Library", "Application Support", "Firefox");
+    }
+    if (platformName === "win32") {
+        const applicationDataDirectory = process.env.APPDATA ||
+            path.join(os.homedir(), "AppData", "Roaming");
+        return path.join(applicationDataDirectory, "Mozilla", "Firefox");
+    }
+    return path.join(os.homedir(), ".mozilla", "firefox");
+}
+/**
+ * Parses the Firefox profiles.ini configuration file to extract profile
+ * records.
+ */
+export function listFirefoxProfiles(customConfigurationDirectory) {
+    const configurationDirectory = customConfigurationDirectory || getFirefoxConfigurationDirectory();
+    const profilesIniPath = path.join(configurationDirectory, "profiles.ini");
+    if (!existsSync(profilesIniPath))
+        return [];
+    const fileContent = readFileSync(profilesIniPath, "utf8");
+    const iniLines = fileContent.split(/\r?\n/);
+    const profileRecords = [];
+    let currentSection = null;
+    let currentProfileData = {};
+    for (const line of iniLines) {
+        const trimmedLine = line.trim();
+        if (trimmedLine.startsWith("[") && trimmedLine.endsWith("]")) {
+            if (currentSection &&
+                currentSection.toLowerCase().startsWith("profile") &&
+                currentProfileData.name &&
+                currentProfileData.path) {
+                const isRelative = currentProfileData.isRelative ?? true;
+                const resolvedPath = isRelative
+                    ? path.resolve(configurationDirectory, currentProfileData.path)
+                    : currentProfileData.path;
+                profileRecords.push({
+                    name: currentProfileData.name,
+                    path: resolvedPath,
+                    isRelative: isRelative,
+                    isDefault: Boolean(currentProfileData.isDefault),
+                });
+            }
+            currentSection = trimmedLine.slice(1, -1);
+            currentProfileData = {};
+            continue;
+        }
+        const equalsIndex = trimmedLine.indexOf("=");
+        if (equalsIndex === -1)
+            continue;
+        const key = trimmedLine.slice(0, equalsIndex).trim();
+        const value = trimmedLine.slice(equalsIndex + 1).trim();
+        if (key === "Name")
+            currentProfileData.name = value;
+        if (key === "Path")
+            currentProfileData.path = value;
+        if (key === "IsRelative")
+            currentProfileData.isRelative = value === "1";
+        if (key === "Default")
+            currentProfileData.isDefault = value === "1";
+    }
+    if (currentSection &&
+        currentSection.toLowerCase().startsWith("profile") &&
+        currentProfileData.name &&
+        currentProfileData.path) {
+        const isRelative = currentProfileData.isRelative ?? true;
+        const resolvedPath = isRelative
+            ? path.resolve(configurationDirectory, currentProfileData.path)
+            : currentProfileData.path;
+        profileRecords.push({
+            name: currentProfileData.name,
+            path: resolvedPath,
+            isRelative: isRelative,
+            isDefault: Boolean(currentProfileData.isDefault),
+        });
+    }
+    return profileRecords;
+}
+/** Resolves a registered Firefox profile name to its filesystem directory path. */
+export function resolveProfileDirectoryByName(profileName) {
+    const profiles = listFirefoxProfiles();
+    const matchedProfile = profiles.find((profile) => profile.name === profileName);
+    if (!matchedProfile) {
+        const availableProfileNames = profiles
+            .map((profile) => profile.name)
+            .join(", ");
+        throw new Error(`Profile "${profileName}" not found. Available profiles: ${availableProfileNames || "none"}`);
+    }
+    return matchedProfile.path;
+}

package/dist/registry.js

@@ -0,0 +1,48 @@
+import { createHash } from "node:crypto";
+export const ROOT_USER_CHROME_ID = "root:userChrome";
+export const ROOT_USER_CONTENT_ID = "root:userContent";
+export class StyleRegistry {
+    styles = new Map();
+    /**
+     * Generates a deterministic short hash ID for a file path when no explicit
+     * ID is supplied.
+     */
+    generateIdForFile(srcPath) {
+        const hash = createHash("sha256")
+            .update(srcPath, "utf8")
+            .digest("hex")
+            .slice(0, 8);
+        return `id-${hash}`;
+    }
+    /** Registers or updates a style entry in the in-memory registry. */
+    register(id, srcPath, target = "chrome") {
+        this.styles.set(id, {
+            registeredAt: new Date(),
+            srcPath: srcPath,
+            target: target,
+        });
+    }
+    /**
+     * Unregisters a style entry from the in-memory registry, returning whether
+     * it was found.
+     */
+    unregister(id) {
+        return this.styles.delete(id);
+    }
+    /** Retrieves metadata for a registered style. */
+    get(id) {
+        return this.styles.get(id);
+    }
+    /** Returns registered styles with optional target filtering. */
+    list(targetFilter) {
+        return Array.from(this.styles.entries())
+            .filter(([, entry]) => !targetFilter || entry.target === targetFilter)
+            .map(([id, entry]) => ({
+            id: id,
+            registeredAt: entry.registeredAt,
+            srcPath: entry.srcPath,
+            target: entry.target,
+        }));
+    }
+}
+export const styleRegistry = new StyleRegistry();

package/dist/types.js

@@ -0,0 +1 @@
+export {};