@wix/mcp 1.0.5 → 1.0.6

package/build/chunk-YRLMZUQM.js

@@ -0,0 +1,1834 @@
+// src/logger.ts
+import fs from "fs/promises";
+import path from "path";
+import { homedir } from "os";
+var createNullLogger = () => {
+  return {
+    log: () => {
+    },
+    error: () => {
+    }
+  };
+};
+var createStdErrLogger = () => {
+  return {
+    log: (data) => {
+      console.error(data);
+    },
+    error: (data) => {
+      console.error(data);
+    }
+  };
+};
+var createMcpServerLogger = (server) => {
+  return {
+    log: (data) => {
+      server.server.sendLoggingMessage({ level: "info", data });
+    },
+    error: (data) => {
+      server.server.sendLoggingMessage({ level: "error", data });
+    }
+  };
+};
+var createFileLogger = () => {
+  const filePath = path.join(homedir(), "wix-mcp-log.txt");
+  const date = (/* @__PURE__ */ new Date()).toLocaleString("en-US", { timeZone: "Asia/Jerusalem" }).replace(/,/g, "");
+  return {
+    log: (...data) => {
+      const message = `[info] ${date} - ${data.join(" ")}`;
+      fs.appendFile(filePath, `${message}
+`);
+    },
+    error: (...data) => {
+      const message = `[error] ${date} - ${data.join(" ")}`;
+      fs.appendFile(filePath, `${message}
+`);
+    }
+  };
+};
+var logger = createNullLogger();
+var attachMcpServerLogger = (server) => {
+  const mcpLogger = createMcpServerLogger(server);
+  logger.log = mcpLogger.log;
+  logger.error = mcpLogger.error;
+};
+var attachStdErrLogger = () => {
+  const stdErrLogger = createStdErrLogger();
+  logger.log = stdErrLogger.log;
+  logger.error = stdErrLogger.error;
+};
+var attachFileLogger = () => {
+  const fileLogger = createFileLogger();
+  logger.log = fileLogger.log;
+  logger.error = fileLogger.error;
+};
+
+// src/docs/docs.ts
+import { z } from "zod";
+
+// src/docs/semanticSearch.ts
+var MAX_CONTENT_LENGTH = 1e4;
+var DEFAULT_MAX_RESULTS = 10;
+var runSemanticSearch = async (toolName, toolParams, maxResults = 20, rerank = false) => {
+  const startTime = (/* @__PURE__ */ new Date()).getTime();
+  const url = new URL(
+    `https://www.wixapis.com/mcp-docs-search/v1/search?maxResults=${maxResults}&rerank=${rerank}`
+  );
+  if (toolName === "SDK") {
+    url.searchParams.append("kbName", "SDK_SCHEMAS_KB_ID");
+    url.searchParams.append("kbName", "SDK_DOCS_KB_ID");
+  } else if (toolName === "REST" || toolName === "BUSINESS_SOLUTIONS") {
+    if (toolName === "REST") {
+      url.searchParams.append("kbName", "REST_METHODS_KB_ID");
+    }
+    url.searchParams.append("kbName", "REST_DOCS_KB_ID");
+    url.searchParams.append("kbName", "MCP_REST_RECIPES_KB_ID");
+  } else if (toolName === "WDS") {
+    url.searchParams.append("kbName", "WDS_DOCS_KB_ID");
+  } else if (toolName === "BUILD_APPS") {
+    url.searchParams.append("kbName", "BUILD_APPS_KB_ID");
+  } else if (toolName === "WIX_HEADLESS") {
+    url.searchParams.append("kbName", "HEADLESS_KB_ID");
+  }
+  for (const [key, value] of Object.entries(toolParams)) {
+    url.searchParams.append(key, value);
+  }
+  logger.log("Running RAG search", url.toString());
+  const response = await fetch(url.toString(), {
+    headers: {
+      "Content-Type": "application/json",
+      "x-time-budget": "180000",
+      "x-wix-time-budget": "180000"
+    }
+  });
+  if (!response.ok) {
+    logger.error(`Failed to run rag search: ${response.statusText}`);
+    throw new Error(`Failed to run rag search: ${response.statusText}`);
+  }
+  const data = await response.json();
+  const endTime = (/* @__PURE__ */ new Date()).getTime();
+  const timeTaskFormatted = (endTime - startTime) / 1e3;
+  logger.log(
+    "Ran RAG search successfully with params",
+    JSON.stringify(toolParams),
+    timeTaskFormatted,
+    typeof data
+  );
+  return data?.results;
+};
+var getContentFromChunkedContent = (chunkedContent) => {
+  let content = "";
+  for (const chunk of chunkedContent) {
+    if (content.length + chunk.length > MAX_CONTENT_LENGTH) {
+      break;
+    }
+    content += "\n\n---\n\n" + chunk;
+  }
+  return content;
+};
+var formatResultsContent = (resultsFromKbs, maxResults, linesInEachResult = void 0) => {
+  const allResults = Object.entries(resultsFromKbs).map(([, { results }]) => results).flat();
+  if (allResults.length === 0) {
+    throw new Error("No result from search");
+  }
+  const sortedResults = allResults.sort(
+    (a, b) => b.scoresInfo.overallMatchScore - a.scoresInfo.overallMatchScore
+  );
+  const topResults = sortedResults.slice(0, maxResults);
+  const concatenatedContent = topResults.map((result) => {
+    let newContent = result.entry.content;
+    if (linesInEachResult) {
+      const totalLines = newContent.split("\n").length;
+      const linesToTake = Math.min(linesInEachResult, totalLines);
+      newContent = newContent.split("\n").slice(0, linesToTake).join("\n");
+      const moreLines = totalLines - linesToTake;
+      const moreLinesText = moreLines > 0 ? `
+
+... ${moreLines} more lines ...` : "";
+      newContent = `${newContent}${moreLinesText}`;
+    }
+    return {
+      ...result,
+      entry: {
+        ...result.entry,
+        content: newContent
+      }
+    };
+  }).map((result) => {
+    const content = result.entry.content;
+    const chunkedContent = result.entry.chunkedContent;
+    if (content.length > MAX_CONTENT_LENGTH) {
+      logger.log(`Content is too long, using chunked content`, {
+        contentLength: content.length,
+        chunkedContentLength: chunkedContent.length
+      });
+      return getContentFromChunkedContent(chunkedContent);
+    }
+    return content;
+  }).join("\n\n---\n\n");
+  return concatenatedContent;
+};
+var runSemanticSearchAndFormat = async ({
+  toolName,
+  toolParams,
+  maxResults = DEFAULT_MAX_RESULTS,
+  rerank,
+  linesInEachResult
+}) => {
+  const results = await runSemanticSearch(
+    toolName,
+    toolParams,
+    maxResults,
+    rerank
+  );
+  const maxResultsToUse = Math.min(maxResults, DEFAULT_MAX_RESULTS);
+  return formatResultsContent(results, maxResultsToUse, linesInEachResult);
+};
+
+// src/docs/docs.ts
+import { captureException } from "@sentry/node";
+var VALID_DOCS_TOOLS = [
+  "WDS",
+  "REST",
+  "SDK",
+  "BUILD_APPS",
+  "WIX_HEADLESS",
+  "BUSINESS_SOLUTIONS"
+];
+var addDocsTools = (server, allowedTools = [
+  "WDS",
+  "REST",
+  "SDK",
+  "BUILD_APPS",
+  "WIX_HEADLESS",
+  "BUSINESS_SOLUTIONS"
+]) => {
+  if (allowedTools.includes("WDS")) {
+    server.tool(
+      "SearchWixWDSDocumentation",
+      [
+        "Searches the Wix Design System Documentation for components and patterns.",
+        "Use this tool when you need to understand or implement UI components and design patterns in a Wix project.",
+        "Search for specific component names, patterns, or UI requirements.",
+        "If you can't find what you need, try to rephrase your search term or use bigger maxResults value."
+      ].join("\n"),
+      {
+        searchTerm: z.string().describe(
+          "The search term to search for in the Wix Design System Documentation"
+        ),
+        maxResults: z.number().describe(
+          "The maximum number of results to return, default is 5, max is 15"
+        ).min(1).max(15).optional().default(10)
+      },
+      async ({ searchTerm, maxResults }, { panorama }) => {
+        try {
+          logger.log(`Searching for ${searchTerm} in Wix WDS`);
+          const result = await runSemanticSearchAndFormat({
+            toolName: "WDS",
+            toolParams: {
+              searchTerm
+            },
+            maxResults: Math.max(1, Math.min(maxResults ?? 5, 15))
+          });
+          return {
+            content: [
+              {
+                type: "text",
+                text: result
+              }
+            ]
+          };
+        } catch (error) {
+          panorama.errorMonitor().reportError(error);
+          captureException(error, {
+            tags: {
+              componentId: "SearchWixWDSDocumentation",
+              toolName: "SearchWixWDSDocumentation"
+            }
+          });
+          logger.error(
+            `Error searching for ${searchTerm} in Wix WDS: ${error}`
+          );
+          return {
+            isError: true,
+            content: [{ type: "text", text: "Error: " + error.message }]
+          };
+        }
+      }
+    );
+  }
+  if (allowedTools.includes("REST")) {
+    server.tool(
+      "SearchWixRESTDocumentation",
+      [
+        "Searches the official Wix REST API documentation.",
+        "Use this tool whenever you need to to interact with the Wix platform via HTTP requests.",
+        "Specify the API endpoint, resource, or action you need information about (e.g., 'get site details endpoint', 'create data collection', 'update product API', 'REST authentication').",
+        "If you can't find what you need, try to rephrase your search term or use bigger maxResults value."
+      ].join("\n"),
+      {
+        searchTerm: z.string().describe(
+          "The search term to search for in the Wix REST API Documentation"
+        ),
+        maxResults: z.number().describe(
+          "The maximum number of results to return, default is 5, max is 15"
+        ).min(1).max(15).optional().default(10)
+      },
+      async ({ searchTerm, maxResults }, { panorama }) => {
+        try {
+          logger.log(`Searching for ${searchTerm} in Wix REST API`);
+          const result = await runSemanticSearchAndFormat({
+            toolName: "REST",
+            toolParams: {
+              searchTerm
+            },
+            maxResults: Math.max(1, Math.min(maxResults ?? 5, 15)),
+            linesInEachResult: 15
+          });
+          return {
+            content: [
+              {
+                type: "text",
+                text: result
+              },
+              {
+                type: "text",
+                text: "Next, you MUST use the ReadFullDocsArticle tool if you want to read the full documentation for a specific article or method."
+              }
+            ]
+          };
+        } catch (error) {
+          panorama.errorMonitor().reportError(error);
+          captureException(error, {
+            tags: {
+              componentId: "SearchWixRESTDocumentation",
+              toolName: "SearchWixRESTDocumentation"
+            }
+          });
+          logger.error(
+            `Error searching for ${searchTerm} in Wix REST API: ${error}`
+          );
+          return {
+            isError: true,
+            content: [{ type: "text", text: "Error: " + error.message }]
+          };
+        }
+      }
+    );
+  }
+  if (allowedTools.includes("BUSINESS_SOLUTIONS")) {
+    server.tool(
+      "WixBusinessFlowsDocumentation",
+      [
+        "This tool provides step-by-step recipes for setting up complex Wix business solutions that involve multiple API calls.",
+        "It excels at guiding the creation of features like booking systems with payments.",
+        "For example, it can guide the setup of a service in Wix Bookings where customers can pay using Wix Payments, such as creating a bookable yoga class",
+        "It searches the Wix Business Solutions documentation for these integrated workflows involving services, bookings, payments, stores, blogs, and more.",
+        "This tool returns a list of articles that are potentially relevant to the input search term.",
+        "**IMPORTANT NOTES:**",
+        "1. Before attempting to implement a multi step API calls on Wix, YOU MUST TRY THIS TOOL FIRST.",
+        "2. Out of the returned list of articles that you will receive, you MUST select the most relevant one and use the ReadFullDocsArticle tool to fetch it."
+      ].join("\n"),
+      {
+        searchTerm: z.string().describe(
+          'The search term for the required sample flow (e.g. "setup a new business")'
+        ),
+        maxResults: z.number().describe(
+          "The maximum number of results to return, default is 5, max is 15"
+        ).min(1).max(15).optional().default(5)
+      },
+      async ({ searchTerm, maxResults }, { panorama }) => {
+        try {
+          logger.log(`Searching for ${searchTerm} in Wix Sample Flows`);
+          const result = await runSemanticSearchAndFormat({
+            toolName: "BUSINESS_SOLUTIONS",
+            toolParams: {
+              searchTerm: "**RECIPE**:  Business Recipes - full setup flow for::: " + searchTerm
+            },
+            maxResults: Math.max(1, Math.min(maxResults ?? 5, 15))
+          });
+          return {
+            content: [
+              {
+                type: "text",
+                text: result
+              },
+              {
+                type: "text",
+                text: `Out of the included list of articles, you **MUST** select the one that is most relevant to the user's request and use the ReadFullDocsArticle tool to fetch it.`
+              }
+            ]
+          };
+        } catch (error) {
+          panorama.errorMonitor().reportError(error);
+          captureException(error, {
+            tags: {
+              componentId: "SearchWixSampleFlowsDocumentation",
+              toolName: "SearchWixSampleFlowsDocumentation"
+            }
+          });
+          logger.error(
+            `Error searching for ${searchTerm} in Wix Sample Flows: ${error}`
+          );
+          return {
+            isError: true,
+            content: [{ type: "text", text: "Error: " + error.message }]
+          };
+        }
+      }
+    );
+  }
+  if (allowedTools.includes("SDK")) {
+    server.tool(
+      "SearchWixSDKDocumentation",
+      [
+        "Searches the official Wix javascript SDK documentation.",
+        "Use this tool whenever you need to write or modify Wix related SDK code.",
+        "Specify the SDK module, function, or feature you need information about (e.g., 'how to query all items from a data collection?', 'how to use wix-stores-backend', 'authentication methods in the SDK').",
+        "If you can't find what you need, try to rephrase your search term or use bigger maxResults value."
+      ].join("\n"),
+      {
+        searchTerm: z.string().describe(
+          "The search term to search for in the Wix SDK Documentation"
+        ),
+        maxResults: z.number().describe(
+          "The maximum number of results to return, default is 5, max is 15"
+        ).min(1).max(15).optional().default(5)
+      },
+      async ({ searchTerm, maxResults }, { panorama }) => {
+        try {
+          logger.log(`Searching for ${searchTerm} in Wix SDK`);
+          panorama.transaction("SearchWixSDKDocumentation").start({ maxResults });
+          const result = await runSemanticSearchAndFormat({
+            toolName: "SDK",
+            toolParams: {
+              searchTerm
+            },
+            maxResults: Math.max(1, Math.min(maxResults ?? 5, 15)),
+            linesInEachResult: 15
+          });
+          panorama.transaction("SearchWixSDKDocumentation").finish({ maxResults });
+          return {
+            content: [
+              {
+                type: "text",
+                text: result
+              },
+              {
+                type: "text",
+                text: "Next, you MUST use ReadFullDocsArticle tool if you want to read full documentation for a specific article or method."
+              }
+            ]
+          };
+        } catch (error) {
+          panorama.errorMonitor().reportError(error);
+          captureException(error, {
+            tags: {
+              componentId: "SearchWixSDKDocumentation",
+              toolName: "SearchWixSDKDocumentation"
+            }
+          });
+          logger.error(
+            `Error searching for ${searchTerm} in Wix SDK: ${error}`
+          );
+          return {
+            isError: true,
+            content: [{ type: "text", text: "Error: " + error.message }]
+          };
+        }
+      }
+    );
+  }
+  if (allowedTools.includes("BUILD_APPS")) {
+    server.tool(
+      "SearchBuildAppsDocumentation",
+      [
+        "Searches the official Build Apps documentation.",
+        "Use this tool when you need to understand or implement Wix CLI applications related code.",
+        "The search term should be a specific Wix CLI command or specific topic related to Wix CLI applications or its ecosystem (e.g. deployment, creating new extensions etc).",
+        "If you can't find what you need, try to rephrase your search term or use bigger maxResults value."
+      ].join("\n"),
+      {
+        searchTerm: z.string().describe(
+          "The search term to search for in the Build Apps Documentation"
+        ),
+        maxResults: z.number().describe(
+          "The maximum number of results to return, default is 5, max is 15"
+        ).min(1).max(15).optional().default(5)
+      },
+      async ({ searchTerm, maxResults }, { panorama }) => {
+        try {
+          logger.log(`Searching for ${searchTerm} in Build Apps`);
+          const result = await runSemanticSearchAndFormat({
+            toolName: "BUILD_APPS",
+            toolParams: {
+              searchTerm: `wix cli docs for ${searchTerm}`
+            },
+            maxResults: Math.max(1, Math.min(maxResults ?? 5, 15))
+          });
+          return {
+            content: [
+              {
+                type: "text",
+                text: result
+              }
+            ]
+          };
+        } catch (error) {
+          panorama.errorMonitor().reportError(error);
+          captureException(error, {
+            tags: {
+              componentId: "SearchBuildAppsDocumentation",
+              toolName: "SearchBuildAppsDocumentation"
+            }
+          });
+          logger.error(
+            `Error searching for ${searchTerm} in Build Apps: ${error}`
+          );
+          return {
+            content: [{ type: "text", text: "Error: " + error.message }]
+          };
+        }
+      }
+    );
+  }
+  if (allowedTools.includes("WIX_HEADLESS")) {
+    server.tool(
+      "SearchWixHeadlessDocumentation",
+      [
+        "Searches the official Wix Headless Documentation.",
+        "Use this tool when you need to understand or implement Headless related code.",
+        "The search term should be a specific Wix Headless topic or feature you need information about.",
+        "If you can't find what you need, try to rephrase your search term or use bigger maxResults value."
+      ].join("\n"),
+      {
+        searchTerm: z.string().describe(
+          "The search term to search for in the Headless Documentation"
+        ),
+        maxResults: z.number().describe(
+          "The maximum number of results to return, default is 5, max is 15"
+        ).min(1).max(15).optional().default(5)
+      },
+      async ({ searchTerm, maxResults }, { panorama }) => {
+        try {
+          logger.log(`Searching for ${searchTerm} in Headless`);
+          const result = await runSemanticSearchAndFormat({
+            toolName: "WIX_HEADLESS",
+            toolParams: {
+              searchTerm
+            },
+            maxResults: Math.max(1, Math.min(maxResults ?? 5, 15))
+          });
+          return {
+            content: [
+              {
+                type: "text",
+                text: result
+              }
+            ]
+          };
+        } catch (error) {
+          panorama.errorMonitor().reportError(error);
+          captureException(error, {
+            tags: {
+              componentId: "SearchWixHeadlessDocumentation",
+              toolName: "SearchWixHeadlessDocumentation"
+            }
+          });
+          logger.error(
+            `Error searching for ${searchTerm} in Wix Headless: ${error}`
+          );
+          return {
+            content: [{ type: "text", text: "Error: " + error.message }]
+          };
+        }
+      }
+    );
+  }
+  server.tool(
+    "ReadFullDocsArticle",
+    [
+      "Fetches the full Wix docs article or method article.",
+      "Use this tool when you read a summary of a docs article or method article, you have the docs url and want to read the full article."
+    ].join("\n"),
+    {
+      articleUrl: z.string().describe(
+        "The URL of the docs article or method article to fetch. Should be something like https://dev.wix.com/docs/.../.../..."
+      )
+    },
+    async ({ articleUrl }) => {
+      try {
+        const articleContent = await fetchArticleContent(articleUrl, "article");
+        if (!articleContent) {
+          throw new Error("Article content is empty");
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: articleContent
+            },
+            {
+              type: "text",
+              text: [
+                "---",
+                "Next, if you are dealing with a method - you MUST call ReadFullDocsMethodSchema tool - it will give you the full request schema for the method."
+              ].join("\n")
+            }
+          ]
+        };
+      } catch (error) {
+        logger.error(
+          `Error fetching article content or method schema for ${articleUrl}: ${error}`
+        );
+        return {
+          content: [
+            {
+              type: "text",
+              text: "Could not fetch article content, you should try completing the task without it."
+            }
+          ]
+        };
+      }
+    }
+  );
+  server.tool(
+    "ReadFullDocsMethodSchema",
+    [
+      "Fetches the full method schema for a given method. Always use it before calling the method.",
+      "This will give you the entire request/response schema with all the fields and their descriptions."
+    ].join("\n"),
+    {
+      articleUrl: z.string().describe(
+        "The URL of the documentation to fetch. Should be something like https://dev.wix.com/docs/.../.../..."
+      )
+    },
+    async ({ articleUrl }) => {
+      try {
+        const articleContent = await fetchArticleContent(
+          articleUrl,
+          "methodSchema"
+        );
+        if (!articleContent) {
+          throw new Error("Method schema is empty");
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: articleContent
+            }
+          ]
+        };
+      } catch (error) {
+        logger.error(
+          `Error fetching method schema for ${articleUrl}: ${error}`
+        );
+        return {
+          content: [
+            {
+              type: "text",
+              text: "Could not fetch method schema, you should try completing the task without it."
+            }
+          ]
+        };
+      }
+    }
+  );
+};
+async function fetchArticleContent(articleUrl, mode) {
+  const url = new URL(`https://dev.wix.com/digor/api/get-article-content`);
+  url.searchParams.set("articleUrl", articleUrl);
+  const schema = mode === "methodSchema" ? "true" : "false";
+  url.searchParams.set("schema", schema);
+  logger.log(`Fetching resource from docs ${url.toString()}`);
+  const response = await fetch(url.toString());
+  const data = await response.json();
+  logger.log(`Fetched resource from docs: ${data.articleContent}`);
+  return data.articleContent;
+}
+
+// src/tool-utils.ts
+var safeParseJSON = (text) => {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+};
+var handleWixAPIResponse = async (response) => {
+  const responseText = await response.text();
+  const responseData = safeParseJSON(responseText);
+  if (!response.ok) {
+    const requestId = response.headers.get("x-wix-request-id");
+    const errorDetails = typeof responseData === "object" ? JSON.stringify(responseData) : responseData;
+    throw new Error(
+      [
+        `Failed to call Wix API: ${response.status} ${response.statusText}.`,
+        requestId ? `request id: ${requestId}` : "",
+        // Wix 404 for API does not exist is huge (generic 404 page) and loaded to the context
+        response.status === 404 && errorDetails.includes("<html") ? "Not found" : errorDetails
+      ].filter((str) => !!str).join("\n")
+    );
+  }
+  return responseData;
+};
+
+// src/wix-mcp-server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+// ../../node_modules/@wix/panorama-common-shared/dist/esm/types/enum-types.js
+var AlertType;
+(function(AlertType2) {
+  AlertType2["SuccessRate"] = "SuccessRate";
+  AlertType2["SuccessRateQuality"] = "SuccessRateQuality";
+  AlertType2["Duration"] = "Duration";
+  AlertType2["ErrorRate"] = "ErrorRate";
+})(AlertType || (AlertType = {}));
+var AlertStatus;
+(function(AlertStatus2) {
+  AlertStatus2["Alerting"] = "alerting";
+  AlertStatus2["Ok"] = "ok";
+})(AlertStatus || (AlertStatus = {}));
+var LogLevel;
+(function(LogLevel2) {
+  LogLevel2["Info"] = "INFO";
+  LogLevel2["Warn"] = "WARN";
+  LogLevel2["Error"] = "ERROR";
+  LogLevel2["Debug"] = "DEBUG";
+})(LogLevel || (LogLevel = {}));
+var TransactionAction;
+(function(TransactionAction2) {
+  TransactionAction2["Start"] = "START";
+  TransactionAction2["Finish"] = "FINISH";
+})(TransactionAction || (TransactionAction = {}));
+var InternalTransactions = {
+  ComponentLoad: "PANORAMA_COMPONENT_LOAD",
+  ComponentPhase: "PANORAMA_COMPONENT_PHASE"
+};
+var Platform;
+(function(Platform2) {
+  Platform2["Standalone"] = "standalone";
+  Platform2["BusinessManager"] = "business-manager";
+  Platform2["Viewer"] = "viewer";
+  Platform2["Editor"] = "editor";
+  Platform2["EditorSettings"] = "editor:settings";
+  Platform2["Mobile"] = "mobile";
+  Platform2["Standards"] = "standards";
+})(Platform || (Platform = {}));
+var ErrorSeverity;
+(function(ErrorSeverity2) {
+  ErrorSeverity2["Fatal"] = "fatal";
+  ErrorSeverity2["Error"] = "error";
+  ErrorSeverity2["Warning"] = "warning";
+  ErrorSeverity2["Log"] = "log";
+  ErrorSeverity2["Info"] = "info";
+  ErrorSeverity2["Debug"] = "debug";
+  ErrorSeverity2["Critical"] = "critical";
+})(ErrorSeverity || (ErrorSeverity = {}));
+
+// ../../node_modules/@wix/panorama-common/dist/esm/global-config/global-config.js
+import { v4 } from "uuid";
+
+// ../../node_modules/@wix/panorama-common/dist/esm/duration-tracker/duration-tracker.js
+var DELIMITER = " | ";
+var DurationTrackerImpl = class {
+  constructor() {
+    this.transactionStartTimes = {};
+    this.phaseStartTimes = {};
+  }
+  createKey(...args) {
+    return args.filter((x) => !!x).join(DELIMITER);
+  }
+  markTransactionStart(fullArtifactId, componentId, transactionName, transactionId) {
+    const key = this.createKey(fullArtifactId, componentId, transactionName, transactionId);
+    this.transactionStartTimes[key] = Date.now();
+  }
+  markTransactionFinish(fullArtifactId, componentId, transactionName, transactionId) {
+    const key = this.createKey(fullArtifactId, componentId, transactionName, transactionId);
+    const finishTime = Date.now();
+    const startTime = this.transactionStartTimes[key] || finishTime;
+    const duration = Math.round(finishTime - startTime);
+    this.transactionStartTimes[key] = 0;
+    return duration;
+  }
+  markPhaseStart(fullArtifactId, componentId, phaseName) {
+    const key = this.createKey(fullArtifactId, componentId, phaseName);
+    this.phaseStartTimes[key] = Date.now();
+  }
+  markPhaseFinish(fullArtifactId, componentId, phaseName) {
+    const key = this.createKey(fullArtifactId, componentId, phaseName);
+    const finishTime = Date.now();
+    const startTime = this.phaseStartTimes[key] || finishTime;
+    const duration = Math.round(finishTime - startTime);
+    this.phaseStartTimes[key] = 0;
+    return duration;
+  }
+};
+var createDurationTracker = () => new DurationTrackerImpl();
+
+// ../../node_modules/@wix/panorama-common/dist/esm/global-config/global-config.js
+var GlobalConfigImpl = class {
+  constructor() {
+    this.sessionId = "";
+    this.reporter = null;
+    this.batchQueue = null;
+    this.durationTracker = createDurationTracker();
+    this.state = /* @__PURE__ */ new Map();
+    this.sessionStart = Date.now();
+  }
+  getSessionId() {
+    this.sessionId = this.sessionId || v4();
+    return this.sessionId;
+  }
+  setSessionId(sessionId) {
+    this.sessionId = sessionId;
+  }
+  getSessionTime() {
+    return Date.now() - this.sessionStart;
+  }
+  getReporter() {
+    return this.reporter;
+  }
+  setReporter(reporter) {
+    this.reporter = reporter;
+  }
+  initBatchQueue(batchQueue) {
+    this.batchQueue = this.batchQueue ?? batchQueue;
+  }
+  getBatchQueue() {
+    return this.batchQueue;
+  }
+  getDurationTracker() {
+    return this.durationTracker;
+  }
+  getStateValue(key) {
+    return this.state.get(key);
+  }
+  setStateValue(key, value) {
+    this.state.set(key, value);
+  }
+  clearState() {
+    this.state.clear();
+    this.durationTracker = createDurationTracker();
+  }
+};
+var createGlobalConfig = () => new GlobalConfigImpl();
+
+// ../../node_modules/@wix/panorama-client/dist/esm/panorama-client-factory.js
+import _defineProperty6 from "@babel/runtime/helpers/defineProperty";
+
+// ../../node_modules/@wix/panorama-common/dist/esm/utils/class-utils.js
+var bindPrototypeMethodsToSelf = (instance, classFn) => {
+  const prototype = classFn ? classFn.prototype : Object.getPrototypeOf(instance);
+  const props = Object.getOwnPropertyNames(prototype);
+  for (const prop of props) {
+    if (prop === "constructor" || typeof prototype[prop] !== "function") {
+      continue;
+    }
+    instance[prop] = prototype[prop].bind(instance);
+  }
+};
+
+// ../../node_modules/@wix/panorama-client/dist/esm/utils/general-utils.js
+var last = (arr) => Array.isArray(arr) ? arr[arr.length - 1] : void 0;
+var union = function() {
+  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+    args[_key] = arguments[_key];
+  }
+  return [...new Set(args.flat()).values()];
+};
+var defaults = function() {
+  for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+    args[_key2] = arguments[_key2];
+  }
+  return args.reduce((res, obj) => Object.entries(obj ?? {}).reduce((_res, _ref) => {
+    let [key, value] = _ref;
+    if (typeof _res[key] === "undefined" && typeof value !== "undefined") {
+      _res[key] = value;
+    }
+    return _res;
+  }, res), {});
+};
+var deepDefaults = function(dest) {
+  for (var _len3 = arguments.length, rest = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
+    rest[_key3 - 1] = arguments[_key3];
+  }
+  const keys = union(...rest.map((value) => Object.keys(value ?? {})));
+  const all = [dest, ...rest];
+  return keys.reduce((res, key) => {
+    const values = all.map((value) => value == null ? void 0 : value[key]);
+    const merged = defaults(...values);
+    const hasValues = Object.values(merged).filter((value) => typeof value !== "undefined").length > 0;
+    if (hasValues) {
+      res = res ?? {};
+      res[key] = merged;
+    } else {
+      var _res2;
+      (_res2 = res) == null || delete _res2[key];
+    }
+    return res;
+  }, dest ? {
+    ...dest
+  } : dest);
+};
+
+// ../../node_modules/@wix/panorama-client/dist/esm/panorama-client.js
+import _defineProperty3 from "@babel/runtime/helpers/defineProperty";
+
+// ../../node_modules/@wix/panorama-client/dist/esm/panorama-client-component.js
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+
+// ../../node_modules/@wix/panorama-client/dist/esm/panorama-error-monitor.js
+var PanoramaErrorMonitorImpl = class {
+  constructor(baseClient, options) {
+    this.baseClient = baseClient;
+    this.options = options;
+    bindPrototypeMethodsToSelf(this);
+  }
+  reportError(error, data) {
+    this.baseClient.reportError(error, data, this.options);
+  }
+  addBreadcrumb(breadcrumb) {
+    this.baseClient.addBreadcrumb(breadcrumb);
+  }
+};
+
+// ../../node_modules/@wix/panorama-client/dist/esm/panorama-logger.js
+var PanoramaLoggerImpl = class {
+  constructor(baseClient) {
+    this.baseClient = baseClient;
+    bindPrototypeMethodsToSelf(this);
+  }
+  info(message, data) {
+    this.baseClient.log(LogLevel.Info, message, data);
+  }
+  warn(message, data) {
+    this.baseClient.log(LogLevel.Warn, message, data);
+  }
+  error(message, data) {
+    this.baseClient.log(LogLevel.Error, message, data);
+  }
+  debug(message, data) {
+    this.baseClient.log(LogLevel.Debug, message, data);
+  }
+};
+
+// ../../node_modules/@wix/panorama-common-shared/dist/esm/utils/transaction-utils.js
+var isCustomTransactionName = (name) => !Object.values(InternalTransactions).includes(name);
+
+// ../../node_modules/@wix/panorama-client/dist/esm/panorama-transaction.js
+var PanoramaTransactionImpl = class {
+  constructor(baseClient, name, options) {
+    this.baseClient = baseClient;
+    this.name = name;
+    this.options = options;
+    if (!isCustomTransactionName(name)) {
+      throw new Error(`"${name}" is an internal transaction and can't be used`);
+    }
+    this.baseClient = baseClient;
+    bindPrototypeMethodsToSelf(this);
+  }
+  start(data, options) {
+    return this.baseClient.reportTransactionStart(this.name, defaults(options, this.options), data);
+  }
+  finish(data, options) {
+    return this.baseClient.reportTransactionFinish(this.name, defaults(options, this.options), data);
+  }
+};
+
+// ../../node_modules/@wix/panorama-client/dist/esm/panorama-client-component.js
+var PanoramaClientForComponentImpl = class {
+  constructor(_ref) {
+    let {
+      baseClient
+    } = _ref;
+    _defineProperty(this, "baseClient", void 0);
+    this.baseClient = baseClient;
+    bindPrototypeMethodsToSelf(this);
+  }
+  transaction(name, options) {
+    return new PanoramaTransactionImpl(this.baseClient, name, options);
+  }
+  errorMonitor(options) {
+    return new PanoramaErrorMonitorImpl(this.baseClient, options);
+  }
+  logger() {
+    return new PanoramaLoggerImpl(this.baseClient);
+  }
+};
+
+// ../../node_modules/@wix/panorama-client/dist/esm/plugins/hooks-manager.js
+import _defineProperty2 from "@babel/runtime/helpers/defineProperty";
+var Hook = /* @__PURE__ */ function(Hook2) {
+  Hook2[Hook2["afterCreateClientForComponent"] = 0] = "afterCreateClientForComponent";
+  Hook2[Hook2["beforeReport"] = 1] = "beforeReport";
+  Hook2[Hook2["beforeReportTransactionStart"] = 2] = "beforeReportTransactionStart";
+  Hook2[Hook2["afterReportTransactionStart"] = 3] = "afterReportTransactionStart";
+  Hook2[Hook2["beforeReportTransactionFinish"] = 4] = "beforeReportTransactionFinish";
+  Hook2[Hook2["afterReportTransactionFinish"] = 5] = "afterReportTransactionFinish";
+  Hook2[Hook2["beforeReportPhaseStart"] = 6] = "beforeReportPhaseStart";
+  Hook2[Hook2["afterReportPhaseStart"] = 7] = "afterReportPhaseStart";
+  Hook2[Hook2["beforeReportPhaseFinish"] = 8] = "beforeReportPhaseFinish";
+  Hook2[Hook2["afterReportPhaseFinish"] = 9] = "afterReportPhaseFinish";
+  Hook2[Hook2["beforeReportError"] = 10] = "beforeReportError";
+  Hook2[Hook2["afterReportError"] = 11] = "afterReportError";
+  Hook2[Hook2["beforeAddBreadcrumb"] = 12] = "beforeAddBreadcrumb";
+  Hook2[Hook2["afterAddBreadcrumb"] = 13] = "afterAddBreadcrumb";
+  Hook2[Hook2["beforeReportLog"] = 14] = "beforeReportLog";
+  Hook2[Hook2["afterReportLog"] = 15] = "afterReportLog";
+  Hook2[Hook2["beforeUnhandledError"] = 16] = "beforeUnhandledError";
+  return Hook2;
+}({});
+var HooksManager = class {
+  constructor() {
+    _defineProperty2(this, "subscribers", {});
+  }
+  tap(hook, subscriber) {
+    this.subscribers[hook] = this.subscribers[hook] || [];
+    this.subscribers[hook].push(subscriber);
+  }
+  invoke(hook) {
+    const subscribers = this.subscribers[hook];
+    if (!subscribers) {
+      return true;
+    }
+    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+      args[_key - 1] = arguments[_key];
+    }
+    for (const subscriber of subscribers) {
+      if (subscriber(...args) === false) {
+        return false;
+      }
+    }
+    return true;
+  }
+};
+
+// ../../node_modules/@wix/panorama-client/dist/esm/panorama-phase.js
+var PanoramaPhaseImpl = class {
+  constructor(name, baseClient) {
+    this.name = name;
+    this.baseClient = baseClient;
+    this.baseClient = baseClient;
+    bindPrototypeMethodsToSelf(this);
+  }
+  start(data) {
+    return this.baseClient.reportPhaseStart(this.name, data);
+  }
+  finish(data) {
+    return this.baseClient.reportPhaseFinish(this.name, data);
+  }
+};
+
+// ../../node_modules/@wix/panorama-client/dist/esm/panorama-client.js
+var PanoramaClientImpl = class {
+  constructor(_ref) {
+    let {
+      hooksManager,
+      baseClient
+    } = _ref;
+    _defineProperty3(this, "baseClient", void 0);
+    _defineProperty3(this, "hooksManager", void 0);
+    this.baseClient = baseClient;
+    this.hooksManager = hooksManager;
+    bindPrototypeMethodsToSelf(this);
+  }
+  onUnhandledError(subscriber) {
+    this.hooksManager.tap(Hook.beforeUnhandledError, subscriber);
+  }
+  reportLoadStart(data, options) {
+    const {
+      ComponentLoad
+    } = InternalTransactions;
+    return this.baseClient.reportTransactionStart(ComponentLoad, options, data);
+  }
+  reportLoadFinish(data, options) {
+    const {
+      ComponentLoad
+    } = InternalTransactions;
+    return this.baseClient.reportTransactionFinish(ComponentLoad, options, data);
+  }
+  phase(name) {
+    return new PanoramaPhaseImpl(name, this.baseClient);
+  }
+  transaction(name, options) {
+    return new PanoramaTransactionImpl(this.baseClient, name, options);
+  }
+  errorMonitor(options) {
+    return new PanoramaErrorMonitorImpl(this.baseClient, options);
+  }
+  logger() {
+    return new PanoramaLoggerImpl(this.baseClient);
+  }
+  createClientForComponent() {
+    const client = new PanoramaClientForComponentImpl({
+      baseClient: this.baseClient
+    });
+    this.hooksManager.invoke(Hook.afterCreateClientForComponent, client);
+    return client;
+  }
+};
+
+// ../../node_modules/@wix/panorama-client/dist/esm/panorama-client-base.js
+import _defineProperty4 from "@babel/runtime/helpers/defineProperty";
+
+// ../../node_modules/@wix/panorama-client/dist/esm/utils/error-utils.js
+var extractWixHttpErrorDetailsRec = (error) => {
+  var _httpClientError$resp;
+  if (!(error instanceof Error)) {
+    return {};
+  }
+  const res = extractWixHttpErrorDetailsRec(error.cause);
+  const httpClientError = error;
+  return defaults(res, {
+    isWixHttpError: httpClientError.isWixHttpError,
+    requestId: ((_httpClientError$resp = httpClientError.response) == null || (_httpClientError$resp = _httpClientError$resp.headers) == null ? void 0 : _httpClientError$resp["x-wix-request-id"]) ?? httpClientError.requestId
+  });
+};
+var extractWixHttpErrorDetails = (error) => defaults(extractWixHttpErrorDetailsRec(error), {
+  isWixHttpError: false,
+  requestId: ""
+});
+
+// ../../node_modules/@wix/panorama-client/dist/esm/constants.js
+var MAX_STACK_TRACE_SIZE_BYTES = 32 * 1024;
+
+// ../../node_modules/@wix/panorama-client/dist/esm/lib/payload-sanitizer.js
+var sanitizePayload = (payload) => {
+  const {
+    errorStack
+  } = payload;
+  if (errorStack && errorStack.length > MAX_STACK_TRACE_SIZE_BYTES) {
+    const truncationMessage = `...[truncated by Panorama client to ${MAX_STACK_TRACE_SIZE_BYTES / 1024}kb]`;
+    const truncatedErrorStack = errorStack.substring(0, MAX_STACK_TRACE_SIZE_BYTES - truncationMessage.length);
+    payload = {
+      ...payload,
+      errorStack: `${truncatedErrorStack}${truncationMessage}`
+    };
+  }
+  return payload;
+};
+
+// ../../node_modules/@wix/panorama-client/dist/esm/lib/payload-builder.js
+var getSessionParams = (globalConfig2) => {
+  const sessionId = globalConfig2.getSessionId();
+  const sessionTime = Math.round(globalConfig2.getSessionTime());
+  return {
+    sessionId,
+    sessionTime
+  };
+};
+var buildTransactionPayload = (globalConfig2, baseParams, transactionParams, data) => {
+  const {
+    transactionName,
+    transactionAction
+  } = transactionParams;
+  const {
+    sessionId,
+    sessionTime
+  } = getSessionParams(globalConfig2);
+  const logLevel = LogLevel.Info;
+  const message = `Panorama ${transactionName} ${transactionAction}`;
+  const requestId = "";
+  return sanitizePayload({
+    ...baseParams,
+    ...transactionParams,
+    sessionId,
+    sessionTime,
+    logLevel,
+    requestId,
+    message,
+    data
+  });
+};
+var buildPhasePayload = (globalConfig2, baseParams, phaseParams, data) => {
+  const transactionName = InternalTransactions.ComponentPhase;
+  const {
+    phaseName,
+    transactionAction
+  } = phaseParams;
+  const {
+    sessionId,
+    sessionTime
+  } = getSessionParams(globalConfig2);
+  const logLevel = LogLevel.Info;
+  const message = `Panorama ${phaseName} phase ${transactionAction}`;
+  const requestId = "";
+  return sanitizePayload({
+    ...baseParams,
+    ...phaseParams,
+    transactionName,
+    sessionId,
+    sessionTime,
+    logLevel,
+    requestId,
+    message,
+    data
+  });
+};
+var buildErrorPayload = (globalConfig2, baseParams, error, data) => {
+  const {
+    sessionId,
+    sessionTime
+  } = getSessionParams(globalConfig2);
+  const {
+    constructor,
+    message,
+    stack = ""
+  } = error;
+  const logLevel = LogLevel.Error;
+  const {
+    requestId
+  } = extractWixHttpErrorDetails(error);
+  return sanitizePayload({
+    ...baseParams,
+    sessionId,
+    sessionTime,
+    logLevel,
+    requestId,
+    data,
+    errorName: (data == null ? void 0 : data.errorName) ?? constructor.name,
+    errorStack: stack,
+    message
+  });
+};
+var buildLoggerPayload = (globalConfig2, baseParams, loggerParams) => {
+  const {
+    sessionId,
+    sessionTime
+  } = getSessionParams(globalConfig2);
+  const requestId = "";
+  return sanitizePayload({
+    ...baseParams,
+    ...loggerParams,
+    sessionId,
+    sessionTime,
+    requestId
+  });
+};
+
+// ../../node_modules/@wix/panorama-client/dist/esm/panorama-client-base.js
+var BasePanoramaClient = class {
+  constructor(_ref) {
+    var _this = this;
+    let {
+      baseParams,
+      globalConfig: globalConfig2,
+      reporter,
+      hooksManager,
+      data,
+      isMuted
+    } = _ref;
+    _defineProperty4(this, "durationTracker", void 0);
+    _defineProperty4(this, "baseParams", void 0);
+    _defineProperty4(this, "globalConfig", void 0);
+    _defineProperty4(this, "reporter", void 0);
+    _defineProperty4(this, "hooksManager", void 0);
+    _defineProperty4(this, "data", void 0);
+    _defineProperty4(this, "isMuted", void 0);
+    _defineProperty4(this, "getErrorMonitorDataWithDefaults", function() {
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      return _this.data.addDataScope(args).getData();
+    });
+    this.baseParams = baseParams;
+    this.globalConfig = globalConfig2;
+    this.reporter = reporter;
+    this.hooksManager = hooksManager;
+    this.data = data;
+    this.isMuted = isMuted;
+    this.durationTracker = typeof globalConfig2.getDurationTracker === "function" ? globalConfig2.getDurationTracker() : createDurationTracker();
+  }
+  report(eventPayload) {
+    if (this.isMuted()) {
+      return;
+    }
+    const reporterOverride = this.globalConfig.getReporter();
+    const beforeReportHookResult = this.hooksManager.invoke(Hook.beforeReport, eventPayload);
+    if (typeof reporterOverride === "function") {
+      reporterOverride(eventPayload);
+      return;
+    }
+    if (!beforeReportHookResult) {
+      return;
+    }
+    this.reporter(eventPayload);
+  }
+  reportTransactionStart(name, options, data) {
+    if (options === void 0) {
+      options = {};
+    }
+    const {
+      id
+    } = options;
+    const dataWithDefault = this.data.addDataScope(data).getData();
+    if (!this.hooksManager.invoke(Hook.beforeReportTransactionStart, name, dataWithDefault)) {
+      return;
+    }
+    const {
+      fullArtifactId,
+      componentId
+    } = this.baseParams;
+    this.durationTracker.markTransactionStart(fullArtifactId, componentId, name, id);
+    const payload = buildTransactionPayload(this.globalConfig, this.baseParams, {
+      transactionName: name,
+      transactionAction: TransactionAction.Start
+    }, dataWithDefault);
+    this.report(payload);
+    this.hooksManager.invoke(Hook.afterReportTransactionStart, name, payload);
+  }
+  reportTransactionFinish(name, options, data) {
+    if (options === void 0) {
+      options = {};
+    }
+    const {
+      id
+    } = options;
+    const dataWithDefault = this.data.addDataScope(data).getData();
+    if (!this.hooksManager.invoke(Hook.beforeReportTransactionFinish, name, dataWithDefault)) {
+      return;
+    }
+    const {
+      fullArtifactId,
+      componentId
+    } = this.baseParams;
+    const duration = this.durationTracker.markTransactionFinish(fullArtifactId, componentId, name, id);
+    const payload = buildTransactionPayload(this.globalConfig, this.baseParams, {
+      transactionName: name,
+      transactionAction: TransactionAction.Finish,
+      transactionDuration: duration
+    }, dataWithDefault);
+    this.report(payload);
+    this.hooksManager.invoke(Hook.afterReportTransactionFinish, name, payload);
+  }
+  reportPhaseStart(name, data) {
+    const dataWithDefault = this.data.addDataScope(data).getData();
+    if (!this.hooksManager.invoke(Hook.beforeReportPhaseStart, name, dataWithDefault)) {
+      return;
+    }
+    const {
+      fullArtifactId,
+      componentId
+    } = this.baseParams;
+    this.durationTracker.markPhaseStart(fullArtifactId, componentId, name);
+    const payload = buildPhasePayload(this.globalConfig, this.baseParams, {
+      phaseName: name,
+      transactionAction: TransactionAction.Start
+    }, dataWithDefault);
+    this.report(payload);
+    this.hooksManager.invoke(Hook.afterReportPhaseStart, name, payload);
+  }
+  reportPhaseFinish(name, data) {
+    const dataWithDefault = this.data.addDataScope(data).getData();
+    if (!this.hooksManager.invoke(Hook.beforeReportPhaseFinish, name, dataWithDefault)) {
+      return;
+    }
+    const {
+      fullArtifactId,
+      componentId
+    } = this.baseParams;
+    const duration = this.durationTracker.markPhaseFinish(fullArtifactId, componentId, name);
+    const payload = buildPhasePayload(this.globalConfig, this.baseParams, {
+      phaseName: name,
+      transactionAction: TransactionAction.Finish,
+      transactionDuration: duration
+    }, dataWithDefault);
+    this.report(payload);
+    this.hooksManager.invoke(Hook.afterReportPhaseFinish, name, payload);
+  }
+  reportError(error, data, options) {
+    if (!(error instanceof Error)) {
+      return;
+    }
+    data = this.data.addDataScope([data, options == null ? void 0 : options.data]).getData();
+    if (!this.hooksManager.invoke(Hook.beforeReportError, error, data, options)) {
+      return;
+    }
+    const payload = buildErrorPayload(this.globalConfig, this.baseParams, error, data);
+    this.report(payload);
+    this.hooksManager.invoke(Hook.afterReportError, error, data, options);
+  }
+  addBreadcrumb(breadcrumb) {
+    if (!this.hooksManager.invoke(Hook.beforeAddBreadcrumb, breadcrumb)) {
+      return;
+    }
+    this.hooksManager.invoke(Hook.afterAddBreadcrumb, breadcrumb);
+  }
+  log(logLevel, message, data) {
+    if (!message) {
+      return;
+    }
+    const dataWithDefault = this.data.addDataScope(data).getData();
+    const loggerParams = {
+      message,
+      data: dataWithDefault,
+      logLevel
+    };
+    if (!this.hooksManager.invoke(Hook.beforeReportLog, logLevel, message, dataWithDefault)) {
+      return;
+    }
+    const payload = buildLoggerPayload(this.globalConfig, this.baseParams, loggerParams);
+    this.report(payload);
+    this.hooksManager.invoke(Hook.afterReportLog, logLevel, message, dataWithDefault);
+  }
+};
+
+// ../../node_modules/@wix/panorama-client/dist/esm/lib/scope.js
+import _defineProperty5 from "@babel/runtime/helpers/defineProperty";
+var Scope = class _Scope {
+  constructor(data) {
+    _defineProperty5(this, "data", void 0);
+    this.data = data;
+  }
+  getEntriesToDeepDefaults(data) {
+    if (!data) {
+      return void 0;
+    }
+    return Object.fromEntries(Object.entries(data).filter((_ref) => {
+      let [key] = _ref;
+      return _Scope.KEYS_TO_DEEP_DEFAULTS.includes(key);
+    }));
+  }
+  addDataScope(data) {
+    const outerDataArray = Array.isArray(data) ? data : [data];
+    const deepDefaultData = deepDefaults(...outerDataArray.map((_data) => this.getEntriesToDeepDefaults(_data)), this.getEntriesToDeepDefaults(this.data));
+    return new _Scope(defaults(deepDefaultData, ...outerDataArray, this.data));
+  }
+  getData() {
+    return this.data;
+  }
+};
+_defineProperty5(Scope, "KEYS_TO_DEEP_DEFAULTS", ["tags", "context"]);
+
+// ../../node_modules/@wix/panorama-client/dist/esm/panorama-client-factory.js
+var PanoramaClientFactoryImpl = class {
+  constructor(options) {
+    this.options = options;
+    _defineProperty6(this, "globalConfig", void 0);
+    _defineProperty6(this, "reporter", () => true);
+    _defineProperty6(this, "plugins", []);
+    _defineProperty6(this, "isMuted", false);
+    bindPrototypeMethodsToSelf(this);
+  }
+  withGlobalConfig(globalConfig2) {
+    this.globalConfig = globalConfig2;
+    return this;
+  }
+  withReporter(reporter) {
+    this.reporter = reporter;
+    return this;
+  }
+  setMuted(isMuted) {
+    this.isMuted = isMuted;
+    return this;
+  }
+  use(plugin) {
+    this.plugins.push(plugin);
+    return this;
+  }
+  client(options) {
+    if (options === void 0) {
+      options = {};
+    }
+    const {
+      pluginParams
+    } = options;
+    const globalConfig2 = this.globalConfig ?? createGlobalConfig();
+    const reporter = this.reporter;
+    const hooksManager = new HooksManager();
+    const baseParams = defaults(options.baseParams, this.options.baseParams);
+    const data = new Scope(this.options.data).addDataScope(options.data);
+    const pluginClientParams = pluginParams ?? {};
+    const baseClient = new BasePanoramaClient({
+      baseParams,
+      globalConfig: globalConfig2,
+      isMuted: () => this.isMuted,
+      reporter,
+      hooksManager,
+      data
+    });
+    const client = new PanoramaClientImpl({
+      baseClient,
+      hooksManager
+    });
+    this.plugins.forEach((plugin) => plugin({
+      hooksManager,
+      globalConfig: globalConfig2,
+      reporter,
+      baseClient,
+      baseParams,
+      pluginParams: pluginClientParams
+    }));
+    return client;
+  }
+};
+var panoramaClient = function(options) {
+  if (options === void 0) {
+    options = {};
+  }
+  return new PanoramaClientFactoryImpl(options);
+};
+
+// ../../node_modules/@wix/panorama-client/dist/esm/types.js
+var StacktraceScriptType = /* @__PURE__ */ function(StacktraceScriptType2) {
+  StacktraceScriptType2["WIX_SERVICE"] = "WIX_SERVICE";
+  StacktraceScriptType2["WIX_APP"] = "WIX_APP";
+  StacktraceScriptType2["WIX_CHAT"] = "WIX_CHAT_WIDGET";
+  StacktraceScriptType2["BROWSER_EXTENSION"] = "BROWSER_EXTENSION";
+  return StacktraceScriptType2;
+}({});
+
+// ../../node_modules/@wix/panorama-client/dist/esm/utils/artifact-utils.js
+var scriptRegexs = [{
+  scriptType: StacktraceScriptType.WIX_SERVICE,
+  regex: () => /\/services\/([^/]+)\/([^/]+)\//
+}, {
+  scriptType: StacktraceScriptType.WIX_APP,
+  regex: () => /apps\.wix\.com\/([^/]+)\//
+}, {
+  scriptType: StacktraceScriptType.WIX_CHAT,
+  regex: () => /unpkg-semver\/(wix-chatbot-widget)\//
+}, {
+  scriptType: StacktraceScriptType.BROWSER_EXTENSION,
+  regex: () => /^chrome-extension:/
+}];
+var fullArtifactIdToArtifactId = (fullArtifactId) => {
+  if (typeof fullArtifactId !== "string") {
+    return "";
+  }
+  return last(fullArtifactId.split(".")) || "";
+};
+
+// ../../node_modules/@wix/panorama-client/dist/esm/utils/url-utils.js
+var getQueryParamValue = (key) => {
+  if (typeof window === "undefined") {
+    return null;
+  }
+  const queryParams = new URLSearchParams(window.location.search);
+  return queryParams.get(key);
+};
+var hasQueryParam = (key) => {
+  const queryParamValue = getQueryParamValue(key);
+  return queryParamValue === "true";
+};
+
+// ../../node_modules/@wix/panorama-client/dist/esm/utils/cookie-utils.js
+var getCookieOverrideValue = (artifactId) => {
+  if (typeof document === "undefined") {
+    return null;
+  }
+  const wixStaticsVersionsCookie = document.cookie.split(";").map((c) => c.trim()).find((c) => c.startsWith("wixStaticsVersions="));
+  if (!wixStaticsVersionsCookie) {
+    return null;
+  }
+  const cookieValue = wixStaticsVersionsCookie.split("=")[1].trim();
+  const overrideArtifactEntry = cookieValue.split("|").find((overrideEntry) => overrideEntry.startsWith(`${artifactId}#`));
+  if (!overrideArtifactEntry) {
+    return null;
+  }
+  return overrideArtifactEntry.split("#")[1];
+};
+
+// ../../node_modules/@wix/panorama-client/dist/esm/utils/environment-utils.js
+var RuntimeEnvironment = /* @__PURE__ */ function(RuntimeEnvironment2) {
+  RuntimeEnvironment2["PRODUCTION"] = "production";
+  RuntimeEnvironment2["DEVELOPMENT"] = "development";
+  RuntimeEnvironment2["BOT"] = "bot";
+  RuntimeEnvironment2["INVALID_USER_AGENT"] = "invalid_useragent";
+  RuntimeEnvironment2["SLED"] = "sled";
+  RuntimeEnvironment2["SERVER"] = "server";
+  RuntimeEnvironment2["TEST"] = "test";
+  return RuntimeEnvironment2;
+}({});
+var FORCE_PANORAMA_REPORT_QUERY_PARAM = "forcePanoramaReport";
+var ENABLE_PANORAMA_LOGS_QUERY_PARAM = "enablePanoramaLogs";
+var hasForcePanoramaReportQueryParam = () => {
+  return hasQueryParam(FORCE_PANORAMA_REPORT_QUERY_PARAM);
+};
+var hasEnablePanoramaLogsQueryParam = () => {
+  return hasQueryParam(ENABLE_PANORAMA_LOGS_QUERY_PARAM);
+};
+var checkIsLocalMode = (fullArtifactId) => {
+  const artifactId = fullArtifactIdToArtifactId(fullArtifactId);
+  if (!artifactId) {
+    return false;
+  }
+  const queryParamOverrideValue = getQueryParamValue(`${artifactId}-override`);
+  const isLocalQueryParamOverride = queryParamOverrideValue && queryParamOverrideValue.includes("localhost");
+  if (isLocalQueryParamOverride) {
+    return true;
+  }
+  const wixStaticCookieValue = getCookieOverrideValue(artifactId);
+  return !!wixStaticCookieValue && wixStaticCookieValue.includes("localhost");
+};
+function calculateEnvironment() {
+  if (typeof WorkerGlobalScope !== "undefined" && self instanceof WorkerGlobalScope) {
+    return RuntimeEnvironment.PRODUCTION;
+  }
+  if (typeof window === "undefined") {
+    try {
+      return process.env.NODE_ENV || RuntimeEnvironment.SERVER;
+    } catch {
+      return RuntimeEnvironment.SERVER;
+    }
+  }
+  const {
+    hostname
+  } = window.location;
+  const {
+    userAgent
+  } = window.navigator;
+  const {
+    cookie
+  } = window.document;
+  const isSled = /(^|;)\s*automation\s*=\s*sled:/.test(cookie);
+  const isLocalhost = /localhost|127\.0\.0\.1|::1|\.local|local\.wix\.com|^$/i.test(hostname);
+  const isBot = /Googlebot|AdsBot-Google-Mobile|bingbot|BingPreview|facebookexternalhit|Baiduspider|YandexBot/i.test(userAgent);
+  const isNotValidUserAgent = /BonEcho|NewsGator|SeaMonkey|iTunes|Epiphany|Konqueror|Sleipnir|IceWeasel/i.test(userAgent);
+  switch (true) {
+    case isSled:
+      return RuntimeEnvironment.SLED;
+    case process.env.NODE_ENV === "test":
+      return RuntimeEnvironment.TEST;
+    case (process.env.NODE_ENV === "development" || isLocalhost):
+      return RuntimeEnvironment.DEVELOPMENT;
+    case isBot:
+      return RuntimeEnvironment.BOT;
+    case isNotValidUserAgent:
+      return RuntimeEnvironment.INVALID_USER_AGENT;
+    default:
+      return RuntimeEnvironment.PRODUCTION;
+  }
+}
+
+// ../../node_modules/@wix/panorama-client/dist/esm/utils/console-utils.js
+var messageFormatter = (artifactId, componentId, message) => {
+  return ["%c%s %c%s %c%s %c%s", "color: #D39874", "Panorama logger:", "color: #CAB6D3", `${artifactId}`, "color: #B3CAD8", `${componentId}`, "color: #A6C6DB", `${message}`];
+};
+var logToConsole = (logLevel, artifactId, componentId, message, data) => {
+  const formattedMessage = messageFormatter(artifactId, componentId, message);
+  if (logLevel === LogLevel.Info) {
+    console.info(...formattedMessage);
+  } else if (logLevel === LogLevel.Warn) {
+    console.warn(...formattedMessage);
+  } else if (logLevel === LogLevel.Error) {
+    console.error(...formattedMessage);
+  } else if (logLevel === LogLevel.Debug) {
+    console.debug(...formattedMessage);
+  } else {
+    console.log(...formattedMessage);
+  }
+  if (data && Object.keys(data).length) {
+    console.table(data);
+  }
+};
+
+// ../../node_modules/@wix/panorama-client/dist/esm/plugins/environment/environment-plugin.js
+var EXCLUDED_ENVIRONMENTS = [RuntimeEnvironment.DEVELOPMENT, RuntimeEnvironment.SLED];
+var environmentPlugin = () => (_ref) => {
+  let {
+    hooksManager,
+    baseParams: {
+      fullArtifactId,
+      componentId
+    }
+  } = _ref;
+  const environment = calculateEnvironment();
+  const isLocalMode = checkIsLocalMode(fullArtifactId);
+  const enablePanoramaLogs = hasEnablePanoramaLogsQueryParam();
+  const shouldSkipReporting = (EXCLUDED_ENVIRONMENTS.includes(environment) || isLocalMode) && !hasForcePanoramaReportQueryParam();
+  const shouldLogToConsole = shouldSkipReporting && enablePanoramaLogs;
+  if (shouldLogToConsole) {
+    logToConsole(LogLevel.Info, fullArtifactId, componentId, `Local mode detected${fullArtifactId ? ` for ${fullArtifactId}` : ""}. Panorama will log reports in the console.`);
+  }
+  hooksManager.tap(Hook.beforeReport, (eventPayload) => {
+    const {
+      data,
+      message,
+      fullArtifactId: messageFullArtifactId,
+      componentId: messageComponentId,
+      logLevel
+    } = eventPayload;
+    if (shouldLogToConsole) {
+      logToConsole(logLevel, messageFullArtifactId, messageComponentId, message || "", data);
+    }
+    if (shouldSkipReporting) {
+      return false;
+    }
+    return;
+  });
+};
+
+// ../../node_modules/@wix/panorama-common-shared/dist/esm/constants.js
+var CLICKHOUSE_REPORT_URL = "https://panorama.wixapps.net/api/v1/log";
+
+// ../../node_modules/@wix/panorama-client-node/dist/esm/reporter.js
+import { createHttpClient } from "@wix/http-client";
+var nodeReporter = function(url, _temp) {
+  let {
+    silent = false
+  } = _temp === void 0 ? {
+    silent: false
+  } : _temp;
+  return (eventPayload) => {
+    const httpClient = createHttpClient();
+    const body = JSON.stringify({
+      logMessage: eventPayload
+    });
+    httpClient.post(url, body).catch((e) => {
+      if (silent) {
+        return;
+      }
+      console.error(e);
+    });
+    return true;
+  };
+};
+
+// ../../node_modules/@wix/panorama-client-node/dist/esm/panorama-client-node.js
+var panoramaClientFactory = (options) => {
+  const {
+    baseParams,
+    reporterOptions,
+    data
+  } = options;
+  const factory = panoramaClient({
+    baseParams,
+    data
+  }).use(environmentPlugin()).withReporter(nodeReporter(CLICKHOUSE_REPORT_URL, reporterOptions));
+  factory.use = void 0;
+  return factory;
+};
+
+// src/panorama.ts
+var packageJson = {
+  version: "1.0.0"
+};
+var globalConfig = createGlobalConfig();
+var panoramaFactory = panoramaClientFactory({
+  reporterOptions: {
+    silent: true
+  },
+  baseParams: {
+    platform: Platform.Standalone,
+    fullArtifactId: "com.wixpress.spartans.wix-mcp",
+    artifactVersion: packageJson.version
+  },
+  data: {
+    packageVersion: packageJson.version,
+    versions: process.versions,
+    platform: process.platform,
+    arch: process.arch
+  }
+}).withGlobalConfig(globalConfig);
+
+// src/wix-mcp-server.ts
+import { captureException as captureException2, setTags } from "@sentry/node";
+var WixMcpServer = class extends McpServer {
+  tool(...args) {
+    const cbIndex = args.findIndex((arg) => typeof arg === "function");
+    if (cbIndex !== -1) {
+      const originalCb = args[cbIndex];
+      const toolName = args[0];
+      const panoramaComponentId = toolName;
+      const panorama = panoramaFactory.client({
+        baseParams: {
+          componentId: panoramaComponentId
+        }
+      });
+      setTags({
+        panoramaSessionId: globalConfig.getSessionId()
+      });
+      const wrappedCb = async (...cbArgs) => {
+        const argsBeforeExtra = cbArgs.slice(0, cbArgs.length - 1);
+        const extra = cbArgs[cbArgs.length - 1];
+        const wrappedExtra = {
+          ...extra,
+          panorama: panorama.createClientForComponent()
+        };
+        panorama.transaction(toolName).start();
+        try {
+          const cbResult = await originalCb(...argsBeforeExtra, wrappedExtra);
+          panorama.transaction(toolName).finish();
+          return cbResult;
+        } catch (e) {
+          panorama.errorMonitor().reportError(e);
+          captureException2(e, {
+            tags: {
+              componentId: panoramaComponentId,
+              toolName
+            }
+          });
+          return {
+            isError: true,
+            content: [{ type: "text", text: e.message }]
+          };
+        }
+      };
+      args[cbIndex] = wrappedCb;
+    }
+    return super.tool.apply(this, args);
+  }
+};
+
+// src/resources/docs.ts
+var getPortalIndex = async (portalName) => {
+  const response = await fetch(
+    `https://dev.wix.com/digor/api/portal-index?portalName=${portalName}`
+  );
+  const data = await response.json();
+  return data;
+};
+var addPortalResources = async (server, portalName) => {
+  const portalIndexResponse = await getPortalIndex(portalName);
+  logger.log(
+    `portalIndexResponse for ${portalName}`,
+    JSON.stringify(portalIndexResponse, null, 2)
+  );
+  for (const entry of portalIndexResponse.portalIndex) {
+    logger.log(`entry ${JSON.stringify(entry, null, 2)}`);
+    const name = entry.url;
+    const uri = entry.url.replace("https://dev.wix.com/docs/", "wix-docs://");
+    logger.log(`adding resource ${name} ${uri}`);
+    server.resource(name, uri, async (uri2) => {
+      logger.log(`fetching resource ${uri2}`);
+      const docsURL = uri2.toString().replace("wix-docs://", "https://dev.wix.com/docs/");
+      const response = await fetch(
+        `https://dev.wix.com/digor/api/get-article-content?articleUrl=${encodeURIComponent(docsURL)}`
+      );
+      const data = await response.json();
+      return {
+        contents: [
+          {
+            uri: uri2.href,
+            text: data.articleContent || "No content found"
+          }
+        ]
+      };
+    });
+  }
+};
+var addDocsResources = async (server, portals) => {
+  for (const portal of portals) {
+    try {
+      logger.log(`Processing portal: ${portal}`);
+      await addPortalResources(server, portal);
+    } catch (error) {
+      logger.error(`Error processing portal ${portal}:`, error);
+    }
+  }
+};
+
+export {
+  logger,
+  attachMcpServerLogger,
+  attachStdErrLogger,
+  attachFileLogger,
+  VALID_DOCS_TOOLS,
+  addDocsTools,
+  handleWixAPIResponse,
+  WixMcpServer,
+  addDocsResources
+};