@dropins/mcp 0.1.0

package/dist/operations/list-api-functions.js

@@ -0,0 +1,53 @@
+import { z } from "zod";
+import { formatSuccessResponse, formatExceptionResponse, } from "../common/response-handling.js";
+import { getApiFunctionRegistry, getApiFunctionsByDropin, getAllDropinNames, } from "../common/registry-loader.js";
+export const ListApiFunctionsSchema = z.object({
+    dropin: z
+        .string()
+        .optional()
+        .describe("Filter by dropin name (e.g. storefront-cart). Omit to list all."),
+});
+export async function listApiFunctions(params) {
+    try {
+        if (params.dropin) {
+            const dropinData = getApiFunctionsByDropin(params.dropin);
+            if (!dropinData) {
+                const availableDropins = getAllDropinNames();
+                return formatSuccessResponse(`Dropin "${params.dropin}" not found`, {
+                    availableDropins,
+                });
+            }
+            const data = {
+                version: dropinData.version,
+                importPath: dropinData.importPath,
+                functions: dropinData.functions,
+                utils: dropinData.utils,
+            };
+            return formatSuccessResponse(`Found ${dropinData.functions.length} API functions in ${params.dropin}`, data);
+        }
+        const registry = getApiFunctionRegistry();
+        const overview = Object.entries(registry.dropins).map(([dropinName, dropinData]) => {
+            const entry = {
+                dropin: dropinName,
+                version: dropinData.version,
+                importPath: dropinData.importPath,
+                functionCount: dropinData.functions.length,
+                functions: dropinData.functions.map((f) => ({
+                    name: f.name,
+                    signature: f.signature,
+                    description: f.description,
+                })),
+                utilsImportPath: dropinData.utils?.importPath,
+                utilModules: dropinData.utils
+                    ? Object.keys(dropinData.utils.modules)
+                    : undefined,
+            };
+            return entry;
+        });
+        const totalFunctions = overview.reduce((sum, d) => sum + d.functionCount, 0);
+        return formatSuccessResponse(`Found ${totalFunctions} API functions across ${overview.length} dropins`, { sharedFunctions: registry.sharedFunctions, overview });
+    }
+    catch (error) {
+        return formatExceptionResponse(error, "listing API functions");
+    }
+}

package/dist/operations/list-containers.d.ts

@@ -0,0 +1,13 @@
+import { z } from "zod";
+export declare const ListContainersSchema: z.ZodObject<{
+    dropin: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    dropin?: string | undefined;
+}, {
+    dropin?: string | undefined;
+}>;
+export declare function listContainers(params: z.infer<typeof ListContainersSchema>): Promise<{
+    success: boolean;
+    message: string;
+    data: unknown;
+}>;

package/dist/operations/list-containers.js

@@ -0,0 +1,44 @@
+import { z } from "zod";
+import { formatSuccessResponse, formatExceptionResponse, } from "../common/response-handling.js";
+import { getContainerRegistry, getContainersByDropin, getAllDropinNames, } from "../common/registry-loader.js";
+export const ListContainersSchema = z.object({
+    dropin: z
+        .string()
+        .optional()
+        .describe("Filter by dropin name (e.g. storefront-cart). Omit to list all."),
+});
+export async function listContainers(params) {
+    try {
+        if (params.dropin) {
+            const dropinData = getContainersByDropin(params.dropin);
+            if (!dropinData) {
+                const availableDropins = getAllDropinNames();
+                return formatSuccessResponse(`Dropin "${params.dropin}" not found`, {
+                    availableDropins,
+                });
+            }
+            return formatSuccessResponse(`Found ${dropinData.containers.length} containers in ${params.dropin}`, {
+                version: dropinData.version,
+                renderImport: dropinData.renderImport,
+                apiImport: dropinData.apiImport,
+                containers: dropinData.containers,
+            });
+        }
+        const registry = getContainerRegistry();
+        const overview = Object.entries(registry.dropins).map(([dropinName, dropinData]) => ({
+            dropin: dropinName,
+            version: dropinData.version,
+            containerCount: dropinData.containers.length,
+            containers: dropinData.containers.map((c) => ({
+                name: c.name,
+                description: c.description,
+                slotNames: c.slotNames,
+            })),
+        }));
+        const totalContainers = overview.reduce((sum, d) => sum + d.containerCount, 0);
+        return formatSuccessResponse(`Found ${totalContainers} containers across ${overview.length} dropins`, { overview });
+    }
+    catch (error) {
+        return formatExceptionResponse(error, "listing containers");
+    }
+}

