npm - @lumeo-ui/mcp-server - Versions diffs - 2.0.0-rc.29 → 2.0.0-rc.30 - Mend

@lumeo-ui/mcp-server 2.0.0-rc.29 → 2.0.0-rc.30

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (5) hide show

package/dist/index.js +286 -2
package/dist/installInfo.js +101 -0
package/package.json +1 -1
package/src/components-api.json +2350 -2
package/src/registry.json +1 -1

package/dist/index.js CHANGED Viewed

@@ -9,8 +9,14 @@
  *
  *   Tools:
  *     - lumeo_list_components  — list/filter all 131 components (name+category+description)
- *     - lumeo_get_component    — full schema (params, enums, events, sub-components, files)
+ *     - lumeo_get_component    — full schema (params, enums, events, sub-components, files, examples)
  *     - lumeo_search           — fuzzy search across name/category/description
+ *     - lumeo_get_example      — working Razor snippet(s) for a component
+ *     - lumeo_get_install      — NuGet + @using + DI + host includes + gotchas
+ *     - lumeo_validate_markup  — pre-flight check Razor for hallucinated APIs / bad enums / bad nesting
+ *     - lumeo_get_theme_tokens — the colour/radius CSS-variable tokens (the only legal colours)
+ *     - lumeo_list_patterns / lumeo_get_pattern — full-page composed examples (dashboard, auth, …)
+ *     - lumeo_changelog        — current version + schema generation timestamp + changelog link
  *
  *   Resources (URI template):
  *     - lumeo://component/{name}   — markdown reference per component
