@sonordev/site-kit 6.5.0 → 7.0.0

package/dist/chunk-WMVK77ND.js

@@ -0,0 +1,53 @@
+// src/articles/routes.ts
+var DEFAULT_PUBLICATION_PATH = "/articles";
+function articleCategorySlug(category) {
+  const value = typeof category === "string" ? category : category?.slug || category?.name || "";
+  return value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function localPath(path) {
+  const value = path.trim();
+  if (!value || /^[a-z][a-z\d+.-]*:/i.test(value) || value.startsWith("//") || value.includes("\\")) {
+    throw new Error("Publication routes must be local paths, such as /theforge/guides/story.");
+  }
+  return value.startsWith("/") ? value : `/${value}`;
+}
+function createPublicationRoutes(options = {}) {
+  const raw = (options.basePath ?? DEFAULT_PUBLICATION_PATH).trim() || DEFAULT_PUBLICATION_PATH;
+  const index = localPath(raw).replace(/\/+$/, "") || "/";
+  const prefix = index === "/" ? "" : index;
+  return {
+    index,
+    post(post) {
+      if (options.postPath) return localPath(options.postPath(post));
+      const category = articleCategorySlug(post.category || options.category);
+      return `${prefix}${options.includeCategoryInPath && category ? `/${encodeURIComponent(category)}` : ""}/${encodeURIComponent(post.slug)}`;
+    },
+    category(slug) {
+      const normalized = articleCategorySlug(slug);
+      return options.categoryPath ? localPath(options.categoryPath(normalized)) : `${prefix}/category/${encodeURIComponent(normalized)}`;
+    },
+    cluster: (slug) => `${prefix}/cluster/${encodeURIComponent(slug)}`,
+    author: (slug) => typeof options.authorPages === "function" ? localPath(options.authorPages(slug)) : `${prefix}/author/${encodeURIComponent(slug)}`,
+    rss: `${prefix}/rss.xml`,
+    atom: `${prefix}/feed.xml`
+  };
+}
+function resolvePublicationUrl(path, siteUrl = "") {
+  return `${siteUrl.replace(/\/+$/, "")}${localPath(path)}`;
+}
+function resolveArticleUrl(post, options = {}) {
+  const canonical = post.canonical_url?.trim();
+  if (canonical) {
+    if (/^https?:\/\//i.test(canonical)) {
+      try {
+        return new URL(canonical).toString();
+      } catch {
+      }
+    } else if (canonical.startsWith("/") && !canonical.startsWith("//") && !canonical.includes("\\")) {
+      return resolvePublicationUrl(canonical, options.siteUrl);
+    }
+  }
+  return resolvePublicationUrl(createPublicationRoutes(options).post(post), options.siteUrl);
+}
+
+export { articleCategorySlug, createPublicationRoutes, resolveArticleUrl, resolvePublicationUrl };

package/dist/chunk-X6F6SO4S.js

@@ -0,0 +1,135 @@
+import { monotonicMs, retryJitter } from './chunk-MH2DSGC6.js';
+import 'server-only';
+
+var DEFAULT_API_URL = "https://api.sonor.io";
+var DEFAULT_REVALIDATE = 86400;
+var DEFAULT_MAX_ATTEMPTS = 6;
+function resolveServerApiConfig(options = {}) {
+  const apiKey = options.apiKey || process.env.SONOR_API_KEY || "";
+  if (!apiKey) return null;
+  const apiUrl = (options.apiUrl || process.env.SONOR_API_URL || process.env.NEXT_PUBLIC_SONOR_API_URL || DEFAULT_API_URL).replace(/\/+$/, "");
+  return { apiUrl, apiKey };
+}
+function requireServerApiConfig(options = {}, errorMessage = "@sonordev/site-kit: SONOR_API_KEY environment variable is required for server-side functions") {
+  const config = resolveServerApiConfig(options);
+  if (!config) throw new Error(errorMessage);
+  return config;
+}
+function resolveApiOrigin(apiUrl) {
+  const url = apiUrl || process.env.SONOR_API_URL || DEFAULT_API_URL;
+  try {
+    return new URL(url.replace(/\/+$/, "")).origin;
+  } catch {
+    return DEFAULT_API_URL;
+  }
+}
+var RETRYABLE_HTTP = /* @__PURE__ */ new Set([429, 502, 503]);
+var DEFAULT_ATTEMPT_TIMEOUT_MS = 1e4;
+var DEFAULT_TOTAL_TIMEOUT_MS = 3e4;
+function attemptSignal(budgetMs, callerSignal) {
+  if (typeof AbortSignal === "undefined" || typeof AbortSignal.timeout !== "function") {
+    return callerSignal ?? void 0;
+  }
+  const timeout = AbortSignal.timeout(Math.max(1, Math.ceil(budgetMs)));
+  if (!callerSignal) return timeout;
+  return typeof AbortSignal.any === "function" ? AbortSignal.any([timeout, callerSignal]) : timeout;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function serverApiFetch(path, options = {}) {
+  const {
+    method = "GET",
+    body,
+    headers: extraHeaders = {},
+    revalidate = DEFAULT_REVALIDATE,
+    tags,
+    apiKey: overrideApiKey,
+    apiUrl: overrideApiUrl,
+    retry = true,
+    maxAttempts = DEFAULT_MAX_ATTEMPTS,
+    timeoutMs = DEFAULT_ATTEMPT_TIMEOUT_MS,
+    totalTimeoutMs = DEFAULT_TOTAL_TIMEOUT_MS,
+    requireKey = false,
+    logPrefix = "@sonordev/site-kit",
+    init
+  } = options;
+  const overrides = { apiKey: overrideApiKey, apiUrl: overrideApiUrl };
+  let config;
+  if (requireKey) {
+    config = requireServerApiConfig(overrides);
+  } else {
+    const resolved = resolveServerApiConfig(overrides);
+    if (!resolved) {
+      console.warn(`${logPrefix}: Missing SONOR_API_KEY \u2014 request to ${path} skipped.`);
+      return null;
+    }
+    config = resolved;
+  }
+  const { apiUrl, apiKey } = config;
+  const url = `${apiUrl}${path.startsWith("/") ? path : `/${path}`}`;
+  const serializedBody = body === void 0 ? void 0 : typeof body === "string" ? body : JSON.stringify(body);
+  const attempts = retry ? Math.max(1, maxAttempts) : 1;
+  const deadline = monotonicMs() + Math.max(1, totalTimeoutMs);
+  for (let attempt = 1; attempt <= attempts; attempt++) {
+    const remaining = deadline - monotonicMs();
+    if (remaining <= 0) {
+      console.warn(
+        `${logPrefix}: Time budget (${totalTimeoutMs}ms) exhausted for ${method} ${path} after ${attempt - 1} attempt(s).`
+      );
+      return null;
+    }
+    try {
+      const response = await fetch(url, {
+        ...init,
+        signal: attemptSignal(Math.min(timeoutMs, remaining), init?.signal),
+        method,
+        headers: {
+          "Content-Type": "application/json",
+          "x-api-key": apiKey,
+          ...extraHeaders
+        },
+        ...serializedBody !== void 0 ? { body: serializedBody } : {},
+        next: { revalidate, ...tags?.length ? { tags } : {} }
+      });
+      if (retry && RETRYABLE_HTTP.has(response.status) && attempt < attempts) {
+        await response.text().catch(() => {
+        });
+        const retryAfter = response.headers.get("retry-after");
+        let delayMs = 250 * attempt * attempt + retryJitter() * 200;
+        if (retryAfter) {
+          const sec = parseInt(retryAfter, 10);
+          if (!Number.isNaN(sec) && sec > 0) delayMs = Math.max(delayMs, sec * 1e3);
+        }
+        await sleep(Math.min(delayMs, 1e4, Math.max(0, deadline - monotonicMs())));
+        continue;
+      }
+      if (!response.ok) {
+        let detail = response.statusText;
+        try {
+          const err = await response.json().catch(() => ({}));
+          if (err?.message) detail = err.message;
+        } catch {
+        }
+        console.warn(`${logPrefix}: API error ${response.status} ${method} ${path}: ${detail}`);
+        return null;
+      }
+      return await response.json();
+    } catch (error) {
+      if (retry && attempt < attempts && monotonicMs() < deadline) {
+        await sleep(
+          Math.min(200 * attempt * attempt + retryJitter() * 150, Math.max(0, deadline - monotonicMs()))
+        );
+        continue;
+      }
+      console.warn(
+        `${logPrefix}: Network error for ${url}:`,
+        error instanceof Error ? error.message : error
+      );
+      return null;
+    }
+  }
+  return null;
+}
+
+export { requireServerApiConfig, resolveApiOrigin, resolveServerApiConfig, serverApiFetch };

package/dist/chunk-XTRZGXB2.js

@@ -0,0 +1,34 @@
+import { timingSafeEqual } from 'crypto';
+
+// src/shared/request-guards.ts
+function secretsMatch(supplied, expected) {
+  if (!expected || !supplied) return false;
+  const a = Buffer.from(supplied);
+  const b = Buffer.from(expected);
+  return a.length === b.length && timingSafeEqual(a, b);
+}
+async function readCappedBody(request, maxBytes) {
+  const reader = request.body?.getReader();
+  if (!reader) return new Uint8Array(0);
+  const chunks = [];
+  let size = 0;
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    size += value.byteLength;
+    if (size > maxBytes) {
+      await reader.cancel();
+      return null;
+    }
+    chunks.push(value);
+  }
+  const body = new Uint8Array(size);
+  let offset = 0;
+  for (const chunk of chunks) {
+    body.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return body;
+}
+
+export { readCappedBody, secretsMatch };

package/dist/chunk-XZMVNORA.js

@@ -0,0 +1,100 @@
+'use client';
+import { useDeferredActivation } from './chunk-YC7ELZS3.js';
+import React, { lazy, useRef, useEffect, useState, Suspense } from 'react';
+import { jsx, jsxs } from 'react/jsx-runtime';
+
+var InteractiveForm = lazy(
+  () => import('./ManagedForm-3VRALWUD.js').then((m) => ({ default: m.ManagedForm }))
+);
+function FormEnhancer({
+  formId,
+  initialConfig,
+  className,
+  experience,
+  defaultValues,
+  onSuccess,
+  onError,
+  enter = "fade",
+  defer = true,
+  children
+}) {
+  const ready = useDeferredActivation(defer);
+  const [enhanced, setEnhanced] = useState(false);
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      "data-sk-form-mount": enhanced ? "enhanced" : "shell",
+      "data-sk-part": "form-mount",
+      style: enter === "fade" ? FADE_HOST : void 0,
+      children: [
+        enter === "fade" && /* @__PURE__ */ jsx(EnterStyles, {}),
+        ready ? /* @__PURE__ */ jsx(Suspense, { fallback: children, children: /* @__PURE__ */ jsx(Enhanced, { onMount: () => setEnhanced(true), fallback: children, children: /* @__PURE__ */ jsx(
+          InteractiveForm,
+          {
+            formId,
+            initialConfig,
+            className,
+            experience,
+            defaultValues,
+            onSuccess,
+            onError
+          }
+        ) }) }) : children
+      ]
+    }
+  );
+}
+var Enhanced = class extends React.Component {
+  constructor() {
+    super(...arguments);
+    this.state = { failed: false };
+  }
+  static getDerivedStateFromError() {
+    return { failed: true };
+  }
+  componentDidCatch(err) {
+    console.error("[Forms] Enhancement failed; keeping the native form:", err);
+  }
+  componentDidMount() {
+    if (!this.state.failed) this.props.onMount();
+  }
+  render() {
+    if (this.state.failed) return this.props.fallback;
+    return /* @__PURE__ */ jsx(FrameTag, { children: this.props.children });
+  }
+};
+function FrameTag({ children }) {
+  const ref = useRef(null);
+  useEffect(() => {
+    const el = ref.current;
+    if (!el) return;
+    el.setAttribute("data-sk-enter", "");
+    const id = requestAnimationFrame(() => el.removeAttribute("data-sk-enter"));
+    return () => cancelAnimationFrame(id);
+  }, []);
+  return /* @__PURE__ */ jsx("div", { ref, style: { display: "contents" }, children });
+}
+var FADE_HOST = {
+  transition: "opacity var(--sk-form-enter-duration, 320ms) var(--sk-form-enter-easing, cubic-bezier(.22,1,.36,1))"
+};
+function EnterStyles() {
+  return /* @__PURE__ */ jsx(
+    "style",
+    {
+      dangerouslySetInnerHTML: {
+        __html: `
+[data-sk-part="form-mount"][data-sk-form-mount="shell"]{opacity:.55}
+[data-sk-part="form-mount"][data-sk-form-mount="enhanced"]{opacity:1}
+[data-sk-part="form-mount"] [data-sk-enter]{opacity:0;transform:translateY(var(--sk-form-enter-distance,6px))}
+[data-sk-part="form-mount"] [data-sk-enter] *{transition:none!important}
+@media (prefers-reduced-motion: reduce){
+[data-sk-part="form-mount"]{transition:none!important}
+[data-sk-part="form-mount"][data-sk-form-mount="shell"]{opacity:1}
+[data-sk-part="form-mount"] [data-sk-enter]{opacity:1;transform:none}
+}`
+      }
+    }
+  );
+}
+
+export { FormEnhancer };

