@sonordev/site-kit 6.5.0 → 7.0.0

package/dist/chunk-FV2VD7WM.js

@@ -0,0 +1,347 @@
+import { createPublicationRoutes } from './chunk-WMVK77ND.js';
+import { resolveTrailingSlash, applyTrailingSlash } from './chunk-YVKRYQRG.js';
+import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
+
+var defaults = {
+  featured: {
+    wrapper: {
+      display: "flex",
+      flexWrap: "wrap",
+      alignItems: "center",
+      justifyContent: "space-between",
+      gap: "1.5rem",
+      padding: "2rem 2.5rem",
+      margin: "3rem 0",
+      borderRadius: "1rem",
+      background: "linear-gradient(135deg, color-mix(in srgb, var(--sk-primary, #2563eb) 8%, transparent), color-mix(in srgb, var(--sk-primary, #2563eb) 15%, transparent))",
+      border: "1px solid color-mix(in srgb, var(--sk-primary, #2563eb) 25%, transparent)"
+    },
+    title: {
+      fontSize: "1.25rem",
+      fontWeight: 700,
+      color: "var(--sk-text-primary, #0f172a)",
+      margin: 0
+    },
+    description: {
+      fontSize: "0.9375rem",
+      color: "var(--sk-text-secondary, #475569)",
+      marginTop: "0.5rem",
+      maxWidth: "40rem"
+    },
+    button: {
+      display: "inline-flex",
+      alignItems: "center",
+      gap: "0.5rem",
+      padding: "0.75rem 1.75rem",
+      borderRadius: "0.5rem",
+      fontWeight: 600,
+      fontSize: "0.9375rem",
+      color: "#ffffff",
+      background: "var(--sk-primary, #2563eb)",
+      textDecoration: "none",
+      transition: "transform 0.15s, box-shadow 0.15s",
+      whiteSpace: "nowrap"
+    }
+  },
+  inline: {
+    wrapper: {
+      display: "flex",
+      gap: "1rem",
+      padding: "1.25rem 1.5rem",
+      margin: "2rem 0",
+      borderRadius: "0.75rem",
+      background: "var(--sk-bg-elevated, #f8fafc)",
+      border: "1px solid color-mix(in srgb, var(--sk-primary, #2563eb) 20%, var(--sk-surface-border, #e2e8f0))"
+    },
+    icon: {
+      display: "flex",
+      alignItems: "center",
+      justifyContent: "center",
+      width: "2.5rem",
+      height: "2.5rem",
+      borderRadius: "0.625rem",
+      background: "var(--sk-primary, #2563eb)",
+      color: "#ffffff",
+      flexShrink: 0,
+      fontSize: "1.125rem"
+    },
+    title: {
+      fontSize: "1rem",
+      fontWeight: 600,
+      color: "var(--sk-text-primary, #0f172a)",
+      margin: 0
+    },
+    description: {
+      fontSize: "0.875rem",
+      color: "var(--sk-text-secondary, #475569)",
+      marginTop: "0.25rem"
+    },
+    link: {
+      display: "inline-flex",
+      alignItems: "center",
+      gap: "0.25rem",
+      marginTop: "0.5rem",
+      fontSize: "0.875rem",
+      fontWeight: 600,
+      color: "var(--sk-primary, #2563eb)",
+      textDecoration: "none"
+    }
+  }
+};
+function ServiceCallout({
+  title,
+  description,
+  cta = "Learn More",
+  url,
+  variant = "featured",
+  styles,
+  unstyled = false
+}) {
+  if (variant === "inline") {
+    return /* @__PURE__ */ jsxs(
+      "aside",
+      {
+        className: styles?.wrapper,
+        style: unstyled ? void 0 : defaults.inline.wrapper,
+        role: "complementary",
+        "aria-label": "Related service",
+        children: [
+          /* @__PURE__ */ jsx("div", { style: unstyled ? void 0 : defaults.inline.icon, children: "\u2192" }),
+          /* @__PURE__ */ jsxs("div", { children: [
+            /* @__PURE__ */ jsx(
+              "h4",
+              {
+                className: styles?.title,
+                style: unstyled ? void 0 : defaults.inline.title,
+                children: title
+              }
+            ),
+            description && /* @__PURE__ */ jsx(
+              "p",
+              {
+                className: styles?.description,
+                style: unstyled ? void 0 : defaults.inline.description,
+                children: description
+              }
+            ),
+            /* @__PURE__ */ jsxs(
+              "a",
+              {
+                href: url,
+                className: styles?.button,
+                style: unstyled ? void 0 : defaults.inline.link,
+                children: [
+                  cta,
+                  " \u2192"
+                ]
+              }
+            )
+          ] })
+        ]
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxs(
+    "section",
+    {
+      className: styles?.wrapper,
+      style: unstyled ? void 0 : defaults.featured.wrapper,
+      role: "complementary",
+      "aria-label": "Call to action",
+      children: [
+        /* @__PURE__ */ jsxs("div", { children: [
+          /* @__PURE__ */ jsx(
+            "h3",
+            {
+              className: styles?.title,
+              style: unstyled ? void 0 : defaults.featured.title,
+              children: title
+            }
+          ),
+          description && /* @__PURE__ */ jsx(
+            "p",
+            {
+              className: styles?.description,
+              style: unstyled ? void 0 : defaults.featured.description,
+              children: description
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsxs(
+          "a",
+          {
+            href: url,
+            className: styles?.button,
+            style: unstyled ? void 0 : defaults.featured.button,
+            children: [
+              cta,
+              " \u2192"
+            ]
+          }
+        )
+      ]
+    }
+  );
+}
+function ServiceCallouts({
+  callouts,
+  styles,
+  unstyled
+}) {
+  if (!callouts || callouts.length === 0) return null;
+  return /* @__PURE__ */ jsx(Fragment, { children: callouts.map((callout, i) => /* @__PURE__ */ jsx(
+    ServiceCallout,
+    {
+      ...callout,
+      variant: i === 0 ? "featured" : "inline",
+      styles,
+      unstyled
+    },
+    callout.url + i
+  )) });
+}
+var clusterNavCss = `
+.sk-cluster-nav {
+  --_cn-primary: var(--sk-primary, currentColor);
+  --_cn-bg: var(--sk-bg-elevated, color-mix(in srgb, currentColor 6%, transparent));
+  --_cn-border: var(--sk-surface-border, color-mix(in srgb, currentColor 12%, transparent));
+  --_cn-text: var(--sk-text-primary, inherit);
+  --_cn-text2: var(--sk-text-secondary, color-mix(in srgb, currentColor 70%, transparent));
+  --_cn-text3: var(--sk-text-tertiary, color-mix(in srgb, currentColor 45%, transparent));
+
+  margin: 2rem 0;
+  padding: 1.5rem;
+  border-radius: 0.75rem;
+  background: var(--_cn-bg);
+  border: 1px solid var(--_cn-border);
+  color: var(--_cn-text);
+}
+
+.sk-cluster-pillar-link {
+  margin-bottom: 1.25rem;
+  padding-bottom: 1.25rem;
+  border-bottom: 1px solid var(--_cn-border);
+}
+.sk-cluster-pillar-link-label {
+  font-size: 0.6875rem;
+  font-weight: 600;
+  text-transform: uppercase;
+  letter-spacing: 0.06em;
+  color: var(--_cn-text3);
+  margin: 0 0 0.375rem 0;
+}
+.sk-cluster-pillar-link a {
+  font-size: 0.9375rem;
+  font-weight: 600;
+  color: var(--_cn-primary);
+  text-decoration: none;
+  transition: opacity 0.15s;
+}
+.sk-cluster-pillar-link a:hover { opacity: 0.8; }
+
+.sk-cluster-siblings-title {
+  font-size: 0.6875rem;
+  font-weight: 600;
+  text-transform: uppercase;
+  letter-spacing: 0.06em;
+  color: var(--_cn-text3);
+  margin: 0 0 0.75rem 0;
+}
+.sk-cluster-siblings-list {
+  list-style: none;
+  margin: 0;
+  padding: 0;
+  display: flex;
+  flex-direction: column;
+  gap: 0.5rem;
+}
+.sk-cluster-siblings-item {
+  display: flex;
+  align-items: center;
+  gap: 0.5rem;
+}
+.sk-cluster-siblings-item a {
+  font-size: 0.875rem;
+  color: var(--_cn-text2);
+  text-decoration: none;
+  transition: color 0.15s;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.sk-cluster-siblings-item a:hover { color: var(--_cn-primary); }
+.sk-cluster-type-badge {
+  display: inline-flex;
+  align-items: center;
+  flex-shrink: 0;
+  padding: 0.125rem 0.4rem;
+  border-radius: 9999px;
+  font-size: 0.625rem;
+  font-weight: 500;
+  text-transform: capitalize;
+  background: color-mix(in srgb, var(--_cn-primary) 10%, transparent);
+  color: var(--_cn-primary);
+  border: 1px solid color-mix(in srgb, var(--_cn-primary) 20%, transparent);
+}
+`;
+function ClusterNavigation({
+  navigation,
+  basePath,
+  routing,
+  category,
+  trailingSlash: trailingSlashProp,
+  unstyled = false,
+  className
+}) {
+  if (!navigation) return null;
+  const siblings = (navigation.siblings || []).filter(
+    (s) => s.article_type !== "pillar"
+  );
+  const hasPillarLink = !navigation.is_pillar && navigation.pillar;
+  const hasSiblings = siblings.length > 0;
+  if (!hasPillarLink && !hasSiblings) return null;
+  const trailingSlash = resolveTrailingSlash(trailingSlashProp);
+  const articleUrl = (article) => {
+    const path = createPublicationRoutes({ basePath, category, includeCategoryInPath: !routing, ...routing }).post(article);
+    return trailingSlash ? applyTrailingSlash(path, true) : path;
+  };
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    !unstyled && /* @__PURE__ */ jsx("style", { dangerouslySetInnerHTML: { __html: clusterNavCss } }),
+    /* @__PURE__ */ jsxs("nav", { className: `${unstyled ? "" : "sk-cluster-nav"} ${className || ""}`, children: [
+      hasPillarLink && navigation.pillar && /* @__PURE__ */ jsxs("div", { className: unstyled ? "" : "sk-cluster-pillar-link", children: [
+        /* @__PURE__ */ jsx("p", { className: unstyled ? "" : "sk-cluster-pillar-link-label", children: "Full Guide" }),
+        /* @__PURE__ */ jsx("a", { href: articleUrl(navigation.pillar), children: navigation.pillar.title })
+      ] }),
+      hasSiblings && /* @__PURE__ */ jsxs("div", { children: [
+        /* @__PURE__ */ jsx("p", { className: unstyled ? "" : "sk-cluster-siblings-title", children: navigation.is_pillar ? "Deep Dives" : "More in This Series" }),
+        /* @__PURE__ */ jsx("ul", { className: unstyled ? "" : "sk-cluster-siblings-list", children: siblings.map((sibling) => /* @__PURE__ */ jsxs("li", { className: unstyled ? "" : "sk-cluster-siblings-item", children: [
+          /* @__PURE__ */ jsx("span", { className: unstyled ? "" : "sk-cluster-type-badge", children: sibling.article_type }),
+          /* @__PURE__ */ jsx("a", { href: articleUrl(sibling), children: sibling.title })
+        ] }, sibling.slug)) })
+      ] })
+    ] })
+  ] });
+}
+
+// src/articles/author-social.ts
+var withPrefix = (value, base) => value.startsWith("http") ? value : `${base}${value}`;
+function getAuthorSocialLinks(author) {
+  const links = [];
+  const linkedin = author.linkedin_url || author.social_links?.linkedin;
+  if (linkedin) links.push({ label: "LinkedIn", href: withPrefix(linkedin, "https://linkedin.com/in/") });
+  const twitter = author.twitter_url ? author.twitter_url : author.social_links?.twitter ? withPrefix(author.social_links.twitter, "https://twitter.com/") : null;
+  if (twitter) links.push({ label: "Twitter", href: twitter });
+  const website = author.website_url || author.website;
+  if (website) links.push({ label: "Website", href: website });
+  const github = author.social_links?.github;
+  if (github) links.push({ label: "GitHub", href: withPrefix(github, "https://github.com/") });
+  return links;
+}
+
+// src/articles/reading-time.ts
+function readingTimeMinutes(post) {
+  const value = post.reading_time_minutes ?? post.reading_time;
+  return typeof value === "number" && value > 0 ? value : null;
+}
+
+export { ClusterNavigation, ServiceCallout, ServiceCallouts, getAuthorSocialLinks, readingTimeMinutes };

package/dist/chunk-FYAB6CXS.js

@@ -0,0 +1,265 @@
+// src/mcp/protocol.ts
+var MCP_PROTOCOL_VERSION_MODERN = "2026-07-28";
+var MCP_PROTOCOL_VERSIONS_LEGACY = ["2025-11-25", "2025-06-18", "2025-03-26"];
+var MCP_SUPPORTED_PROTOCOL_VERSIONS = [
+  MCP_PROTOCOL_VERSION_MODERN,
+  ...MCP_PROTOCOL_VERSIONS_LEGACY
+];
+var META_PROTOCOL_VERSION = "io.modelcontextprotocol/protocolVersion";
+var META_CLIENT_INFO = "io.modelcontextprotocol/clientInfo";
+var META_SERVER_INFO = "io.modelcontextprotocol/serverInfo";
+var JSONRPC_PARSE_ERROR = -32700;
+var JSONRPC_INVALID_REQUEST = -32600;
+var JSONRPC_METHOD_NOT_FOUND = -32601;
+var JSONRPC_INVALID_PARAMS = -32602;
+var MCP_ERROR_HEADER_MISMATCH = -32020;
+var MCP_ERROR_UNSUPPORTED_PROTOCOL_VERSION = -32022;
+var MAX_JSON_TEXT = 6e4;
+function isToolResult(value) {
+  return typeof value === "object" && value !== null && Array.isArray(value.content);
+}
+function toToolResult(value) {
+  if (isToolResult(value)) return value;
+  if (typeof value === "string") {
+    return { content: [{ type: "text", text: value }] };
+  }
+  if (value === void 0 || value === null) {
+    return { content: [{ type: "text", text: "(no result)" }] };
+  }
+  let text;
+  try {
+    text = JSON.stringify(value, null, 2);
+  } catch {
+    text = String(value);
+  }
+  if (text.length > MAX_JSON_TEXT) {
+    text = `${text.slice(0, MAX_JSON_TEXT)}
+\u2026 (truncated)`;
+  }
+  return {
+    content: [{ type: "text", text }],
+    structuredContent: value
+  };
+}
+function toolErrorResult(message) {
+  return { content: [{ type: "text", text: message }], isError: true };
+}
+function toToolDescriptor(tool) {
+  const descriptor = {
+    name: tool.name,
+    description: tool.description,
+    inputSchema: tool.inputSchema
+  };
+  if (tool.title) descriptor.title = tool.title;
+  if (tool.outputSchema) descriptor.outputSchema = tool.outputSchema;
+  if (tool.annotations) descriptor.annotations = tool.annotations;
+  return descriptor;
+}
+function validateArgs(tool, args) {
+  const required = tool.inputSchema.required ?? [];
+  const missing = required.filter((key) => {
+    const value = args[key];
+    return value === void 0 || value === null || value === "";
+  });
+  if (missing.length > 0) {
+    return `Missing required argument${missing.length > 1 ? "s" : ""}: ${missing.join(", ")}.`;
+  }
+  for (const [key, schema] of Object.entries(tool.inputSchema.properties ?? {})) {
+    const value = args[key];
+    if (value === void 0 || value === null) continue;
+    if (schema.enum && !schema.enum.includes(value)) {
+      return `Invalid value for "${key}": ${JSON.stringify(value)}. Expected one of: ${schema.enum.map((v) => JSON.stringify(v)).join(", ")}.`;
+    }
+  }
+  return null;
+}
+function capabilities() {
+  return { tools: { listChanged: false } };
+}
+function serverInfoBlock(info) {
+  return { name: info.name, version: info.version, ...info.title ? { title: info.title } : {} };
+}
+function isSupportedVersion(version) {
+  return MCP_SUPPORTED_PROTOCOL_VERSIONS.includes(version);
+}
+function unsupportedVersionError(id, requested) {
+  return {
+    status: 400,
+    response: {
+      jsonrpc: "2.0",
+      id,
+      error: {
+        code: MCP_ERROR_UNSUPPORTED_PROTOCOL_VERSION,
+        message: "Unsupported protocol version",
+        data: { supported: [...MCP_SUPPORTED_PROTOCOL_VERSIONS], requested }
+      }
+    }
+  };
+}
+function errorOutcome(id, code, message, status, data) {
+  return {
+    status,
+    response: { jsonrpc: "2.0", id, error: { code, message, ...data ? { data } : {} } }
+  };
+}
+async function dispatch(message, options) {
+  const { server } = options;
+  const id = message.id ?? null;
+  const isNotification = message.id === void 0;
+  const params = message.params ?? {};
+  const meta = params._meta ?? {};
+  const bodyVersion = typeof meta[META_PROTOCOL_VERSION] === "string" ? meta[META_PROTOCOL_VERSION] : null;
+  const headerVersion = options.headerProtocolVersion || null;
+  if (bodyVersion && headerVersion && bodyVersion !== headerVersion) {
+    return errorOutcome(
+      id,
+      MCP_ERROR_HEADER_MISMATCH,
+      `Header mismatch: MCP-Protocol-Version header value '${headerVersion}' does not match body value '${bodyVersion}'`,
+      400
+    );
+  }
+  const requestedVersion = bodyVersion || headerVersion;
+  if (requestedVersion && !isSupportedVersion(requestedVersion)) {
+    return unsupportedVersionError(id, requestedVersion);
+  }
+  if (options.headerMethod && options.headerMethod !== message.method) {
+    return errorOutcome(
+      id,
+      MCP_ERROR_HEADER_MISMATCH,
+      `Header mismatch: Mcp-Method header value '${options.headerMethod}' does not match body value '${message.method}'`,
+      400
+    );
+  }
+  if (options.headerName) {
+    const bodyName = typeof params.name === "string" ? params.name : typeof params.uri === "string" ? params.uri : null;
+    if (bodyName && options.headerName !== bodyName) {
+      return errorOutcome(
+        id,
+        MCP_ERROR_HEADER_MISMATCH,
+        `Header mismatch: Mcp-Name header value '${options.headerName}' does not match body value '${bodyName}'`,
+        400
+      );
+    }
+  }
+  if (options.strictHeaders && bodyVersion) {
+    if (!headerVersion) {
+      return errorOutcome(
+        id,
+        MCP_ERROR_HEADER_MISMATCH,
+        "Header mismatch: required MCP-Protocol-Version header is missing",
+        400
+      );
+    }
+    if (!options.headerMethod) {
+      return errorOutcome(
+        id,
+        MCP_ERROR_HEADER_MISMATCH,
+        "Header mismatch: required Mcp-Method header is missing",
+        400
+      );
+    }
+  }
+  const negotiated = requestedVersion || MCP_PROTOCOL_VERSION_MODERN;
+  switch (message.method) {
+    // ── Modern discovery (MUST implement) ──────────────────────────────────
+    case "server/discover": {
+      return {
+        status: 200,
+        response: {
+          jsonrpc: "2.0",
+          id,
+          result: {
+            resultType: "complete",
+            supportedVersions: [...MCP_SUPPORTED_PROTOCOL_VERSIONS],
+            capabilities: capabilities(),
+            ...server.info.instructions ? { instructions: server.info.instructions } : {},
+            ttlMs: server.discoverTtlMs ?? 36e5,
+            cacheScope: "public",
+            _meta: { [META_SERVER_INFO]: serverInfoBlock(server.info) }
+          }
+        }
+      };
+    }
+    // ── Legacy handshake ───────────────────────────────────────────────────
+    case "initialize": {
+      const asked = typeof params.protocolVersion === "string" ? params.protocolVersion : "";
+      const agreed = isSupportedVersion(asked) ? asked : MCP_PROTOCOL_VERSIONS_LEGACY[0];
+      return {
+        status: 200,
+        response: {
+          jsonrpc: "2.0",
+          id,
+          result: {
+            protocolVersion: agreed,
+            capabilities: capabilities(),
+            serverInfo: serverInfoBlock(server.info),
+            ...server.info.instructions ? { instructions: server.info.instructions } : {}
+          }
+        }
+      };
+    }
+    case "notifications/initialized":
+    case "initialized":
+      return { status: 202, response: null };
+    case "ping":
+      return { status: 200, response: { jsonrpc: "2.0", id, result: {} } };
+    // ── Tools ──────────────────────────────────────────────────────────────
+    case "tools/list": {
+      const tools = server.tools.filter((t) => t.exposeToHttp !== false).map((t) => toToolDescriptor(t));
+      return { status: 200, response: { jsonrpc: "2.0", id, result: { tools } } };
+    }
+    case "tools/call": {
+      const name = typeof params.name === "string" ? params.name : "";
+      const tool = server.tools.find((t) => t.name === name && t.exposeToHttp !== false);
+      if (!tool) {
+        return errorOutcome(
+          id,
+          JSONRPC_INVALID_PARAMS,
+          `Unknown tool: ${name || "(none)"}`,
+          400,
+          {
+            available: server.tools.filter((t) => t.exposeToHttp !== false).map((t) => t.name)
+          }
+        );
+      }
+      const args = params.arguments ?? {};
+      const invalid = validateArgs(tool, args);
+      if (invalid) {
+        return {
+          status: 200,
+          response: { jsonrpc: "2.0", id, result: toolErrorResult(invalid) }
+        };
+      }
+      try {
+        const raw = await tool.handler(args, {
+          ...options.context,
+          surface: "http",
+          protocolVersion: negotiated
+        });
+        return { status: 200, response: { jsonrpc: "2.0", id, result: toToolResult(raw) } };
+      } catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        return {
+          status: 200,
+          response: {
+            jsonrpc: "2.0",
+            id,
+            result: toolErrorResult(`Tool "${tool.name}" failed: ${detail}`)
+          }
+        };
+      }
+    }
+    // Declared unsupported rather than left to fall through, so the error names
+    // the reason instead of looking like a typo'd method.
+    case "resources/list":
+      return { status: 200, response: { jsonrpc: "2.0", id, result: { resources: [] } } };
+    case "prompts/list":
+      return { status: 200, response: { jsonrpc: "2.0", id, result: { prompts: [] } } };
+    default: {
+      if (isNotification) return { status: 202, response: null };
+      return errorOutcome(id, JSONRPC_METHOD_NOT_FOUND, `Method not found: ${message.method}`, 404);
+    }
+  }
+}
+
+export { JSONRPC_INVALID_REQUEST, JSONRPC_METHOD_NOT_FOUND, JSONRPC_PARSE_ERROR, MCP_ERROR_HEADER_MISMATCH, MCP_ERROR_UNSUPPORTED_PROTOCOL_VERSION, MCP_PROTOCOL_VERSIONS_LEGACY, MCP_PROTOCOL_VERSION_MODERN, MCP_SUPPORTED_PROTOCOL_VERSIONS, META_CLIENT_INFO, META_PROTOCOL_VERSION, META_SERVER_INFO, dispatch, errorOutcome, isSupportedVersion, toToolDescriptor, toToolResult, toolErrorResult, validateArgs };