package/dist/operations/list-design-tokens.d.ts

@@ -0,0 +1,13 @@
+import { z } from "zod";
+export declare const ListDesignTokensSchema: z.ZodObject<{
+    category: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    category?: string | undefined;
+}, {
+    category?: string | undefined;
+}>;
+export declare function listDesignTokens(params: z.infer<typeof ListDesignTokensSchema>): Promise<{
+    success: boolean;
+    message: string;
+    data: unknown;
+}>;

package/dist/operations/list-design-tokens.js

@@ -0,0 +1,47 @@
+import { z } from "zod";
+import { formatSuccessResponse, formatExceptionResponse, } from "../common/response-handling.js";
+import { getDesignTokenRegistry, getDesignTokensByCategory, } from "../common/registry-loader.js";
+export const ListDesignTokensSchema = z.object({
+    category: z
+        .string()
+        .optional()
+        .describe("Token category: colors, typography, spacing, shapes, grid. Omit to list all."),
+});
+export async function listDesignTokens(params) {
+    try {
+        const registry = getDesignTokenRegistry();
+        if (params.category) {
+            const categoryData = getDesignTokensByCategory(params.category);
+            if (!categoryData) {
+                const availableCategories = Object.keys(registry.categories);
+                return formatSuccessResponse(`Category "${params.category}" not found`, { availableCategories });
+            }
+            const tokens = categoryData.tokens ?? [];
+            return formatSuccessResponse(`Found ${tokens.length} tokens in category "${params.category}"`, {
+                category: params.category,
+                description: categoryData.description,
+                tokens,
+                cssScope: registry.cssScope,
+                overrideExample: registry.overrideExample,
+            });
+        }
+        const overview = Object.entries(registry.categories).map(([categoryName, categoryData]) => ({
+            category: categoryName,
+            description: categoryData.description,
+            tokenCount: categoryData.tokens?.length ?? 0,
+            tokens: categoryData.tokens?.map((t) => ({
+                cssVariable: t.cssVariable,
+                defaultValue: t.defaultValue,
+            })) ?? [],
+        }));
+        const totalTokens = overview.reduce((sum, c) => sum + c.tokenCount, 0);
+        return formatSuccessResponse(`Found ${totalTokens} design tokens across ${overview.length} categories`, {
+            cssScope: registry.cssScope,
+            overrideExample: registry.overrideExample,
+            overview,
+        });
+    }
+    catch (error) {
+        return formatExceptionResponse(error, "listing design tokens");
+    }
+}

package/dist/operations/list-events.d.ts

@@ -0,0 +1,16 @@
+import { z } from "zod";
+export declare const ListEventsSchema: z.ZodObject<{
+    dropin: z.ZodOptional<z.ZodString>;
+    direction: z.ZodOptional<z.ZodEnum<["emitted", "consumed", "all"]>>;
+}, "strip", z.ZodTypeAny, {
+    dropin?: string | undefined;
+    direction?: "emitted" | "consumed" | "all" | undefined;
+}, {
+    dropin?: string | undefined;
+    direction?: "emitted" | "consumed" | "all" | undefined;
+}>;
+export declare function listEvents(params: z.infer<typeof ListEventsSchema>): Promise<{
+    success: boolean;
+    message: string;
+    data: unknown;
+}>;