@@ -23,6 +29,7 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { CallToolRequestSchema, ListResourcesRequestSchema, ListResourceTemplatesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
 import { loadComponentsApi, } from "./componentsApi.js";
 import { components as curatedExamples } from "./components.js";
+import { setupFor, PORTAL_COMPONENTS, NEEDS_OVERLAY_PROVIDER } from "./installInfo.js";
 const DOCS_BASE = "https://lumeo.nativ.sh";
 // ───────────────── Load source-of-truth schema ─────────────────
 const api = loadComponentsApi() ?? {
@@ -34,6 +41,9 @@ const api = loadComponentsApi() ?? {
 const components = Object.values(api.components).sort((a, b) => a.name.localeCompare(b.name));
 const byName = new Map(components.map((c) => [c.name.toLowerCase(), c]));
 const CATEGORIES = Array.from(new Set(components.map((c) => c.category))).sort();
+const themeTokens = api.themeTokens ?? [];
+const patterns = api.patterns ?? [];
+const patternByKey = new Map(patterns.map((p) => [p.title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, ""), p]));
 // Hand-curated examples overlay (~30 components). Auto-gen schema wins for
 // parameters/enums/events; the curated `example` Razor snippet is preserved
 // as a documentation aid because LLMs benefit from seeing real usage.
@@ -187,10 +197,141 @@ function toGetPayload(c) {
         cssVars: c.cssVars,
         files: c.files,
         subComponents,
-        example: curatedExampleByName.get(c.name.toLowerCase()) ?? null,
+        examples: c.examples ?? [],
+        curatedExample: curatedExampleByName.get(c.name.toLowerCase()) ?? null,
         docs: docsUrl(c),
     };
 }
+// ───────────────── lumeo_get_install ─────────────────
+function buildInstallInfo(c) {
+    const setup = setupFor(c.nugetPackage);
+    const subNames = Object.values(c.subComponents).map((s) => s.componentName);
+    const isPortal = PORTAL_COMPONENTS.has(c.name);
+    const needsOverlayProvider = NEEDS_OVERLAY_PROVIDER.has(c.name);
+    const requiredParams = c.parameters
+        .filter((p) => /\bEditorRequired\b/i.test(p.description ?? "") || /required/i.test(p.description ?? ""))
+        .map((p) => p.name);
+    return {
+        component: c.name,
+        package: setup.package,
+        install: {
+            dotnet: setup.dotnetAdd,
+            registryCli: setup.lumeoAddNote,
+        },
+        imports: setup.usings,
+        di: setup.di,
+        hostIncludes: setup.hostIncludes,
+        namespace: c.namespace ?? "Lumeo",
+        subComponents: subNames,
+        requirements: [
+            isPortal
+                ? "Portal component: the page <body> (or an ancestor of the overlay root) needs the theme classes `bg-background text-foreground`, or this renders outside the theme cascade and looks unstyled."
+                : null,
+            needsOverlayProvider
+                ? "For the service-driven API (e.g. ToastService / OverlayService), add an <OverlayProvider /> once in your layout."
+                : null,
+            requiredParams.length
+                ? `Required parameters: ${requiredParams.map((p) => `\`${p}\``).join(", ")}.`
+                : null,
+            /Overlay/i.test(JSON.stringify(c.implements)) || isPortal
+                ? "Overlay/dismiss patterns are handled internally (RegisterClickOutside / LockScroll / focus trap) — you don't wire those yourself."
+                : null,
+        ].filter(Boolean),
+        notes: setup.notes,
+        docs: docsUrl(c),
+    };
+}
+// Build a lookup of every component + sub-component → its parameter set,
+// plus the parent each sub-component must live inside.
+const elementIndex = (() => {
+    const m = new Map();
+    const enumValueSet = (vals) => new Set(vals.map((v) => v.toLowerCase()));
+    for (const c of components) {
+        const enums = new Map();
+        for (const e of c.enums)
+            enums.set(e.name, enumValueSet(e.values));
+        m.set(c.name.toLowerCase(), { params: new Set(c.parameters.map((p) => p.name)), enums });
+        for (const s of Object.values(c.subComponents)) {
+            const subEnums = new Map();
+            for (const e of s.enums)
+                subEnums.set(e.name, enumValueSet(e.values));
+            m.set(s.componentName.toLowerCase(), { params: new Set(s.parameters.map((p) => p.name)), enums: subEnums, parent: c.name });
+        }
+    }
+    return m;
+})();
+function validateMarkup(markup) {
+    const issues = [];
+    // Find component tags: <Foo ...> or <Foo .../> or </Foo>. Lumeo components are PascalCase.
+    const tagRx = /<\/?([A-Z][A-Za-z0-9]*)((?:\s+[^<>]*?)?)\/?>/g;
+    // Track which known Lumeo components appear, to validate parent-child.
+    const present = new Set();
+    let m;
+    while ((m = tagRx.exec(markup)) !== null) {
+        const tag = m[1];
+        const isClose = m[0].startsWith("</");
+        const known = elementIndex.get(tag.toLowerCase());
+        if (!known)
+            continue; // not a Lumeo element (could be a user component / HTML — ignore)
+        present.add(tag);
+        if (isClose)
+            continue;
+        // Parse attributes (best-effort): Name="..." | Name='...' | Name="@expr" | Name=@expr | bare-name
+        const attrBlob = m[2] ?? "";
+        const attrRx = /([@A-Za-z_][\w-]*)\s*=\s*("(?:[^"]*)"|'(?:[^']*)'|@?[^\s"'<>]+)|([@A-Za-z_][\w-]*)(?=\s|$)/g;
+        let am;
+        while ((am = attrRx.exec(attrBlob)) !== null) {
+            let name = (am[1] ?? am[3] ?? "").trim();
+            if (!name)
+                continue;
+            // Strip Blazor directive prefixes/suffixes: @bind-Foo, @bind-Foo:event, Foo:stopPropagation, @onclick, @attributes, @key, @ref, @bind
+            if (name.startsWith("@bind-"))
+                name = name.slice("@bind-".length).split(":")[0];
+            else if (name.startsWith("@bind"))
+                continue; // @bind / @bind:event on inputs — skip
+            else if (name.startsWith("@on") || name === "@attributes" || name === "@key" || name === "@ref" || name === "@oninput" || name === "@onchange")
+                continue;
+            else if (name.startsWith("@"))
+                continue; // other directives
+            if (name.includes(":"))
+                name = name.split(":")[0]; // EventName:stopPropagation, :preventDefault
+            if (name === "class" || name === "style" || name === "id")
+                continue; // pass-through HTML attrs (Lumeo captures unmatched)
+            if (/^data-|^aria-/i.test(name))
+                continue; // captured unmatched
+            if (!known.params.has(name)) {
+                // Could be a captured-unmatched HTML attr — only flag if it looks like a typo'd Lumeo param (PascalCase).
+                if (/^[A-Z]/.test(name)) {
+                    issues.push({ severity: "warning", component: tag, message: `Unknown parameter \`${name}\` on <${tag}>. Did you mean one of: ${[...known.params].slice(0, 8).join(", ")}…? (Or it's a pass-through HTML attribute, which is allowed.)` });
+                }
+                continue;
+            }
+            // Enum value check: Foo="Bar.Baz.Qux" or Foo="Qux"
+            const rawVal = (am[2] ?? "").replace(/^["']|["']$/g, "").trim();
+            if (!rawVal || rawVal.startsWith("@"))
+                continue; // dynamic expression — can't statically check
+            // Which enum does this param use? Match by param name heuristically against enum names.
+            for (const [enumName, vals] of known.enums) {
+                // crude: the param likely uses this enum if rawVal looks like EnumName.Value or matches a value
+                const lastSeg = rawVal.split(".").pop().toLowerCase();
+                const looksLikeThisEnum = rawVal.toLowerCase().includes(enumName.toLowerCase()) || vals.has(lastSeg);
+                if (looksLikeThisEnum && !vals.has(lastSeg)) {
+                    issues.push({ severity: "error", component: tag, message: `\`${name}="${rawVal}"\` — \`${lastSeg}\` is not a valid ${enumName} value. Allowed: ${[...vals].join(", ")}.` });
+                }
+            }
+        }
+    }
+    // Parent-child: every sub-component present should have its required parent present somewhere.
+    for (const tag of present) {
+        const known = elementIndex.get(tag.toLowerCase());
+        if (known.parent && !present.has(known.parent)) {
+            issues.push({ severity: "error", component: tag, message: `<${tag}> must be used inside <${known.parent}> (it reads a CascadingValue from it). No <${known.parent}> found in this markup.` });
+        }
+    }
+    // Also flag obviously-unknown PascalCase tags that look like attempted Lumeo components.
+    // (Skip — too noisy; user components are also PascalCase. The known-element checks above are enough.)
+    return { ok: !issues.some((i) => i.severity === "error"), issues };
+}
 // ───────────────── Server setup ─────────────────
 const server = new Server({
     name: "lumeo-mcp",
@@ -247,6 +388,78 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
                 },
             },
         },
