@mp3wizard/figma-console-mcp 1.14.0

package/dist/cloudflare/apps/design-system-dashboard/scoring/token-architecture.js

@@ -0,0 +1,349 @@
+/**
+ * Token Architecture Scorer (weight: 0.20)
+ *
+ * Evaluates the depth and organization of the token system.
+ * Checks collection organization, mode coverage, alias usage,
+ * token tier depth, type distribution, and description coverage.
+ */
+import { buildCollectionNameMap, clamp, getSeverity } from "./types.js";
+/** Maximum examples to include in a finding. */
+const MAX_EXAMPLES = 5;
+/**
+ * Check if a value entry is a variable alias reference.
+ */
+function isAlias(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        value.type === "VARIABLE_ALIAS");
+}
+/** Check if variable data was unavailable (vs. genuinely empty). */
+function variableDataUnavailable(data) {
+    return (data.dataAvailability !== undefined && !data.dataAvailability.variables);
+}
+/** Message explaining why variable data is missing. */
+function variableUnavailableMessage(data) {
+    const reason = data.dataAvailability?.variableError ||
+        "Figma Enterprise plan or Desktop Bridge plugin required";
+    return `Variable data unavailable: ${reason}. Score reflects missing data, not actual design system quality.`;
+}
+/**
+ * Score collection organization.
+ * Variables should be organized into collections.
+ */
+function scoreCollectionOrganization(data) {
+    const count = data.collections.length;
+    if (count === 0 && variableDataUnavailable(data)) {
+        return {
+            id: "token-collection-org",
+            label: "Collection organization",
+            score: 0,
+            severity: "info",
+            tooltip: "Variables should be grouped into collections by concern (colors, spacing, typography). More collections = better organization.",
+            details: variableUnavailableMessage(data),
+        };
+    }
+    let score;
+    if (count >= 3) {
+        score = 100;
+    }
+    else if (count === 2) {
+        score = 80;
+    }
+    else if (count === 1) {
+        score = 50;
+    }
+    else {
+        score = 0;
+    }
+    return {
+        id: "token-collection-org",
+        label: "Collection organization",
+        score: clamp(score),
+        severity: getSeverity(score),
+        tooltip: "Variables should be grouped into collections by concern (colors, spacing, typography). More collections = better organization.",
+        details: count === 0
+            ? "No variable collections found. Organize variables into collections."
+            : `${count} collection${count === 1 ? "" : "s"} found.`,
+    };
+}
+/**
+ * Score mode coverage.
+ * Collections should have multiple modes (e.g., light/dark).
+ */
+function scoreModeCoverage(data) {
+    if (data.collections.length === 0) {
+        return {
+            id: "token-mode-coverage",
+            label: "Mode coverage",
+            score: 0,
+            severity: variableDataUnavailable(data) ? "info" : "fail",
+            tooltip: "Collections should support multiple modes (e.g. Light/Dark). This enables theming without duplicating tokens.",
+            details: variableDataUnavailable(data)
+                ? variableUnavailableMessage(data)
+                : "No collections found to evaluate mode coverage.",
+        };
+    }
+    const maxModes = Math.max(...data.collections.map((c) => c.modes?.length ?? 0));
+    let score;
+    if (maxModes >= 2) {
+        score = 100;
+    }
+    else if (maxModes === 1) {
+        score = 50;
+    }
+    else {
+        score = 0;
+    }
+    return {
+        id: "token-mode-coverage",
+        label: "Mode coverage",
+        score: clamp(score),
+        severity: getSeverity(score),
+        tooltip: "Collections should support multiple modes (e.g. Light/Dark). This enables theming without duplicating tokens.",
+        details: maxModes >= 2
+            ? `Collections support up to ${maxModes} modes (e.g., light/dark).`
+            : maxModes === 1
+                ? "Collections have only 1 mode. Consider adding light/dark modes."
+                : "No modes detected in collections.",
+    };
+}
+/**
+ * Score alias usage.
+ * Higher alias percentage indicates better token layering.
+ */
+function scoreAliasUsage(data) {
+    if (data.variables.length === 0) {
+        return {
+            id: "token-alias-usage",
+            label: "Alias usage",
+            score: 0,
+            severity: variableDataUnavailable(data) ? "info" : "fail",
+            tooltip: "Semantic tokens should reference primitive tokens via aliases rather than hard-coding values. Aliases enable single-source-of-truth updates.",
+            details: variableDataUnavailable(data)
+                ? variableUnavailableMessage(data)
+                : "No variables to evaluate alias usage.",
+        };
+    }
+    const collectionNames = buildCollectionNameMap(data.collections);
+    let aliasCount = 0;
+    let totalValues = 0;
+    const rawValueVars = [];
+    for (const variable of data.variables) {
+        if (!variable.valuesByMode)
+            continue;
+        let hasAnyAlias = false;
+        for (const modeValues of Object.values(variable.valuesByMode)) {
+            totalValues++;
+            if (isAlias(modeValues)) {
+                aliasCount++;
+                hasAnyAlias = true;
+            }
+        }
+        if (!hasAnyAlias) {
+            rawValueVars.push(variable);
+        }
+    }
+    if (totalValues === 0) {
+        return {
+            id: "token-alias-usage",
+            label: "Alias usage",
+            score: 0,
+            severity: "fail",
+            tooltip: "Semantic tokens should reference primitive tokens via aliases rather than hard-coding values. Aliases enable single-source-of-truth updates.",
+            details: "No variable values found to evaluate.",
+        };
+    }
+    const ratio = aliasCount / totalValues;
+    const score = clamp(ratio * 100);
+    return {
+        id: "token-alias-usage",
+        label: "Alias usage",
+        score,
+        severity: getSeverity(score),
+        tooltip: "Semantic tokens should reference primitive tokens via aliases rather than hard-coding values. Aliases enable single-source-of-truth updates.",
+        details: `${aliasCount} of ${totalValues} values are aliases (${Math.round(ratio * 100)}%). Higher alias usage indicates better token layering.`,
+        examples: rawValueVars.length > 0 ? rawValueVars.slice(0, MAX_EXAMPLES).map((v) => v.name) : undefined,
+        locations: rawValueVars.length > 0
+            ? rawValueVars.slice(0, MAX_EXAMPLES).map((v) => ({
+                name: v.name,
+                collection: collectionNames.get(v.variableCollectionId),
+                type: "variable",
+            }))
+            : undefined,
+    };
+}
+/**
+ * Build a map of variable ID to variable for alias chain tracing.
+ */
+function buildVariableMap(variables) {
+    const map = new Map();
+    for (const v of variables) {
+        if (v.id) {
+            map.set(v.id, v);
+        }
+    }
+    return map;
+}
+/**
+ * Trace the depth of an alias chain starting from a given variable.
+ * Returns the number of tiers (1 = raw value, 2 = one alias hop, etc.).
+ */
+function traceAliasDepth(variable, variableMap, visited) {
+    if (!variable.valuesByMode)
+        return 1;
+    const values = Object.values(variable.valuesByMode);
+    let maxDepth = 1;
+    for (const value of values) {
+        if (isAlias(value)) {
+            const targetId = value.id;
+            if (visited.has(targetId))
+                continue; // Prevent circular references
+            const target = variableMap.get(targetId);
+            if (target) {
+                visited.add(targetId);
+                const depth = 1 + traceAliasDepth(target, variableMap, visited);
+                maxDepth = Math.max(maxDepth, depth);
+            }
+        }
+    }
+    return maxDepth;
+}
+/**
+ * Score token tier depth.
+ * Deeper alias chains indicate more sophisticated token architecture.
+ */
+function scoreTokenTierDepth(data) {
+    if (data.variables.length === 0) {
+        return {
+            id: "token-tier-depth",
+            label: "Token tier depth",
+            score: 0,
+            severity: variableDataUnavailable(data) ? "info" : "fail",
+            tooltip: "A layered token system (primitive -> semantic -> component) enables scalable theming. 3+ tiers indicates mature architecture.",
+            details: variableDataUnavailable(data)
+                ? variableUnavailableMessage(data)
+                : "No variables to evaluate tier depth.",
+        };
+    }
+    const variableMap = buildVariableMap(data.variables);
+    let maxDepth = 1;
+    for (const variable of data.variables) {
+        const visited = new Set();
+        if (variable.id)
+            visited.add(variable.id);
+        const depth = traceAliasDepth(variable, variableMap, visited);
+        maxDepth = Math.max(maxDepth, depth);
+    }
+    let score;
+    if (maxDepth >= 3) {
+        score = 100;
+    }
+    else if (maxDepth === 2) {
+        score = 67;
+    }
+    else {
+        score = 33;
+    }
+    return {
+        id: "token-tier-depth",
+        label: "Token tier depth",
+        score: clamp(score),
+        severity: getSeverity(score),
+        tooltip: "A layered token system (primitive -> semantic -> component) enables scalable theming. 3+ tiers indicates mature architecture.",
+        details: `Maximum alias chain depth: ${maxDepth} tier${maxDepth === 1 ? "" : "s"}. 3+ tiers indicates a well-layered token architecture.`,
+    };
+}
+/**
+ * Score type distribution across variables.
+ * A healthy system includes COLOR, FLOAT, and STRING variables.
+ */
+function scoreTypeDistribution(data) {
+    if (data.variables.length === 0) {
+        return {
+            id: "token-type-distribution",
+            label: "Type distribution",
+            score: 0,
+            severity: variableDataUnavailable(data) ? "info" : "fail",
+            tooltip: "A complete token system includes COLOR, FLOAT, and STRING variables. Missing types indicate gaps in the design language.",
+            details: variableDataUnavailable(data)
+                ? variableUnavailableMessage(data)
+                : "No variables to evaluate type distribution.",
+        };
+    }
+    const expectedTypes = ["COLOR", "FLOAT", "STRING"];
+    const presentTypes = new Set(data.variables.map((v) => v.resolvedType));
+    const matchCount = expectedTypes.filter((t) => presentTypes.has(t)).length;
+    const score = clamp((matchCount / expectedTypes.length) * 100);
+    return {
+        id: "token-type-distribution",
+        label: "Type distribution",
+        score,
+        severity: getSeverity(score),
+        tooltip: "A complete token system includes COLOR, FLOAT, and STRING variables. Missing types indicate gaps in the design language.",
+        details: `${matchCount} of ${expectedTypes.length} expected types (COLOR, FLOAT, STRING) present. Found: ${[...presentTypes].join(", ") || "none"}.`,
+    };
+}
+/**
+ * Score description coverage for variables.
+ * Well-documented variables should have non-empty descriptions.
+ */
+function scoreDescriptionCoverage(data) {
+    if (data.variables.length === 0) {
+        return {
+            id: "token-description-coverage",
+            label: "Description coverage",
+            score: 0,
+            severity: variableDataUnavailable(data) ? "info" : "fail",
+            tooltip: "Variables should have descriptions explaining their purpose and usage context. Descriptions help consumers choose the right token.",
+            details: variableDataUnavailable(data)
+                ? variableUnavailableMessage(data)
+                : "No variables to evaluate description coverage.",
+        };
+    }
+    const collectionNames = buildCollectionNameMap(data.collections);
+    const withDesc = data.variables.filter((v) => v.description && v.description.trim().length > 0);
+    const withoutDesc = data.variables.filter((v) => !v.description || v.description.trim().length === 0);
+    const ratio = withDesc.length / data.variables.length;
+    const score = clamp(ratio * 100);
+    return {
+        id: "token-description-coverage",
+        label: "Description coverage",
+        score,
+        severity: getSeverity(score),
+        tooltip: "Variables should have descriptions explaining their purpose and usage context. Descriptions help consumers choose the right token.",
+        details: `${withDesc.length} of ${data.variables.length} variables have descriptions (${Math.round(ratio * 100)}%).`,
+        examples: withoutDesc.length > 0
+            ? withoutDesc.slice(0, MAX_EXAMPLES).map((v) => v.name)
+            : undefined,
+        locations: withoutDesc.length > 0
+            ? withoutDesc.slice(0, MAX_EXAMPLES).map((v) => ({
+                name: v.name,
+                collection: collectionNames.get(v.variableCollectionId),
+                type: "variable",
+            }))
+            : undefined,
+    };
+}
+/**
+ * Token Architecture category scorer.
+ * Returns the average score across all token architecture checks.
+ */
+export function scoreTokenArchitecture(data) {
+    const findings = [
+        scoreCollectionOrganization(data),
+        scoreModeCoverage(data),
+        scoreAliasUsage(data),
+        scoreTokenTierDepth(data),
+        scoreTypeDistribution(data),
+        scoreDescriptionCoverage(data),
+    ];
+    const score = clamp(findings.reduce((sum, f) => sum + f.score, 0) / findings.length);
+    return {
+        id: "token-architecture",
+        label: "Token Architecture",
+        shortLabel: "Tokens",
+        score,
+        weight: 0.2,
+        findings,
+    };
+}