package/dist/operations/list-events.js

@@ -0,0 +1,39 @@
+import { z } from "zod";
+import { formatSuccessResponse, formatExceptionResponse, } from "../common/response-handling.js";
+import { getEventCatalog, getEventsByDropin, getAllDropinNames, } from "../common/registry-loader.js";
+export const ListEventsSchema = z.object({
+    dropin: z
+        .string()
+        .optional()
+        .describe("Filter events by dropin name (e.g. storefront-cart)"),
+    direction: z
+        .enum(["emitted", "consumed", "all"])
+        .optional()
+        .describe("Filter by direction: emitted, consumed, or all (default: all)"),
+});
+export async function listEvents(params) {
+    try {
+        if (params.dropin) {
+            const direction = params.direction ?? "all";
+            const events = getEventsByDropin(params.dropin, direction);
+            if (events.length === 0) {
+                const availableDropins = getAllDropinNames();
+                return formatSuccessResponse(`No events found for dropin "${params.dropin}" (direction: ${direction})`, { availableDropins });
+            }
+            return formatSuccessResponse(`Found ${events.length} events for ${params.dropin} (direction: ${direction})`, { events });
+        }
+        const catalog = getEventCatalog();
+        const events = catalog.events ?? [];
+        const summary = events.map((event) => ({
+            name: event.name,
+            payloadType: event.payloadType,
+            description: event.description,
+            emittedBy: event.emittedBy?.map((e) => e.dropin) ?? [],
+            consumedBy: event.consumedBy?.map((c) => c.dropin) ?? [],
+        }));
+        return formatSuccessResponse(`Found ${events.length} events in the catalog`, { events: summary });
+    }
+    catch (error) {
+        return formatExceptionResponse(error, "listing events");
+    }
+}

package/dist/operations/list-graphql-queries.d.ts

@@ -0,0 +1,19 @@
+import { z } from "zod";
+export declare const ListGraphqlQueriesSchema: z.ZodObject<{
+    dropin: z.ZodOptional<z.ZodString>;
+    type: z.ZodOptional<z.ZodEnum<["query", "mutation"]>>;
+    name: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type?: "query" | "mutation" | undefined;
+    dropin?: string | undefined;
+    name?: string | undefined;
+}, {
+    type?: "query" | "mutation" | undefined;
+    dropin?: string | undefined;
+    name?: string | undefined;
+}>;
+export declare function listGraphqlQueries(params: z.infer<typeof ListGraphqlQueriesSchema>): Promise<{
+    success: boolean;
+    message: string;
+    data: unknown;
+}>;

package/dist/operations/list-graphql-queries.js