package/dist/chunk-Y3INC4QJ.js

@@ -0,0 +1,133 @@
+// src/articles/article-tables.ts
+var tableScrollClass = "sk-article-table-scroll";
+var legacyTableScrollClass = "sk-blog-table-scroll";
+var voidElements = /* @__PURE__ */ new Set([
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+]);
+var preservedElements = /* @__PURE__ */ new Set(["pre", "code", "script", "style", "textarea", "xmp", "template"]);
+function htmlTags() {
+  return /<!--[\s\S]*?(?:-->|$)|<\/?[a-z][\w:-]*(?=[\s/>])(?:[^"'<>]|"[^"]*"|'[^']*')*>/gi;
+}
+function hasScrollClass(tag) {
+  const attributes = tag.replace(/^<[\w:-]+/, "").replace(/\/?>$/, "");
+  const pattern = /([^\s=/>]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+)))?/g;
+  for (const attribute of attributes.matchAll(pattern)) {
+    if (attribute[1].toLowerCase() !== "class") continue;
+    return (attribute[2] ?? attribute[3] ?? attribute[4] ?? "").split(/\s+/).some((name) => name === tableScrollClass || name === legacyTableScrollClass);
+  }
+  return false;
+}
+function labelText(html) {
+  return html.replace(/<!--[\s\S]*?(?:-->|$)/g, "").replace(htmlTags(), " ").replace(/\s+/g, " ").trim();
+}
+function escapeLabel(text) {
+  return text.replace(/&(?!(?:#\d+|#x[\da-f]+|[a-z][\da-z]+);)/gi, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function tableLabel(table, number) {
+  const caption = table.match(/<caption\b(?:[^"'<>]|"[^"]*"|'[^']*')*>([\s\S]*?)<\/caption\s*>/i)?.[1];
+  const headers = [...table.matchAll(/<th\b(?:[^"'<>]|"[^"]*"|'[^']*')*>([\s\S]*?)<\/th\s*>/gi)].slice(0, 4).map((match) => labelText(match[1])).filter(Boolean).join(", ");
+  const summary = labelText(caption || headers).slice(0, 180);
+  return escapeLabel(`Table ${number}${summary ? `: ${summary}` : ""}`);
+}
+function wrapArticleTables(html) {
+  const tags = htmlTags();
+  const stack = [];
+  const tables = [];
+  let tableNumber = 0;
+  let token;
+  while (token = tags.exec(html)) {
+    const tag = token[0];
+    if (tag.startsWith("<!--")) continue;
+    const tagName = /^<\/?([\w:-]+)/.exec(tag)[1].toLowerCase();
+    if (tag.startsWith("</")) {
+      const index = stack.map((frame3) => frame3.tag).lastIndexOf(tagName);
+      if (index < 0) continue;
+      const frame2 = stack[index];
+      if (frame2.table) tables.push({ ...frame2.table, end: tags.lastIndex });
+      stack.length = index;
+      continue;
+    }
+    if (preservedElements.has(tagName)) {
+      const closingTag = new RegExp(`</${tagName}\\s*>`, "gi");
+      closingTag.lastIndex = tags.lastIndex;
+      if (!closingTag.exec(html)) break;
+      tags.lastIndex = closingTag.lastIndex;
+      continue;
+    }
+    if (voidElements.has(tagName) || /\/\s*>$/.test(tag)) continue;
+    const frame = { tag: tagName, scrollRegion: hasScrollClass(tag) };
+    if (tagName === "table" && !stack.some((ancestor) => ancestor.tag === "table")) {
+      tableNumber += 1;
+      if (!stack.some((ancestor) => ancestor.scrollRegion)) {
+        frame.table = { start: token.index, number: tableNumber };
+      }
+    }
+    stack.push(frame);
+  }
+  let output = "";
+  let cursor = 0;
+  for (const { start, end, number } of tables) {
+    const table = html.slice(start, end);
+    output += `${html.slice(cursor, start)}<div class="${tableScrollClass}" role="region" tabindex="0" aria-label="${tableLabel(table, number)}">${table}</div>`;
+    cursor = end;
+  }
+  return output + html.slice(cursor);
+}
+var articleTableCss = (
+  /* css */
+  `
+.sk-article-content .sk-article-table-scroll {
+  box-sizing: border-box;
+  min-width: 0;
+  max-width: 100%;
+  overflow-x: auto;
+  margin: 1.5em 0;
+  border: 1px solid var(--sk-surface-border, #e2e8f0);
+  border-radius: var(--sk-radius, 0.5rem);
+  background: var(--sk-bg-elevated, #f8fafc);
+  scrollbar-width: thin;
+  scrollbar-color: var(--sk-primary, #2563eb) var(--sk-bg-elevated, #f8fafc);
+  overscroll-behavior-x: contain;
+}
+.sk-article-content .sk-article-table-scroll:focus-visible {
+  outline: 2px solid var(--sk-border-focus, var(--sk-primary, #2563eb));
+  outline-offset: 3px;
+}
+.sk-article-content .sk-article-table-scroll::-webkit-scrollbar { height: 10px; }
+.sk-article-content .sk-article-table-scroll::-webkit-scrollbar-track {
+  background: var(--sk-bg-elevated, #f8fafc);
+  border-radius: var(--sk-radius, 0.5rem);
+}
+.sk-article-content .sk-article-table-scroll::-webkit-scrollbar-thumb {
+  background: var(--sk-primary, #2563eb);
+  background-clip: padding-box;
+  border: 2px solid var(--sk-bg-elevated, #f8fafc);
+  border-radius: var(--sk-radius, 0.5rem);
+}
+.sk-article-content .sk-article-table-scroll > table {
+  display: table;
+  margin: 0;
+  overflow: visible;
+}
+.sk-article-content .sk-article-table-scroll caption {
+  padding: 0.625rem 0.875rem;
+  text-align: start;
+  color: var(--sk-text-secondary, #475569);
+}
+`.trim()
+);
+
+export { articleTableCss, wrapArticleTables };

package/dist/chunk-YC7ELZS3.js

@@ -0,0 +1,51 @@
+'use client';
+import { useState, useEffect } from 'react';
+
+// src/shared/defer.ts
+function useDeferredActivation(enabled, idleTimeout = 2500) {
+  const [ready, setReady] = useState(!enabled);
+  useEffect(() => {
+    if (!enabled || ready) return;
+    let fired = false;
+    let idleId = null;
+    let timeoutId = null;
+    const w = window;
+    const go = () => {
+      if (fired) return;
+      fired = true;
+      setReady(true);
+    };
+    const scheduleIdle = () => {
+      if (typeof w.requestIdleCallback === "function") {
+        idleId = w.requestIdleCallback(go, { timeout: idleTimeout });
+      } else {
+        timeoutId = setTimeout(go, Math.min(idleTimeout, 1500));
+      }
+    };
+    const interactionEvents = [
+      "pointerdown",
+      "keydown",
+      "touchstart",
+      "scroll"
+    ];
+    interactionEvents.forEach(
+      (evt) => window.addEventListener(evt, go, { once: true, passive: true })
+    );
+    if (document.readyState === "complete") {
+      scheduleIdle();
+    } else {
+      window.addEventListener("load", scheduleIdle, { once: true });
+    }
+    return () => {
+      window.removeEventListener("load", scheduleIdle);
+      interactionEvents.forEach((evt) => window.removeEventListener(evt, go));
+      if (idleId != null && typeof w.cancelIdleCallback === "function") {
+        w.cancelIdleCallback(idleId);
+      }
+      if (timeoutId != null) clearTimeout(timeoutId);
+    };
+  }, [enabled, ready, idleTimeout]);
+  return ready;
+}
+
+export { useDeferredActivation };

package/dist/chunk-YGGDU6C3.js

@@ -0,0 +1,93 @@
+'use client';
+import { useEffect } from 'react';
+import { jsxs, jsx } from 'react/jsx-runtime';
+
+// src/forms/FormCelebration.tsx
+var STYLE_ID = "sk-celebration-css";
+var CSS = `
+@keyframes sk-cel-pop { 0% { transform: scale(.4); opacity: 0 } 70% { transform: scale(1.08) } 100% { transform: scale(1); opacity: 1 } }
+@keyframes sk-cel-draw { to { stroke-dashoffset: 0 } }
+@keyframes sk-cel-rise { from { transform: translateY(10px); opacity: 0 } to { transform: translateY(0); opacity: 1 } }
+@keyframes sk-cel-burst {
+  0% { transform: rotate(var(--sk-cel-a)) translateY(0) scale(1); opacity: 0 }
+  12% { opacity: 1 }
+  100% { transform: rotate(var(--sk-cel-a)) translateY(calc(var(--sk-cel-d) * -1)) scale(.2); opacity: 0 }
+}
+.sk-cel { text-align: center; padding: 1.5rem 0; }
+.sk-cel-stage { position: relative; width: 92px; height: 92px; margin: 0 auto 1.1rem; }
+/* Disc/particles mix toward currentColor so they stay visible on sections
+   painted with the brand color itself (same contrast guarantee as delight.tsx). */
+.sk-cel-disc {
+  width: 92px; height: 92px; border-radius: 50%;
+  background: color-mix(in srgb, var(--sk-primary, #2563eb) 72%, currentColor);
+  display: flex; align-items: center; justify-content: center;
+  animation: sk-cel-pop .45s cubic-bezier(.22,1.4,.36,1) both;
+}
+.sk-cel-check { stroke-dasharray: 26; stroke-dashoffset: 26; animation: sk-cel-draw .35s ease-out .28s forwards; }
+.sk-cel-p {
+  position: absolute; top: 50%; left: 50%; width: 7px; height: 7px; margin: -3.5px;
+  border-radius: 50%; background: color-mix(in srgb, var(--sk-primary, #2563eb) 72%, currentColor); opacity: 0; pointer-events: none;
+  animation: sk-cel-burst .7s ease-out .3s both;
+}
+.sk-cel-p:nth-child(even) { width: 5px; height: 5px; border-radius: 1px; background: color-mix(in srgb, var(--sk-primary, #2563eb) 40%, currentColor); }
+.sk-cel-msg { animation: sk-cel-rise .4s ease-out .35s both; font-size: 1.15rem; line-height: 1.6; }
+@media (prefers-reduced-motion: reduce) {
+  .sk-cel-disc, .sk-cel-msg { animation: none }
+  .sk-cel-check { animation: none; stroke-dashoffset: 0 }
+  .sk-cel-p { display: none }
+}
+`;
+var PARTICLES = Array.from({ length: 12 }, (_, i) => ({
+  angle: i * 30,
+  distance: 46 + i % 3 * 14
+}));
+function FormCelebration({ message, className }) {
+  useEffect(() => {
+    try {
+      if (!window.matchMedia("(prefers-reduced-motion: reduce)").matches) {
+        navigator.vibrate?.(15);
+      }
+    } catch {
+    }
+  }, []);
+  return /* @__PURE__ */ jsxs("div", { className, "data-sk-part": "celebration", children: [
+    /* @__PURE__ */ jsx("style", { id: STYLE_ID, dangerouslySetInnerHTML: { __html: CSS } }),
+    /* @__PURE__ */ jsxs("div", { className: "sk-cel", children: [
+      /* @__PURE__ */ jsxs("div", { className: "sk-cel-stage", "aria-hidden": "true", "data-sk-part": "celebration-stage", children: [
+        PARTICLES.map((p, i) => /* @__PURE__ */ jsx(
+          "span",
+          {
+            className: "sk-cel-p",
+            "data-sk-part": "celebration-particle",
+            style: { ["--sk-cel-a"]: `${p.angle}deg`, ["--sk-cel-d"]: `${p.distance}px` }
+          },
+          i
+        )),
+        /* @__PURE__ */ jsx("div", { className: "sk-cel-disc", "data-sk-part": "celebration-disc", children: /* @__PURE__ */ jsx("svg", { width: "44", height: "44", viewBox: "0 0 24 24", fill: "none", children: /* @__PURE__ */ jsx(
+          "path",
+          {
+            className: "sk-cel-check",
+            d: "M5 12.5l4.2 4.3L19 7",
+            stroke: "var(--sk-form-success-check, #fff)",
+            strokeWidth: "2.6",
+            strokeLinecap: "round",
+            strokeLinejoin: "round"
+          }
+        ) }) })
+      ] }),
+      /* @__PURE__ */ jsx(
+        "p",
+        {
+          className: "sk-cel-msg",
+          "data-sk-part": "celebration-message",
+          role: "status",
+          "aria-live": "polite",
+          style: { margin: 0, color: "var(--sk-form-success-text, inherit)" },
+          children: message
+        }
+      )
+    ] })
+  ] });
+}
+
+export { FormCelebration };

package/dist/chunk-YVKRYQRG.js

@@ -0,0 +1,70 @@
+// src/sitemap/shared.ts
+function inferPageType(urlPath) {
+  if (urlPath === "/" || urlPath === "") return "homepage";
+  if (/^\/services(\/|$)/i.test(urlPath)) return "service";
+  if (/^\/compare(\/|$)/i.test(urlPath)) return "comparison";
+  if (/^\/(insights|article)(\/|$)/i.test(urlPath)) return "article";
+  if (/^\/industries(\/|$)/i.test(urlPath)) return "industry";
+  if (/^\/work(\/|$)/i.test(urlPath)) return "portfolio";
+  if (/^\/faq(\/|$)/i.test(urlPath)) return "faq";
+  if (/^\/pricing(\/|$)/i.test(urlPath)) return "pricing";
+  return "page";
+}
+function stripTrailingSlash(path) {
+  if (path !== "/" && path.endsWith("/")) {
+    return path.slice(0, -1);
+  }
+  return path;
+}
+function applyTrailingSlash(path, trailingSlash) {
+  const cut = path.search(/[?#]/);
+  const pathname = cut === -1 ? path : path.slice(0, cut);
+  const suffix = cut === -1 ? "" : path.slice(cut);
+  return shapePathname(pathname, trailingSlash) + suffix;
+}
+function shapePathname(pathname, trailingSlash) {
+  if (pathname === "" || pathname === "/") return pathname;
+  if (/^\/\.well-known(\/|$)/.test(pathname)) return pathname;
+  const bare = stripTrailingSlash(pathname);
+  if (!trailingSlash) return bare;
+  const lastSegment = bare.slice(bare.lastIndexOf("/") + 1);
+  return lastSegment.includes(".") ? bare : `${bare}/`;
+}
+function nextTrailingSlash() {
+  let value;
+  try {
+    value = process.env.__NEXT_TRAILING_SLASH;
+  } catch {
+    return void 0;
+  }
+  if (value === true || value === "true") return true;
+  if (value === false || value === "false") return false;
+  return void 0;
+}
+function resolveTrailingSlash(explicit) {
+  return explicit ?? nextTrailingSlash() ?? false;
+}
+function locToPath(loc) {
+  let path;
+  try {
+    path = new URL(loc).pathname;
+  } catch {
+    path = loc.startsWith("/") ? loc : `/${loc}`;
+  }
+  return stripTrailingSlash(path);
+}
+var EMBEDDED_DOMAIN_PREFIX = /^\/{1,2}[a-z0-9.-]+\.[a-z]{2,}(\/|$)/i;
+var EMBEDDED_DOMAIN_ANYWHERE = /\/\/[a-z0-9.-]+\.[a-z]{2,}/i;
+function stripEmbeddedDomain(path) {
+  return path.replace(EMBEDDED_DOMAIN_PREFIX, "/");
+}
+function isMalformedSitemapPath(path) {
+  return path.includes("://") || EMBEDDED_DOMAIN_ANYWHERE.test(path);
+}
+var LLMS_WRITE_ROUTE_BUDGET_MS = 5e4;
+function llmsWriteTimeoutMs(configured, routeStartedAt, now = Date.now()) {
+  if (configured != null) return configured;
+  return LLMS_WRITE_ROUTE_BUDGET_MS - (now - routeStartedAt);
+}
+
+export { applyTrailingSlash, inferPageType, isMalformedSitemapPath, llmsWriteTimeoutMs, locToPath, resolveTrailingSlash, stripEmbeddedDomain, stripTrailingSlash };