package/dist/cloudflare/apps/design-system-dashboard/scoring/types.js

@@ -0,0 +1,40 @@
+/**
+ * Design System Dashboard — Shared Types
+ *
+ * Defines the JSON contract between the scoring engine (server-side),
+ * the server registration (tools), and the UI (client-side rendering).
+ */
+/** Build a map of collection ID → collection name for location context. */
+export function buildCollectionNameMap(collections) {
+    const map = new Map();
+    for (const col of collections) {
+        if (col.id && col.name)
+            map.set(col.id, col.name);
+    }
+    return map;
+}
+// ---------------------------------------------------------------------------
+// Thresholds and helpers
+// ---------------------------------------------------------------------------
+export const THRESHOLDS = {
+    GOOD: 90,
+    NEEDS_WORK: 50,
+};
+export function getStatus(score) {
+    if (score >= THRESHOLDS.GOOD)
+        return "good";
+    if (score >= THRESHOLDS.NEEDS_WORK)
+        return "needs-work";
+    return "poor";
+}
+export function getSeverity(score) {
+    if (score >= THRESHOLDS.GOOD)
+        return "pass";
+    if (score >= THRESHOLDS.NEEDS_WORK)
+        return "warning";
+    return "fail";
+}
+/** Clamp a number to 0-100. */
+export function clamp(value) {
+    return Math.max(0, Math.min(100, Math.round(value)));
+}