@@ -0,0 +1,84 @@
+import { z } from "zod";
+import { formatSuccessResponse, formatExceptionResponse, } from "../common/response-handling.js";
+import { getGraphqlRegistry, getGraphqlByDropin, getAllDropinNames, } from "../common/registry-loader.js";
+function filterOperations(operations, type, name) {
+    let result = operations;
+    if (type) {
+        result = result.filter((op) => op.type === type);
+    }
+    if (name) {
+        const search = name.toLowerCase();
+        result = result.filter((op) => op.name?.toLowerCase().includes(search));
+    }
+    return result;
+}
+function filterFragments(fragments, name) {
+    if (!name)
+        return fragments;
+    const search = name.toLowerCase();
+    return fragments.filter((f) => f.name?.toLowerCase().includes(search));
+}
+export const ListGraphqlQueriesSchema = z.object({
+    dropin: z
+        .string()
+        .optional()
+        .describe("Filter by dropin name (e.g. storefront-cart). Omit to list all."),
+    type: z
+        .enum(["query", "mutation"])
+        .optional()
+        .describe("Filter by operation type: query or mutation."),
+    name: z
+        .string()
+        .optional()
+        .describe("Search by operation or fragment name (case-insensitive substring match)."),
+});
+export async function listGraphqlQueries(params) {
+    try {
+        if (params.dropin) {
+            const dropinData = getGraphqlByDropin(params.dropin);
+            if (!dropinData) {
+                const availableDropins = getAllDropinNames();
+                return formatSuccessResponse(`Dropin "${params.dropin}" not found in GraphQL registry`, { availableDropins });
+            }
+            const operations = filterOperations(dropinData.operations ?? [], params.type, params.name);
+            const fragments = filterFragments(dropinData.fragments ?? [], params.name);
+            const exportedFragments = fragments.filter((f) => f.exported);
+            return formatSuccessResponse(`Found ${operations.length} operation(s) and ${fragments.length} fragment(s) in ${params.dropin}`, {
+                version: dropinData.version,
+                operations,
+                fragments,
+                extensibility: {
+                    exportedFragmentCount: exportedFragments.length,
+                    hint: exportedFragments.length > 0
+                        ? "Exported fragments can be extended via overrideGQLOperations in build.mjs"
+                        : "No exported fragments found for this dropin",
+                },
+            });
+        }
+        const registry = getGraphqlRegistry();
+        const overview = Object.entries(registry.dropins).map(([dropinName, dropinData]) => {
+            const operations = filterOperations(dropinData.operations ?? [], params.type, params.name);
+            const allFragments = dropinData.fragments ?? [];
+            const filteredFragments = filterFragments(allFragments, params.name);
+            const exportedCount = allFragments.filter((f) => f.exported).length;
+            return {
+                dropin: dropinName,
+                version: dropinData.version,
+                operationCount: operations.length,
+                fragmentCount: filteredFragments.length,
+                exportedFragmentCount: exportedCount,
+                operations: operations.map(({ source: _, ...rest }) => rest),
+            };
+        });
+        const filtered = overview.filter((d) => d.operationCount > 0 || d.fragmentCount > 0);
+        const totalOps = filtered.reduce((sum, d) => sum + d.operationCount, 0);
+        const totalFrags = filtered.reduce((sum, d) => sum + d.fragmentCount, 0);
+        return formatSuccessResponse(`Found ${totalOps} operation(s) and ${totalFrags} fragment(s) across ${filtered.length} dropin(s)`, {
+            hint: "Use dropin parameter to see operation variables, fragment dependencies, and exported fragment source. Fragments marked as 'exported' are extensible via overrideGQLOperations in build.mjs.",
+            overview: filtered,
+        });
+    }
+    catch (error) {
+        return formatExceptionResponse(error, "listing GraphQL queries");
+    }
+}

package/dist/operations/list-i18n-keys.d.ts

@@ -0,0 +1,19 @@
+import { z } from "zod";
+export declare const ListI18nKeysSchema: z.ZodObject<{
+    dropin: z.ZodOptional<z.ZodString>;
+    query: z.ZodOptional<z.ZodString>;
+    containerName: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    query?: string | undefined;
+    dropin?: string | undefined;
+    containerName?: string | undefined;
+}, {
+    query?: string | undefined;
+    dropin?: string | undefined;
+    containerName?: string | undefined;
+}>;
+export declare function listI18nKeys(params: z.infer<typeof ListI18nKeysSchema>): Promise<{
+    success: boolean;
+    message: string;
+    data: unknown;
+}>;

package/dist/operations/list-i18n-keys.js