+        {
+            name: "lumeo_get_example",
+            description: "Get working Razor example snippet(s) for a component — the exact code behind the docs-site demos. " +
+                "Returns an array of { title, code }. Use this before writing markup for an unfamiliar component.",
+            inputSchema: {
+                type: "object",
+                required: ["name"],
+                properties: {
+                    name: { type: "string", description: "Component name (e.g. \"Tabs\", \"DataGrid\"). Case-insensitive." },
+                },
+            },
+        },
+        {
+            name: "lumeo_get_install",
+            description: "Everything needed to actually USE a component: NuGet package + `dotnet add` line, `@using` imports, " +
+                "DI registration (builder.Services.AddLumeo…), host-page <script>/<link> includes, sub-components, and " +
+                "gotchas (portal components needing theme classes on <body>, OverlayProvider, required params).",
+            inputSchema: {
+                type: "object",
+                required: ["name"],
+                properties: {
+                    name: { type: "string", description: "Component name. Case-insensitive." },
+                },
+            },
+        },
+        {
+            name: "lumeo_validate_markup",
+            description: "Validate a snippet of Razor that uses Lumeo components BEFORE compiling it. Checks: do the components exist? " +
+                "are parameter names valid (catches hallucinated APIs)? are enum values legal? are sub-components nested inside " +
+                "their required parent (e.g. <TabsContent> inside <Tabs>, <DialogContent> inside <Dialog>)? " +
+                "Returns { ok, issues: [{ severity, component, message }] }. Pass-through HTML/data-/aria- attributes are allowed.",
+            inputSchema: {
+                type: "object",
+                required: ["markup"],
+                properties: {
+                    markup: { type: "string", description: "Razor markup to validate (the component/markup portion — @code blocks are ignored)." },
+                },
+            },
+        },
+        {
+            name: "lumeo_get_theme_tokens",
+            description: `List all ${themeTokens.length} Lumeo theme tokens (CSS custom properties driving colours + radii). ` +
+                "These are the ONLY colours you should use — as Tailwind-style utilities like `bg-primary`, `text-foreground`, " +
+                "`border-border`, `bg-card`, `text-muted-foreground`, `ring-ring`. Never raw hex/hsl, never `dark:` prefixes " +
+                "(dark mode is a CSS-variable swap). Returns { token, cssVar } pairs.",
+            inputSchema: { type: "object", properties: {} },
+        },
+        {
+            name: "lumeo_list_patterns",
+            description: `List all ${patterns.length} Lumeo "patterns" / "blocks" — full-page composed examples (dashboard, auth, chat, ` +
+                "kanban, mail, settings, …) built entirely from Lumeo components. Returns { title, key, route, description }. " +
+                "Use lumeo_get_pattern for the full Razor source of one.",
+            inputSchema: { type: "object", properties: {} },
+        },
+        {
+            name: "lumeo_get_pattern",
+            description: "Get the complete Razor source of a Lumeo pattern/block (a full-page composed example). Returns title, " +
+                "description, route, and the demo code snippet(s). Great as a starting skeleton for a real page.",
+            inputSchema: {
+                type: "object",
+                required: ["key"],
+                properties: {
+                    key: { type: "string", description: "Pattern key (kebab-case, from lumeo_list_patterns) — e.g. \"dashboard\", \"authentication\", \"chat\"." },
+                },
+            },
+        },
+        {
+            name: "lumeo_changelog",
+            description: "Current Lumeo package version, when the API schema was generated, and a link to the full changelog. " +
+                "Use to check which version's API surface this MCP reflects.",
+            inputSchema: { type: "object", properties: {} },
+        },
     ],
 }));
 server.setRequestHandler(CallToolRequestSchema, async (req) => {
@@ -278,6 +491,76 @@ server.setRequestHandler(CallToolRequestSchema, async (req) => {
             const results = searchCatalog(query).map(toListPayload);
             return { content: [{ type: "text", text: JSON.stringify(results, null, 2) }] };
         }
+        case "lumeo_get_example": {
+            const wanted = typeof a.name === "string" ? a.name : "";
+            const c = findComponent(wanted);
+            if (!c) {
+                return { isError: true, content: [{ type: "text", text: `Component "${wanted}" not found. Use lumeo_search.` }] };
+            }
+            const examples = (c.examples ?? []).slice();
+            const curated = curatedExampleByName.get(c.name.toLowerCase());
+            if (curated && !examples.some((e) => e.code.trim() === curated.trim())) {
+                examples.push({ title: `${c.name} (curated)`, code: curated });
+            }
+            if (examples.length === 0) {
+                return { content: [{ type: "text", text: `No example on file for "${c.name}". See ${docsUrl(c)} or call lumeo_get_component for its full API.` }] };
+            }
+            return { content: [{ type: "text", text: JSON.stringify({ component: c.name, docs: docsUrl(c), examples }, null, 2) }] };
+        }
+        case "lumeo_get_install": {
+            const wanted = typeof a.name === "string" ? a.name : "";
+            const c = findComponent(wanted);
+            if (!c) {
+                return { isError: true, content: [{ type: "text", text: `Component "${wanted}" not found. Use lumeo_search.` }] };
+            }
+            return { content: [{ type: "text", text: JSON.stringify(buildInstallInfo(c), null, 2) }] };
+        }
+        case "lumeo_validate_markup": {
+            const markup = typeof a.markup === "string" ? a.markup : "";
+            if (!markup.trim()) {
+                return { isError: true, content: [{ type: "text", text: "No markup provided." }] };
+            }
+            const result = validateMarkup(markup);
+            const summary = result.ok
+                ? (result.issues.length ? `OK with ${result.issues.length} warning(s).` : "OK — no issues found.")
+                : `${result.issues.filter((i) => i.severity === "error").length} error(s), ${result.issues.filter((i) => i.severity === "warning").length} warning(s).`;
+            return { content: [{ type: "text", text: JSON.stringify({ ...result, summary }, null, 2) }] };
+        }
+        case "lumeo_get_theme_tokens": {
+            return { content: [{ type: "text", text: JSON.stringify({
+                            count: themeTokens.length,
+                            usage: "Use as Tailwind-style utilities: bg-{token}, text-{token}, border-{token}, ring-{token}, fill-{token}. e.g. `bg-primary text-primary-foreground`, `border-border/40`, `text-muted-foreground`. Radius tokens (radius, radius-sm, radius-lg, …) → `rounded-[var(--radius-lg)]`. Never raw hex; never `dark:` prefixes (dark mode swaps the variable values).",
+                            tokens: themeTokens,
+                        }, null, 2) }] };
+        }
+        case "lumeo_list_patterns": {
+            const list = patterns.map((p) => ({
+                title: p.title,
+                key: p.title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, ""),
+                route: p.route,
+                description: p.description,
+            }));
+            return { content: [{ type: "text", text: JSON.stringify(list, null, 2) }] };
+        }
+        case "lumeo_get_pattern": {
+            const key = (typeof a.key === "string" ? a.key : "").toLowerCase();
+            const p = patternByKey.get(key) ?? patterns.find((x) => x.title.toLowerCase().includes(key) || x.route.includes(key));
+            if (!p) {
+                return { isError: true, content: [{ type: "text", text: `Pattern "${key}" not found. Use lumeo_list_patterns for valid keys.` }] };
+            }
+            return { content: [{ type: "text", text: JSON.stringify({
+                            title: p.title, route: `${DOCS_BASE}${p.route}`, description: p.description, examples: p.examples,
+                        }, null, 2) }] };
+        }
+        case "lumeo_changelog": {
+            return { content: [{ type: "text", text: JSON.stringify({
+                            version: api.version,
+                            apiSchemaGenerated: api.generated,
+                            componentCount: api.stats.componentCount,
+                            changelog: `${DOCS_BASE}/docs/changelog`,
+                            note: "Detailed per-release notes live on the docs site. This MCP's API surface reflects the version above.",
+                        }, null, 2) }] };
+        }
         default:
             return { isError: true, content: [{ type: "text", text: `Unknown tool: ${name}` }] };
     }
@@ -338,6 +621,7 @@ async function main() {
     await server.connect(transport);
     process.stderr.write(`[lumeo-mcp] ready — ${components.length} components, ${CATEGORIES.length} categories, ` +
         `${api.stats.totalParameters} params, ${api.stats.totalEnums} enums, ` +
+        `${themeTokens.length} theme tokens, ${patterns.length} patterns, ` +
         `api v${api.version}, generated ${api.generated}\n`);
 }
 main().catch((err) => {

package/dist/installInfo.js ADDED Viewed

@@ -0,0 +1,101 @@
+/**
+ * Static install/setup metadata that isn't derivable from the Razor source.
+ * Keyed by NuGet package; plus a small list of component-specific gotchas
+ * (portal components needing theme classes on <body>, etc.). Hand-maintained —
+ * these change rarely. Surfaced via the `lumeo_get_install` MCP tool so an
+ * LLM gets everything it needs to actually run a component, not just its API.
+ */
+export const PACKAGE_SETUP = {
+    Lumeo: {
+        package: "Lumeo",
+        dotnetAdd: "dotnet add package Lumeo --prerelease",
+        lumeoAddNote: "Or copy a single component into your project: `lumeo add <component>` (after `lumeo init`).",
+        usings: ["@using Lumeo"],
+        di: ["builder.Services.AddLumeo();  // registers ComponentInteropService, OverlayService, ConsentService, etc."],
+        hostIncludes: [
+            `<link rel="stylesheet" href="_content/Lumeo/css/lumeo.css" />`,
+            `<script src="_content/Lumeo/js/components.js"></script>`,
+        ],
+        notes: [
+            "Tailwind v4: Lumeo ships pre-compiled utilities in lumeo.css — no Tailwind build step required for the components themselves.",
+            "Dark mode is handled by CSS-variable swaps in lumeo.css. Do NOT use `dark:` Tailwind prefixes; toggle the `dark` class on <html>.",
+            "All colours come from theme tokens (bg-primary, text-foreground, border-border, …) — never raw hex/hsl. Use the `lumeo_get_theme_tokens` tool for the full list.",
+        ],
+    },
+    "Lumeo.Charts": {
+        package: "Lumeo.Charts",
+        dotnetAdd: "dotnet add package Lumeo.Charts --prerelease",
+        lumeoAddNote: "`lumeo add chart` copies the Chart component + ECharts interop.",
+        usings: ["@using Lumeo"],
+        di: ["builder.Services.AddLumeo();", "builder.Services.AddLumeoCharts();"],
+        hostIncludes: [
+            `<script src="_content/Lumeo.Charts/js/echarts.min.js"></script>`,
+            `<script src="_content/Lumeo.Charts/js/chart-interop.js"></script>`,
+        ],
+        notes: ["Wraps Apache ECharts — 30+ chart types via the declarative <Chart> wrapper or raw EChartOption / OptionJson."],
+    },
+    "Lumeo.DataGrid": {
+        package: "Lumeo.DataGrid",
+        dotnetAdd: "dotnet add package Lumeo.DataGrid --prerelease",
+        lumeoAddNote: "`lumeo add datagrid` copies the DataGrid + supporting types.",
+        usings: ["@using Lumeo"],
+        di: ["builder.Services.AddLumeo();", "builder.Services.AddLumeoDataGrid();  // registers IDataGridExportService"],
+        hostIncludes: [],
+        notes: [
+            "Excel/PDF export pulls in ClosedXML (MIT) and QuestPDF (dual-licensed — free under $1M revenue, otherwise paid). CSV/JSON export has no third-party dependency.",
+            "In Blazor WebAssembly, hide PDF export (`ExportFormats=\"DataGridExportFormat.Csv | DataGridExportFormat.Excel\"`) — QuestPDF throws PlatformNotSupportedException there.",
+        ],
+    },
+    "Lumeo.Editor": {
+        package: "Lumeo.Editor",
+        dotnetAdd: "dotnet add package Lumeo.Editor --prerelease",
+        lumeoAddNote: "`lumeo add rich-text-editor`.",
+        usings: ["@using Lumeo"],
+        di: ["builder.Services.AddLumeo();", "builder.Services.AddLumeoEditor();"],
+        hostIncludes: [`<script src="_content/Lumeo.Editor/js/editor-interop.js"></script>`],
+        notes: [],
+    },
+    "Lumeo.Scheduler": {
+        package: "Lumeo.Scheduler",
+        dotnetAdd: "dotnet add package Lumeo.Scheduler --prerelease",
+        lumeoAddNote: "`lumeo add scheduler`.",
+        usings: ["@using Lumeo"],
+        di: ["builder.Services.AddLumeo();", "builder.Services.AddLumeoScheduler();"],
+        hostIncludes: [],
+        notes: [],
+    },
+    "Lumeo.Gantt": {
+        package: "Lumeo.Gantt",
+        dotnetAdd: "dotnet add package Lumeo.Gantt --prerelease",
+        lumeoAddNote: "`lumeo add gantt`.",
+        usings: ["@using Lumeo"],
+        di: ["builder.Services.AddLumeo();", "builder.Services.AddLumeoGantt();"],
+        hostIncludes: [],
+        notes: [],
+    },
+    "Lumeo.Motion": {
+        package: "Lumeo.Motion",
+        dotnetAdd: "dotnet add package Lumeo.Motion --prerelease",
+        lumeoAddNote: "`lumeo add <motion-component>` (e.g. `lumeo add border-beam`).",
+        usings: ["@using Lumeo"],
+        di: ["builder.Services.AddLumeo();", "builder.Services.AddLumeoMotion();"],
+        hostIncludes: [`<script src="_content/Lumeo.Motion/js/motion-interop.js"></script>`],
+        notes: ["Animation primitives (BorderBeam, Marquee, NumberTicker, Confetti, …). Most are pure CSS; a few use a small JS interop module."],
+    },
+};
+/**
+ * Components whose content renders into a portal/overlay outside the normal
+ * component tree. They need `bg-background text-foreground` on <body> (or a
+ * wrapper that is an ancestor of the portal root) or they render outside the
+ * theme cascade and look unstyled.
+ */
+export const PORTAL_COMPONENTS = new Set([
+    "Dialog", "Sheet", "Drawer", "Toast", "Popover", "Tooltip", "AlertDialog",
+    "HoverCard", "ContextMenu", "DropdownMenu", "Command", "PopConfirm", "Tour",
+    "DatePicker", "DateTimePicker", "TimePicker", "Combobox", "Cascader", "Mention", "Select",
+]);
+/** Components that need an OverlayProvider in the layout for the service-driven API. */
+export const NEEDS_OVERLAY_PROVIDER = new Set(["Toast", "Dialog", "Sheet", "Drawer"]);
+export function setupFor(nugetPackage) {
+    return PACKAGE_SETUP[nugetPackage] ?? PACKAGE_SETUP.Lumeo;
+}

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@lumeo-ui/mcp-server",
-  "version": "2.0.0-rc.29",
+  "version": "2.0.0-rc.30",
   "description": "Model Context Protocol server for the Lumeo Blazor component library. Lets LLMs (Claude, Copilot, Cursor) author correct Lumeo markup.",
   "type": "module",
   "main": "dist/index.js",