package/dist/cloudflare/apps/design-system-dashboard/server.js

@@ -0,0 +1,159 @@
+/**
+ * Design System Dashboard MCP App - Server Registration
+ *
+ * Registers tools and resource for the Design System Dashboard MCP App.
+ * Uses the official @modelcontextprotocol/ext-apps helpers for proper
+ * MCP Apps protocol compatibility with Claude Desktop.
+ *
+ * Data flow:
+ *   1. LLM calls figma_audit_design_system → server fetches + scores data,
+ *      returns SHORT summary to LLM (avoids context exhaustion)
+ *   2. UI opens, connects, calls ds_dashboard_refresh (app-only visibility)
+ *   3. ds_dashboard_refresh returns full JSON → UI renders
+ */
+import { readFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { RESOURCE_MIME_TYPE, registerAppResource, registerAppTool, } from "@modelcontextprotocol/ext-apps/server";
+import { z } from "zod";
+import { scoreDesignSystem } from "./scoring/engine.js";
+const DASHBOARD_URI = "ui://figma-console/design-system-dashboard";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+// Shared state
+let lastFileUrl;
+/**
+ * Register the Design System Dashboard MCP App with the server.
+ *
+ * @param server - The MCP server instance
+ * @param getDesignSystemData - Function to fetch raw design system data from Figma
+ * @param getCurrentUrl - Optional function to get the current browser URL (for lastFileUrl tracking)
+ */
+export function registerDesignSystemDashboardApp(server, getDesignSystemData, getCurrentUrl) {
+    // Tool: fetches + scores data, returns SHORT summary to LLM
+    registerAppTool(server, "figma_audit_design_system", {
+        title: "Audit Design System Health",
+        description: "Analyze the health and AI-readiness of a Figma file's design system. Produces a scored dashboard evaluating naming conventions, token architecture, component metadata, accessibility, consistency, and coverage. Results are displayed in the dashboard UI.",
+        inputSchema: {
+            fileUrl: z
+                .string()
+                .url()
+                .optional()
+                .describe("Figma file URL. If not provided, uses the currently active file."),
+        },
+        _meta: {
+            ui: { resourceUri: DASHBOARD_URI },
+        },
+    }, async ({ fileUrl }) => {
+        try {
+            // Track the actual URL used (explicit or current browser URL)
+            // This ensures ds_dashboard_refresh uses the correct file
+            lastFileUrl = fileUrl || getCurrentUrl?.() || undefined;
+            const data = await getDesignSystemData(fileUrl);
+            const scored = scoreDesignSystem(data);
+            const categorySummaries = scored.categories
+                .map((c) => `${c.label}: ${c.score}/100`)
+                .join(", ");
+            const fileName = scored.fileInfo?.name || "Unknown file";
+            const unavailableNote = scored.dataAvailability && !scored.dataAvailability.variables
+                ? " Note: Variable/token data was unavailable (requires Enterprise plan or Desktop Bridge). Token Architecture scores reflect missing data, not actual quality."
+                : "";
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Design System: ${fileName}. Health: ${scored.overall}/100 — ${scored.status}. ${categorySummaries}.${unavailableNote} The dashboard UI is now showing detailed results.`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Design System Dashboard error: ${errorMessage}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    // Tool: returns full JSON data (app-only, hidden from LLM)
+    registerAppTool(server, "ds_dashboard_refresh", {
+        title: "Dashboard Refresh",
+        description: "Refresh dashboard data (called from MCP App UI)",
+        inputSchema: {
+            fileUrl: z
+                .string()
+                .url()
+                .optional()
+                .describe("Figma file URL to refresh data for."),
+        },
+        _meta: {
+            ui: {
+                resourceUri: DASHBOARD_URI,
+                visibility: ["app"],
+            },
+        },
+    }, async ({ fileUrl }) => {
+        try {
+            const url = fileUrl || lastFileUrl;
+            const data = await getDesignSystemData(url);
+            const scored = scoreDesignSystem(data);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(scored),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            error: errorMessage,
+                            overall: 0,
+                            status: "poor",
+                            categories: [],
+                            summary: [],
+                            meta: {
+                                componentCount: 0,
+                                variableCount: 0,
+                                collectionCount: 0,
+                                styleCount: 0,
+                                componentSetCount: 0,
+                                standaloneCount: 0,
+                                variantCount: 0,
+                                timestamp: Date.now(),
+                            },
+                        }),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    // Resource: serves the Vite-built HTML
+    registerAppResource(server, "Design System Dashboard App", DASHBOARD_URI, {
+        description: "Interactive dashboard for evaluating design system health and AI-readiness",
+    }, async () => {
+        const htmlPath = resolve(__dirname, "mcp-app.html");
+        const html = await readFile(htmlPath, "utf-8");
+        return {
+            contents: [
+                {
+                    uri: DASHBOARD_URI,
+                    mimeType: RESOURCE_MIME_TYPE,
+                    text: html,
+                },
+            ],
+        };
+    });
+}

package/dist/cloudflare/apps/token-browser/server.js

@@ -0,0 +1,136 @@
+/**
+ * Token Browser MCP App - Server Registration
+ *
+ * Registers tools and resource for the Token Browser MCP App.
+ * Uses the official @modelcontextprotocol/ext-apps helpers for proper
+ * MCP Apps protocol compatibility with Claude Desktop.
+ *
+ * Data flow:
+ *   1. LLM calls figma_browse_tokens → server fetches + caches data,
+ *      returns SHORT summary to LLM (avoids context exhaustion)
+ *   2. UI opens, connects, calls token_browser_refresh (app-only visibility)
+ *   3. token_browser_refresh returns full JSON → UI renders
+ */
+import { readFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { RESOURCE_MIME_TYPE, registerAppResource, registerAppTool, } from "@modelcontextprotocol/ext-apps/server";
+import { z } from "zod";
+const TOKEN_BROWSER_URI = "ui://figma-console/token-browser";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+/**
+ * Register the Token Browser MCP App with the server.
+ *
+ * @param server - The MCP server instance
+ * @param getVariablesHandler - Function to fetch variables data
+ */
+export function registerTokenBrowserApp(server, getVariablesHandler) {
+    // Shared state: remember last URL so refresh tool can reuse it
+    let lastFileUrl;
+    // Tool: fetches + caches data, returns SHORT summary to LLM
+    registerAppTool(server, "figma_browse_tokens", {
+        title: "Browse Design Tokens",
+        description: "Open an interactive browser to explore design tokens (variables) from a Figma file. Shows tokens organized by collection with search, filtering, and mode switching. Data is displayed in the UI — do not attempt to list or describe the tokens in chat.",
+        inputSchema: {
+            fileUrl: z
+                .string()
+                .url()
+                .optional()
+                .describe("Figma file URL. If not provided, uses the currently active file."),
+        },
+        _meta: {
+            ui: { resourceUri: TOKEN_BROWSER_URI },
+        },
+    }, async ({ fileUrl }) => {
+        try {
+            lastFileUrl = fileUrl;
+            const result = await getVariablesHandler(fileUrl);
+            const varCount = result.variables?.length || 0;
+            const colCount = result.collections?.length || 0;
+            // Count by type
+            const colors = result.variables?.filter((v) => v.resolvedType === "COLOR")
+                .length || 0;
+            const numbers = result.variables?.filter((v) => v.resolvedType === "FLOAT")
+                .length || 0;
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Token Browser opened: ${varCount} tokens across ${colCount} collections (${colors} colors, ${numbers} numbers). The interactive UI is now displaying the results — users can search, filter by type, and browse by collection.`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Token Browser error: ${errorMessage}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    // Tool: returns full JSON data (app-only, hidden from LLM)
+    registerAppTool(server, "token_browser_refresh", {
+        title: "Token Browser Refresh",
+        description: "Refresh token data (called from MCP App UI)",
+        inputSchema: {
+            fileUrl: z
+                .string()
+                .url()
+                .optional()
+                .describe("Figma file URL to refresh data for."),
+        },
+        _meta: {
+            ui: {
+                resourceUri: TOKEN_BROWSER_URI,
+                visibility: ["app"],
+            },
+        },
+    }, async ({ fileUrl }) => {
+        try {
+            const url = fileUrl || lastFileUrl;
+            const result = await getVariablesHandler(url);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result) }],
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            error: errorMessage,
+                            variables: [],
+                            collections: [],
+                        }),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    // Resource: serves the Vite-built HTML
+    registerAppResource(server, "Token Browser App", TOKEN_BROWSER_URI, {
+        description: "Interactive browser for exploring Figma design tokens and variables",
+    }, async () => {
+        const htmlPath = resolve(__dirname, "mcp-app.html");
+        const html = await readFile(htmlPath, "utf-8");
+        return {
+            contents: [
+                {
+                    uri: TOKEN_BROWSER_URI,
+                    mimeType: RESOURCE_MIME_TYPE,
+                    text: html,
+                },
+            ],
+        };
+    });
+}

package/dist/cloudflare/browser/base.js

@@ -0,0 +1,5 @@
+/**
+ * Browser Manager Interface
+ * Abstract interface for browser automation across different runtimes
+ */
+export {};