@@ -0,0 +1,105 @@
+import { z } from "zod";
+import { formatSuccessResponse, formatExceptionResponse, } from "../common/response-handling.js";
+import { getI18nRegistry, getContainerRegistry, } from "../common/registry-loader.js";
+export const ListI18nKeysSchema = z.object({
+    dropin: z
+        .string()
+        .optional()
+        .describe('Filter to a specific dropin (e.g. "storefront-checkout"). Omit to search across all dropins.'),
+    query: z
+        .string()
+        .optional()
+        .describe('Substring filter applied to both key paths and values (e.g. "email" matches Checkout.LoginForm.invalidEmailError and its value). Case-insensitive.'),
+    containerName: z
+        .string()
+        .optional()
+        .describe('Filter to keys used by a specific container (e.g. "MiniCart"). Derived from the second segment of the dot-notation key path.'),
+});
+function inferContainer(key) {
+    const parts = key.split(".");
+    return parts.length >= 2 ? parts[1] : "(unlinked)";
+}
+export async function listI18nKeys(params) {
+    var _a;
+    try {
+        const registry = getI18nRegistry();
+        const allDropins = Object.keys(registry.dropins);
+        if (allDropins.length === 0) {
+            return formatSuccessResponse("i18n registry is empty", {
+                hint: "Run the generate script to populate registry/i18n.json",
+                query: null,
+                dropinFilter: null,
+                containerFilter: null,
+                totalMatched: 0,
+                dropins: [],
+            });
+        }
+        const searchDropins = params.dropin ? [params.dropin] : allDropins;
+        if (params.dropin && !registry.dropins[params.dropin]) {
+            return formatSuccessResponse(`Dropin "${params.dropin}" not found in i18n registry`, {
+                error: "Dropin not found",
+                availableDropins: allDropins,
+            });
+        }
+        const lowerQuery = params.query?.toLowerCase().trim() ?? "";
+        const lowerContainer = params.containerName?.toLowerCase().trim() ?? "";
+        const containerRegistry = getContainerRegistry();
+        const knownContainerNames = new Set(Object.values(containerRegistry.dropins).flatMap((d) => d.containers.map((c) => c.name.toLowerCase())));
+        const matches = [];
+        for (const dropinName of searchDropins) {
+            const dropinData = registry.dropins[dropinName];
+            if (!dropinData)
+                continue;
+            for (const [key, value] of Object.entries(dropinData.keys)) {
+                const container = inferContainer(key);
+                if (lowerContainer && container.toLowerCase() !== lowerContainer) {
+                    continue;
+                }
+                if (!lowerQuery ||
+                    key.toLowerCase().includes(lowerQuery) ||
+                    value.toLowerCase().includes(lowerQuery)) {
+                    matches.push({ dropin: dropinName, container, key, value });
+                }
+            }
+        }
+        const grouped = {};
+        for (const { dropin, container, key, value } of matches) {
+            grouped[dropin] ?? (grouped[dropin] = {});
+            (_a = grouped[dropin])[container] ?? (_a[container] = []);
+            grouped[dropin][container].push({ key, value });
+        }
+        const dropinSummary = Object.entries(grouped).map(([dropin, containers]) => {
+            const containerEntries = Object.entries(containers).map(([container, keys]) => ({
+                container,
+                knownContainer: knownContainerNames.has(container.toLowerCase()),
+                keys,
+            }));
+            return {
+                dropin,
+                version: registry.dropins[dropin]?.version ?? "unknown",
+                matchedKeys: containerEntries.reduce((sum, c) => sum + c.keys.length, 0),
+                containers: containerEntries,
+            };
+        });
+        const filterParts = [];
+        if (params.dropin)
+            filterParts.push(params.dropin);
+        if (params.containerName)
+            filterParts.push(`container "${params.containerName}"`);
+        if (params.query)
+            filterParts.push(`query "${params.query}"`);
+        const filterDesc = filterParts.length
+            ? ` in ${filterParts.join(", ")}`
+            : " across all dropins";
+        return formatSuccessResponse(`Found ${matches.length} key(s)${filterDesc}`, {
+            query: params.query ?? null,
+            dropinFilter: params.dropin ?? null,
+            containerFilter: params.containerName ?? null,
+            totalMatched: matches.length,
+            dropins: dropinSummary,
+        });
+    }
+    catch (error) {
+        return formatExceptionResponse(error, "listing i18n keys");
+    }
+}

package/dist/operations/list-models.d.ts

@@ -0,0 +1,16 @@
+import { z } from "zod";
+export declare const ListModelsSchema: z.ZodObject<{
+    dropin: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    dropin?: string | undefined;
+    model?: string | undefined;
+}, {
+    dropin?: string | undefined;
+    model?: string | undefined;
+}>;
+export declare function listModels(params: z.infer<typeof ListModelsSchema>): Promise<{
+    success: boolean;
+    message: string;
+    data: unknown;
+}>;

package/dist/operations/list-models.js

@@ -0,0 +1,80 @@
+import { z } from "zod";
+import { formatSuccessResponse, formatExceptionResponse, } from "../common/response-handling.js";
+import { getModelsRegistry, getModelsByDropin, findModel, getAllDropinNames, } from "../common/registry-loader.js";
+export const ListModelsSchema = z.object({
+    dropin: z
+        .string()
+        .optional()
+        .describe("Filter models by dropin name (e.g. storefront-cart)"),
+    model: z
+        .string()
+        .optional()
+        .describe("Find a specific model by name (e.g. CartModel, Price, Item). Returns full definition."),
+});
+export async function listModels(params) {
+    try {
+        if (params.model) {
+            if (params.dropin) {
+                const models = getModelsByDropin(params.dropin);
+                const found = models.find((m) => m.name === params.model);
+                if (!found) {
+                    return formatSuccessResponse(`Model "${params.model}" not found in ${params.dropin}`, {
+                        availableModels: models.map((m) => m.name),
+                        hint: "The model may exist in a different dropin. Omit the dropin parameter to search globally.",
+                    });
+                }
+                return formatSuccessResponse(`Found model "${params.model}" in ${params.dropin}`, {
+                    name: found.name,
+                    kind: found.kind,
+                    dropin: params.dropin,
+                    definition: found.definition,
+                });
+            }
+            const matches = findModel(params.model);
+            if (matches.length === 0) {
+                return formatSuccessResponse(`Model "${params.model}" not found in any dropin`, {
+                    suggestion: "Try searching with a different name or list all models for a dropin",
+                });
+            }
+            if (matches.length === 1) {
+                return formatSuccessResponse(`Found model "${params.model}" in ${matches[0].dropin}`, {
+                    name: matches[0].name,
+                    kind: matches[0].kind,
+                    dropin: matches[0].dropin,
+                    definition: matches[0].definition,
+                });
+            }
+            return formatSuccessResponse(`Model "${params.model}" exists in ${matches.length} dropins — specify a dropin parameter to get the exact definition`, {
+                matches: matches.map((m) => ({
+                    dropin: m.dropin,
+                    kind: m.kind,
+                    definition: m.definition,
+                })),
+            });
+        }
+        if (params.dropin) {
+            const models = getModelsByDropin(params.dropin);
+            if (models.length === 0) {
+                const availableDropins = getAllDropinNames();
+                return formatSuccessResponse(`No models found for dropin "${params.dropin}"`, { availableDropins });
+            }
+            return formatSuccessResponse(`Found ${models.length} models in ${params.dropin}`, {
+                models: models.map((m) => ({
+                    name: m.name,
+                    kind: m.kind,
+                    definition: m.definition,
+                })),
+            });
+        }
+        const registry = getModelsRegistry();
+        const summary = Object.entries(registry.dropins).map(([dropin, data]) => ({
+            dropin,
+            modelCount: data.models.length,
+            models: data.models.map((m) => m.name),
+        }));
+        return formatSuccessResponse(`Model registry contains definitions across ${summary.length} dropins`, { dropins: summary });
+    }
+    catch (error) {
+        return formatExceptionResponse(error, "listing models");
+    }
+}

package/dist/operations/list-slots.d.ts

@@ -0,0 +1,16 @@
+import { z } from "zod";
+export declare const ListSlotsSchema: z.ZodObject<{
+    dropin: z.ZodOptional<z.ZodString>;
+    container: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    dropin?: string | undefined;
+    container?: string | undefined;
+}, {
+    dropin?: string | undefined;
+    container?: string | undefined;
+}>;
+export declare function listSlots(params: z.infer<typeof ListSlotsSchema>): Promise<{
+    success: boolean;
+    message: string;
+    data: unknown;
+}>;

package/dist/operations/list-slots.js

@@ -0,0 +1,81 @@
+import { z } from "zod";
+import { formatSuccessResponse, formatExceptionResponse, } from "../common/response-handling.js";
+import { getSlotRegistry, getSlotsByDropin, getSlotsByContainer, getAllDropinNames, } from "../common/registry-loader.js";
+export const ListSlotsSchema = z.object({
+    dropin: z
+        .string()
+        .optional()
+        .describe("Dropin name (e.g. storefront-cart). Omit to list all."),
+    container: z
+        .string()
+        .optional()
+        .describe("Container name (e.g. CartSummaryList). Requires dropin to be set."),
+});
+export async function listSlots(params) {
+    try {
+        const availableDropins = getAllDropinNames();
+        if (params.container && !params.dropin) {
+            return formatSuccessResponse('The "container" filter requires "dropin" to be specified', {
+                hint: 'Provide both dropin and container, e.g. { dropin: "storefront-cart", container: "CartSummaryList" }',
+                availableDropins,
+            });
+        }
+        if (params.dropin && params.container) {
+            const containerData = getSlotsByContainer(params.dropin, params.container);
+            if (!containerData) {
+                const dropinData = getSlotsByDropin(params.dropin);
+                return formatSuccessResponse(`Container "${params.container}" not found in ${params.dropin}`, {
+                    availableContainers: dropinData
+                        ? Object.keys(dropinData.containers)
+                        : [],
+                    hint: !dropinData
+                        ? `Dropin "${params.dropin}" not found. Available: ${availableDropins.join(", ")}`
+                        : undefined,
+                });
+            }
+            const hasDefaultCtx = (containerData.slots ?? []).some((s) => s.contextType === "DefaultSlotContext");
+            const registry = getSlotRegistry();
+            return formatSuccessResponse(`Slots for ${params.dropin} > ${params.container}`, {
+                ...containerData,
+                ...(hasDefaultCtx && registry.defaultSlotContext
+                    ? { defaultSlotContext: registry.defaultSlotContext }
+                    : {}),
+            });
+        }
+        if (params.dropin) {
+            const dropinData = getSlotsByDropin(params.dropin);
+            if (!dropinData) {
+                return formatSuccessResponse(`Dropin "${params.dropin}" not found`, {
+                    availableDropins,
+                });
+            }
+            const summary = Object.entries(dropinData.containers).map(([containerName, containerData]) => ({
+                container: containerName,
+                slotCount: (containerData.slots ?? []).length,
+                slotNames: (containerData.slots ?? []).map((s) => s.name),
+            }));
+            return formatSuccessResponse(`Slots for ${params.dropin}`, {
+                containers: summary,
+                raw: dropinData,
+            });
+        }
+        const registry = getSlotRegistry();
+        const overview = Object.entries(registry.dropins).map(([dropinName, dropinData]) => {
+            const containers = Object.entries(dropinData.containers).map(([containerName, containerData]) => ({
+                container: containerName,
+                slotCount: (containerData.slots ?? []).length,
+                slotNames: (containerData.slots ?? []).map((s) => s.name),
+            }));
+            return {
+                dropin: dropinName,
+                totalSlots: containers.reduce((sum, c) => sum + c.slotCount, 0),
+                containers,
+            };
+        });
+        const totalSlots = overview.reduce((sum, d) => sum + d.totalSlots, 0);
+        return formatSuccessResponse(`Found ${totalSlots} slots across ${overview.length} dropins`, { overview });
+    }
+    catch (error) {
+        return formatExceptionResponse(error, "listing slots");
+    }
+}