@postedin/cms-client 0.1.0

package/dist/index.js

@@ -0,0 +1,1636 @@
+import {
+  defineCmsToHref,
+  defineLocales,
+  defineRoutes
+} from "./chunk-6V54ITTK.js";
+import {
+  MAX_REQUEST_BYTES,
+  MAX_UPLOAD_BYTES
+} from "./chunk-MNZ7DIGC.js";
+
+// src/api.ts
+import { stringify } from "qs-esm";
+
+// src/placeholder.ts
+function getRandomPlaceholderUrl(width = 600, height = 400) {
+  const pastelColors = ["ebfaf5", "c3c8cd", "faf0e6", "f5f5eb", "f0ebfa"];
+  const randomIndex = Math.floor(Math.random() * pastelColors.length);
+  const randomColor = pastelColors[randomIndex];
+  return `https://placehold.co/${width}x${height}/${randomColor}/${randomColor}`;
+}
+
+// src/api.ts
+var CMS_API_KEY_COLLECTION = "api-keys";
+var DEPTH = 2;
+var LIMIT = 1e3;
+var PAGE_CONCURRENCY = 4;
+async function mapWithConcurrency(items, limit, worker) {
+  const results = new Array(items.length);
+  let next = 0;
+  const runner = async () => {
+    while (next < items.length) {
+      const index = next++;
+      results[index] = await worker(items[index], index);
+    }
+  };
+  await Promise.all(
+    Array.from({ length: Math.min(limit, items.length) }, runner)
+  );
+  return results;
+}
+function applyLocale(query, locale, fallback) {
+  if (!locale) {
+    return query;
+  }
+  query.locale = locale;
+  if (fallback === "null") {
+    query["fallback-locale"] = "null";
+  }
+  return query;
+}
+function createApi(options) {
+  const pageConcurrency = options.pageConcurrency ?? PAGE_CONCURRENCY;
+  function buildHeaders() {
+    const headers = {
+      Authorization: `${CMS_API_KEY_COLLECTION} API-Key ${options.apiKey}`
+    };
+    if (options.protectionBypassSecret) {
+      headers["x-vercel-protection-bypass"] = options.protectionBypassSecret;
+    }
+    return headers;
+  }
+  function apiUrl(url, query = {}, scoped = true) {
+    if (scoped) {
+      query.where = {
+        and: [
+          { "project.slug": { equals: options.projectSlug } },
+          ...query.where ? [query.where] : []
+        ]
+      };
+    }
+    return options.apiUrl + url + stringify(query, { addQueryPrefix: true });
+  }
+  function getUploadsPublicUrl(endpoint) {
+    return `${options.uploadsBaseUrl}/${endpoint}`;
+  }
+  const hasUploadsBucket = !!options.uploadsBaseUrl;
+  function siteUploadUrl(media, use) {
+    return options.resolveUploadUrl?.(media, use) ?? void 0;
+  }
+  function fileUrl(media) {
+    if (!media) {
+      return null;
+    }
+    if (options.isDev) {
+      return media.url ?? null;
+    }
+    const own = siteUploadUrl(media, "file");
+    if (own !== void 0) {
+      return own;
+    }
+    if (hasUploadsBucket && media.filename) {
+      return getUploadsPublicUrl(media.filename);
+    }
+    return media.url ?? null;
+  }
+  function imageUrl(media) {
+    if (!media) {
+      return getRandomPlaceholderUrl();
+    }
+    if (options.isDev) {
+      return media.url ?? getRandomPlaceholderUrl();
+    }
+    const own = siteUploadUrl(media, "image");
+    if (own !== void 0) {
+      return own ?? getRandomPlaceholderUrl();
+    }
+    if (hasUploadsBucket && media.filename) {
+      return getUploadsPublicUrl(media.filename);
+    }
+    return media.url || getRandomPlaceholderUrl();
+  }
+  async function fetchCmsFile(url) {
+    return await fetch(new URL(url, options.apiUrl), {
+      headers: buildHeaders()
+    });
+  }
+  async function fetchCmsGlobal(global, fetchOptions = {}) {
+    const query = fetchOptions.query || {};
+    const depth = fetchOptions.depth ?? DEPTH;
+    applyLocale(query, fetchOptions.locale, fetchOptions.fallback ?? "null");
+    const res = await fetch(
+      apiUrl(`/api/globals/${global}`, { depth, ...query }),
+      { headers: buildHeaders() }
+    );
+    return await res.json();
+  }
+  async function fetchCmsGlobalCollection(collection, fetchOptions = {}) {
+    const query = fetchOptions.query || {};
+    const depth = fetchOptions.depth ?? DEPTH;
+    applyLocale(query, fetchOptions.locale, fetchOptions.fallback ?? "null");
+    const res = await fetch(apiUrl(`/api/${collection}`, { depth, ...query }), {
+      headers: buildHeaders()
+    });
+    if (!res.ok) {
+      const url = apiUrl(`/api/${collection}`, { depth, ...query });
+      const text = await res.text();
+      let error;
+      try {
+        const json = JSON.parse(text);
+        error = `${res.status} (${url})j: ${json.message || JSON.stringify(json)}`;
+      } catch {
+        error = `${res.status} (${url})t: ${text}`;
+      }
+      throw new Error(error);
+    }
+    const docs = (await res.json()).docs;
+    if (!docs.length) {
+      throw new Error(
+        `Failed to load global collection "${collection}", no docs found.`
+      );
+    }
+    return docs[0];
+  }
+  async function fetchCmsCollection(collection, fetchOptions = {}) {
+    const query = fetchOptions.query || {};
+    const depth = fetchOptions.depth ?? DEPTH;
+    const limit = fetchOptions.limit || LIMIT;
+    const sort = fetchOptions.sort || "-createdAt";
+    const fields = query.fields || {};
+    if (fetchOptions.status) {
+      query.where = query?.where || {};
+      query.where._status = { equals: fetchOptions.status };
+    }
+    applyLocale(query, fetchOptions.locale, fetchOptions.fallback ?? "null");
+    const fetchPage = async (page = 1) => {
+      const res = await fetch(
+        apiUrl(`/api/${collection}`, {
+          depth,
+          limit,
+          sort,
+          fields,
+          ...query,
+          page
+        }),
+        { headers: buildHeaders() }
+      );
+      if (!res.ok) {
+        const errorText = await res.text();
+        throw new Error(
+          `CMS API request failed for ${collection} (page ${page})
+Status: ${res.status} ${res.statusText}
+Details: ${errorText.substring(0, 500)}${errorText.length > 500 ? "..." : ""}`
+        );
+      }
+      return await res.json();
+    };
+    const firstPage = await fetchPage();
+    let otherPagesData = [];
+    if (firstPage.totalPages > 1) {
+      const otherPages = Array.from(
+        { length: firstPage.totalPages - 1 },
+        (_, i) => i + 2
+      );
+      otherPagesData = await mapWithConcurrency(
+        otherPages,
+        pageConcurrency,
+        async (p) => (await fetchPage(p)).docs
+      );
+    }
+    return firstPage.docs.concat(otherPagesData.flat());
+  }
+  async function fetchCmsProject() {
+    const slug = options.projectSlug;
+    const res = await fetch(
+      apiUrl(
+        "/api/projects",
+        { limit: 1, where: { slug: { equals: slug } } },
+        false
+      ),
+      { headers: buildHeaders() }
+    );
+    if (!res.ok) {
+      const errorText = await res.text();
+      throw new Error(
+        `CMS API request failed for ProjectBySlug
+Status: ${res.status} ${res.statusText}
+Details: ${errorText.substring(0, 500)}${errorText.length > 500 ? "..." : ""}`
+      );
+    }
+    const docs = (await res.json()).docs;
+    if (!docs) {
+      throw new Error(
+        `CMS API request failed for ProjectBySlug
+Status: ${res.status} ${res.statusText}
+Details: failed to find project by slug "${slug}"`
+      );
+    }
+    return docs[0];
+  }
+  return {
+    apiUrl,
+    buildHeaders,
+    getUploadsPublicUrl,
+    fileUrl,
+    imageUrl,
+    fetchCmsFile,
+    fetchCmsGlobal,
+    fetchCmsGlobalCollection,
+    fetchCmsCollection,
+    fetchCmsProject
+  };
+}
+
+// src/blog-listing.ts
+var EMPTY = { name: null, description: null };
+async function fetchBlogListing(ctx, locale) {
+  const options = await ctx.cms(locale).options();
+  const configured = options.blog?.page;
+  const id = typeof configured === "string" ? configured : configured?.id ?? null;
+  if (!id) {
+    return EMPTY;
+  }
+  const [doc] = await ctx.api.fetchCmsCollection("pages", {
+    locale,
+    fallback: "default",
+    status: "published",
+    limit: 1,
+    query: { where: { id: { equals: id } } }
+  });
+  if (!doc) {
+    return EMPTY;
+  }
+  return {
+    name: doc.listingName || null,
+    description: doc.listingDescription ?? null
+  };
+}
+function createBlogListing(ctx) {
+  const cache = /* @__PURE__ */ new Map();
+  return function getBlogListing(locale) {
+    let pending = cache.get(locale);
+    if (!pending) {
+      pending = fetchBlogListing(ctx, locale);
+      cache.set(locale, pending);
+    }
+    return pending;
+  };
+}
+
+// src/loader.ts
+function createGlobalLoader(fetchFn, options) {
+  let cache;
+  return async () => {
+    if (!cache) {
+      cache = fetchFn().then(async (data) => {
+        if (options?.transform) {
+          return await options.transform(data);
+        }
+        return data;
+      });
+    }
+    return await cache;
+  };
+}
+function createCollectionLoader(fetchFn, options) {
+  let cache;
+  const load = async () => {
+    if (!cache) {
+      cache = fetchFn().then(async (data) => {
+        if (options?.transform) {
+          return await options.transform(data);
+        }
+        return data;
+      });
+    }
+    return await cache;
+  };
+  return Object.assign(load, {
+    page: async (page, limit, options2 = { excluded: [] }) => {
+      const data = (await load()).filter((doc) => {
+        if (!options2.excluded.length) {
+          return true;
+        }
+        return !options2.excluded.find((ex) => ex.id === doc.id);
+      });
+      const first = (page - 1) * limit;
+      const last = first + limit;
+      return data.slice(first, last);
+    },
+    find: async (predicate) => {
+      return (await load()).find(predicate);
+    },
+    filter: async (predicate) => {
+      return (await load()).filter(predicate);
+    }
+  });
+}
+
+// src/collections/appearance.ts
+var DEFAULT_APPEARANCE_FALLBACKS = {
+  // The theme ramp's 500.
+  brandColor: "var(--color-theme-500)",
+  backgroundColor: {
+    lightTheme: "var(--site-background-light)",
+    darkTheme: "var(--site-background-dark)"
+  }
+};
+function removeInvalid(obj) {
+  if (obj === null || obj === void 0) {
+    return {};
+  }
+  const cleaned = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (value !== null && value !== void 0 && value !== "") {
+      cleaned[key] = value;
+    }
+  }
+  return cleaned;
+}
+function appearance_default(ctx) {
+  return createGlobalLoader(
+    async () => {
+      if (!ctx.options.appearance) {
+        throw new Error(
+          "cms.appearance() needs the `appearance` option of createClient: the Appearance document fetched at config time."
+        );
+      }
+      return ctx.options.appearance;
+    },
+    {
+      transform: (appearance) => {
+        const fallbacks = ctx.options.appearanceFallbacks ?? DEFAULT_APPEARANCE_FALLBACKS;
+        return {
+          ...appearance,
+          branding: {
+            ...appearance.branding,
+            brandColor: appearance.branding?.brandColor || fallbacks.brandColor,
+            logo: {
+              type: appearance.branding?.logo?.type,
+              dark: appearance.branding?.logo?.dark,
+              darkSvg: appearance.branding?.logo?.darkSvg,
+              light: appearance.branding?.logo?.light,
+              lightSvg: appearance.branding?.logo?.lightSvg
+            },
+            icon: appearance.branding?.icon
+          },
+          backgroundColor: {
+            ...fallbacks.backgroundColor,
+            ...removeInvalid(appearance.backgroundColor)
+          }
+        };
+      }
+    }
+  );
+}
+
+// src/collections/areas.ts
+function areas_default(ctx, locale) {
+  const areas = createCollectionLoader(
+    () => ctx.api.fetchCmsCollection("areas", {
+      sort: "_order",
+      locale
+    }),
+    {
+      transform: (areas2) => areas2.map((area) => ({
+        ...area,
+        page: typeof area.page === "object" ? area.page : null
+      }))
+    }
+  );
+  return {
+    all: areas
+  };
+}
+
+// src/collections/authors.ts
+function authors_default(ctx, locale) {
+  const authors = createCollectionLoader(
+    async () => ctx.api.fetchCmsCollection("authors", { locale }),
+    {
+      transform: (authors2) => {
+        const validAuthors = authors2.filter((author) => author.slug);
+        return validAuthors;
+      }
+    }
+  );
+  return {
+    all: authors,
+    findBySlug: async (slug) => {
+      return authors.find((author) => author.slug === slug);
+    }
+  };
+}
+
+// src/collections/banners.ts
+function banners_default(ctx, locale) {
+  const banners = createCollectionLoader(
+    async () => ctx.api.fetchCmsCollection("banners", { locale })
+  );
+  return {
+    all: banners
+  };
+}
+
+// src/decode-html.ts
+function decodeHtml(str) {
+  return str.replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'");
+}
+
+// src/collections/categories.ts
+function getCategoryPath(category) {
+  if (!category.parent) {
+    return category.slug;
+  }
+  return `${getCategoryPath(category.parent)}/${category.slug}`;
+}
+function getCategoryBreadcrumbs(category, locale, prefixPath) {
+  const ancestors = category.parent ? getCategoryBreadcrumbs(category.parent, locale, prefixPath) : [];
+  const path = getCategoryPath(category);
+  return [
+    ...ancestors,
+    {
+      label: category.title,
+      url: prefixPath(`/blog/category/${path}`, locale)
+    }
+  ];
+}
+function categories_default(ctx, locale) {
+  const categories = createCollectionLoader(
+    async () => ctx.api.fetchCmsCollection("categories", { locale }),
+    {
+      transform: (categories2) => {
+        const catMap = new Map(
+          categories2.filter((category) => category.slug).map((category) => [
+            category.id,
+            {
+              ...category,
+              title: decodeHtml(category.title),
+              children: [],
+              path: category.slug,
+              breadcrumbs: []
+            }
+          ])
+        );
+        const wireRelationships = (category) => {
+          if (typeof category.parent === "string") {
+            const parent = catMap.get(category.parent);
+            if (parent) {
+              category.parent = parent;
+              parent.children.push(category);
+            }
+          }
+        };
+        catMap.forEach((category) => wireRelationships(category));
+        catMap.forEach((category) => {
+          category.path = getCategoryPath(category);
+          category.breadcrumbs = getCategoryBreadcrumbs(
+            category,
+            locale,
+            ctx.locales.prefixPath
+          );
+        });
+        return Array.from(catMap.values());
+      }
+    }
+  );
+  return {
+    all: categories,
+    wire: async (category) => {
+      if (!category) {
+        return null;
+      }
+      const id = typeof category === "string" ? category : category.id;
+      return (await categories()).find((cat) => cat.id === id);
+    }
+  };
+}
+
+// src/collections/forms.ts
+function forms_default(ctx, locale) {
+  const forms = createCollectionLoader(
+    () => ctx.api.fetchCmsCollection("forms", { locale, fallback: "default" })
+  );
+  const findById = async (id) => await forms.find((form) => form.id === id) ?? null;
+  return {
+    all: forms,
+    findById,
+    // Swaps a form reference coming from a block for its localized document
+    resolve: async (form) => {
+      if (typeof form === "string") {
+        return await findById(form);
+      }
+      return await findById(form.id) ?? form;
+    }
+  };
+}
+
+// src/collections/header-footer.ts
+function header_footer_default(ctx, locale) {
+  return createGlobalLoader(
+    async () => ctx.api.fetchCmsGlobalCollection("header-footer", { locale })
+  );
+}
+
+// src/collections/image-links.ts
+function image_links_default(ctx, locale) {
+  const imageLinks = createCollectionLoader(
+    async () => ctx.api.fetchCmsCollection("image-links", { locale })
+  );
+  return {
+    all: imageLinks
+  };
+}
+
+// src/collections/media.ts
+function media_default(ctx, locale) {
+  const media = createCollectionLoader(
+    async () => ctx.api.fetchCmsCollection("media", { locale, depth: 0 })
+  );
+  return {
+    all: media
+  };
+}
+
+// src/collections/options.ts
+function options_default(ctx, locale) {
+  return createGlobalLoader(
+    async () => ctx.api.fetchCmsGlobalCollection("options", { locale })
+  );
+}
+
+// src/collections/pages.ts
+function pages_default(ctx, locale) {
+  const pages = createCollectionLoader(
+    async () => ctx.api.fetchCmsCollection("pages", {
+      status: "published",
+      locale
+    }),
+    {
+      transform: (rawPages) => {
+        const pageMap = new Map(
+          rawPages.filter((page) => page.slug).map((page) => {
+            const path = (page.breadcrumbs?.at(-1)?.url ?? page.slug).replace(
+              /^\//,
+              ""
+            );
+            return [page.id, { ...page, children: [], path }];
+          })
+        );
+        pageMap.forEach((page) => {
+          const rawParent = page.parent;
+          const parentId = typeof rawParent === "string" ? rawParent : rawParent?.id;
+          if (parentId) {
+            const parent = pageMap.get(parentId);
+            if (parent) {
+              page.parent = parent;
+              parent.children.push(page);
+            } else {
+              page.parent = void 0;
+            }
+          }
+        });
+        pageMap.forEach((page) => {
+          page.children.sort((a, b) => {
+            if (a.order == null && b.order == null) {
+              return 0;
+            }
+            if (a.order == null) {
+              return 1;
+            }
+            if (b.order == null) {
+              return -1;
+            }
+            return a.order - b.order;
+          });
+        });
+        return Array.from(pageMap.values());
+      }
+    }
+  );
+  return {
+    all: pages,
+    findByPath: async (path) => (await pages()).find((p) => p.path === path),
+    findById: async (id) => (await pages()).find((p) => p.id === id) ?? null
+  };
+}
+
+// src/collections/posts.ts
+import { TfIdf } from "natural/lib/natural/tfidf/index.js";
+async function wirePost(ctx, post, locale, tags = []) {
+  if (!post) {
+    return void 0;
+  }
+  let coverImage = post.coverImage;
+  if (typeof coverImage === "string") {
+    coverImage = void 0;
+  }
+  const postTags = post.tags?.map(
+    (tag) => typeof tag === "string" ? tags.find((t) => t.id === tag) : tag
+  ).filter((tag) => tag !== void 0);
+  const cms = ctx.cms(locale);
+  const secondaryCategories = (await Promise.all(
+    (post.secondaryCategories ?? []).map(
+      (c) => cms.categories.wire(c)
+    )
+  )).filter((c) => c != null);
+  const category = await cms.categories.wire(post.category);
+  const categoryTitles = [category, ...secondaryCategories].filter((c) => c != null).map((c) => c.title);
+  return {
+    ...post,
+    category,
+    secondaryCategories,
+    coverImage,
+    tags: postTags,
+    searchTokens: `${post.title} ${categoryTitles.join(" ")}`
+  };
+}
+function collectCustomTeamMemberIds(post) {
+  const ids = [];
+  for (const block of post.contentBlocks ?? []) {
+    if (block.blockType !== "team-member") {
+      continue;
+    }
+    if (block.filter !== "custom") {
+      continue;
+    }
+    for (const m of block.members ?? []) {
+      const id = typeof m === "string" ? m : m?.id;
+      if (id) {
+        ids.push(id);
+      }
+    }
+  }
+  return ids;
+}
+function posts_default(ctx, locale) {
+  const tfIdf = new TfIdf();
+  const keyedPosts = {};
+  let teamMemberIndex = null;
+  const posts = createCollectionLoader(
+    async () => ctx.api.fetchCmsCollection("posts", {
+      status: "published",
+      sort: "-publishDate",
+      locale
+    }) || [],
+    {
+      transform: async (posts2) => {
+        const cms = ctx.cms(locale);
+        const tags = await cms.tags.all();
+        const wiredPosts = await Promise.all(
+          posts2?.filter((post) => post.slug).map(async (post) => {
+            return wirePost(ctx, post, locale, tags);
+          }) || []
+        );
+        const currentYear = (/* @__PURE__ */ new Date()).getFullYear();
+        wiredPosts.forEach((post) => {
+          if (post.publishDate && (new Date(post.publishDate).getFullYear() > currentYear - 4 || tfIdf.documents.length < 200)) {
+            tfIdf.addDocument(post.searchTokens, post.id);
+            keyedPosts[post.id] = post;
+          }
+        });
+        return wiredPosts;
+      }
+    }
+  );
+  return {
+    all: posts,
+    exists: async () => !!(await posts()).length,
+    page: async (...args) => {
+      return posts.page(...args);
+    },
+    latest: async () => {
+      return posts.page(1, 6);
+    },
+    featured: async () => {
+      return (await posts()).filter((post) => post.featured).slice(0, 10);
+    },
+    // TF-IDF similarity over title + category titles. When similarity
+    // yields fewer than `limit` posts, pad with the latest posts from the
+    // same category (newest first, secondary categories count too).
+    related: async (post, limit = 6) => {
+      const scores = [];
+      tfIdf.tfidfs(post.searchTokens, (_, score, postId) => {
+        scores.push({
+          postId,
+          score
+        });
+      });
+      const similar = scores.filter((entry) => entry.postId !== post.id && entry.score > 0).sort((a, b) => b.score - a.score).slice(0, limit).map((entry) => keyedPosts[entry.postId]);
+      if (similar.length >= limit) {
+        return similar;
+      }
+      const categoryId = post.category?.id;
+      const seen = new Set(similar.map((p) => p.id));
+      const fromCategory = await posts.filter(
+        (p) => p.id !== post.id && !seen.has(p.id) && (!categoryId || p.category?.id === categoryId || (p.secondaryCategories ?? []).some(
+          (c) => c.id === categoryId
+        ))
+      );
+      return [...similar, ...fromCategory.slice(0, limit - similar.length)];
+    },
+    findBySlug: async (slug) => {
+      return posts.find((post) => post.slug === slug);
+    },
+    findByAuthor: async (author) => {
+      return posts.filter((post) => post.author?.id === author.id);
+    },
+    findByTeamMember: async (memberId) => {
+      if (!teamMemberIndex) {
+        teamMemberIndex = (async () => {
+          const all = await posts();
+          const index = /* @__PURE__ */ new Map();
+          for (const post of all) {
+            for (const id of collectCustomTeamMemberIds(post)) {
+              const list = index.get(id);
+              if (list) {
+                list.push(post);
+              } else {
+                index.set(id, [post]);
+              }
+            }
+          }
+          for (const list of index.values()) {
+            list.sort(
+              (a, b) => new Date(b.publishDate ?? 0).getTime() - new Date(a.publishDate ?? 0).getTime()
+            );
+          }
+          return index;
+        })();
+      }
+      return (await teamMemberIndex).get(memberId) ?? [];
+    },
+    findByCategory: async (category) => {
+      return posts.filter(
+        (post) => post.category === category.id || post.category?.id === category.id || (post.secondaryCategories ?? []).some(
+          (c) => c.id === category.id
+        )
+      );
+    },
+    findByTag: async (tag) => {
+      return posts.filter((post) => {
+        return post.tags?.some((postTag) => postTag.id === tag.id);
+      });
+    },
+    nextInCategory: async (post) => {
+      if (!post.category) {
+        return void 0;
+      }
+      const allCategoryIds = /* @__PURE__ */ new Set([
+        post.category.id,
+        ...(post.secondaryCategories ?? []).map((c) => c.id)
+      ]);
+      const categoryPosts = await posts.filter(
+        (p) => allCategoryIds.has(p.category?.id ?? "") || (p.secondaryCategories ?? []).some(
+          (c) => allCategoryIds.has(c.id)
+        )
+      );
+      const idx = categoryPosts.findIndex((p) => p.id === post.id);
+      return idx >= 0 && idx + 1 < categoryPosts.length ? categoryPosts[idx + 1] : void 0;
+    }
+  };
+}
+
+// src/collections/project.ts
+function project_default(ctx) {
+  return createGlobalLoader(async () => {
+    if (!ctx.options.project) {
+      throw new Error(
+        "cms.project() needs the `project` option of createClient: the Project document fetched at config time."
+      );
+    }
+    return ctx.options.project;
+  });
+}
+
+// src/collections/questions.ts
+function questions_default(ctx, locale) {
+  const questions = createCollectionLoader(
+    async () => ctx.api.fetchCmsCollection("questions", {
+      locale,
+      sort: "_questions_questions_order"
+    }),
+    {
+      transform: (questions2) => {
+        const validQuestions = questions2.filter((question) => question.tags);
+        return validQuestions;
+      }
+    }
+  );
+  return {
+    all: questions,
+    filterByTag: async (searchTag) => {
+      return questions.filter(
+        (question) => question.tags.some((tag) => {
+          return tag.id === searchTag.id;
+        })
+      );
+    }
+  };
+}
+
+// src/collections/seo.ts
+function seo_default(ctx, locale) {
+  return createGlobalLoader(
+    async () => ctx.api.fetchCmsGlobalCollection("seo", { locale })
+  );
+}
+
+// src/collections/tags.ts
+function tags_default(ctx, locale) {
+  const tags = createCollectionLoader(
+    async () => ctx.api.fetchCmsCollection("tags", { locale }),
+    {
+      transform: (tags2) => {
+        const validTags = tags2.filter((tag) => tag.slug);
+        return validTags;
+      }
+    }
+  );
+  return {
+    all: tags,
+    findBySlug: async (slug) => {
+      return tags.find((tag) => tag.slug === slug);
+    }
+  };
+}
+
+// src/collections/team-members.ts
+function team_members_default(ctx, locale) {
+  const members = createCollectionLoader(
+    async () => ctx.api.fetchCmsCollection("team-members", {
+      sort: "_order",
+      locale
+    }),
+    {
+      transform: async (members2) => {
+        const allAreas = await ctx.cms(locale).areas.all();
+        const areaById = new Map(allAreas.map((a) => [a.id, a]));
+        return members2.filter((m) => m.slug).map((m) => {
+          const docs = [];
+          for (const row of m.memberAreas ?? []) {
+            const ref = row.area;
+            const id = typeof ref === "string" ? ref : ref.id;
+            const hit = areaById.get(id);
+            if (hit) {
+              docs.push(hit);
+            } else if (typeof ref === "string") {
+              docs.push(ref);
+            } else {
+              docs.push({
+                ...ref,
+                page: typeof ref.page === "object" ? ref.page : null
+              });
+            }
+          }
+          return {
+            ...m,
+            areas: {
+              docs,
+              hasNextPage: false,
+              totalDocs: docs.length
+            }
+          };
+        });
+      }
+    }
+  );
+  const memberTypes = createCollectionLoader(
+    () => ctx.api.fetchCmsCollection("member-types", {
+      sort: "_order",
+      locale
+    })
+  );
+  return {
+    all: members,
+    types: memberTypes,
+    findBySlug: async (slug) => {
+      return members.find((m) => m.slug === slug);
+    }
+  };
+}
+
+// src/cms.ts
+function buildCms(ctx, locale) {
+  const categoriesService = categories_default(ctx, locale);
+  const postsService = posts_default(ctx, locale);
+  return {
+    locale,
+    areas: areas_default(ctx, locale),
+    authors: authors_default(ctx, locale),
+    banners: banners_default(ctx, locale),
+    appearance: appearance_default(ctx),
+    imageLinks: image_links_default(ctx, locale),
+    categories: {
+      ...categoriesService,
+      populated: async () => {
+        const cats = await categoriesService.all();
+        const allPosts = await postsService.all();
+        const ids = /* @__PURE__ */ new Set([
+          ...allPosts.map((p) => p.category?.id).filter(Boolean),
+          ...allPosts.flatMap(
+            (p) => (p.secondaryCategories ?? []).map((c) => c.id)
+          )
+        ]);
+        return cats.filter((c) => ids.has(c.id));
+      },
+      // Categories that hold posts, each with how many. `populated()`
+      // answers only whether that number is non-zero and has five callers
+      // depending on its shape, so this is a second reading of the same
+      // fold rather than a change to it. Both collections are already
+      // cached, so it costs no extra fetch.
+      withCounts: async () => {
+        const cats = await categoriesService.all();
+        const allPosts = await postsService.all();
+        const counts = /* @__PURE__ */ new Map();
+        for (const post of allPosts) {
+          const ids = new Set(
+            [
+              post.category?.id,
+              ...(post.secondaryCategories ?? []).map((c) => c.id)
+            ].filter((id) => !!id)
+          );
+          for (const id of ids) {
+            counts.set(id, (counts.get(id) ?? 0) + 1);
+          }
+        }
+        return cats.map((c) => ({ ...c, postCount: counts.get(c.id) ?? 0 })).filter((c) => c.postCount > 0);
+      }
+    },
+    forms: forms_default(ctx, locale),
+    headerFooter: header_footer_default(ctx, locale),
+    media: media_default(ctx, locale),
+    options: options_default(ctx, locale),
+    pages: pages_default(ctx, locale),
+    posts: postsService,
+    project: project_default(ctx),
+    questions: questions_default(ctx, locale),
+    seo: seo_default(ctx, locale),
+    tags: tags_default(ctx, locale),
+    teamMembers: team_members_default(ctx, locale)
+  };
+}
+
+// src/config-time.ts
+function createRedirect(routes, from, to) {
+  if (!to) {
+    return;
+  }
+  if (to.type === "custom") {
+    if (!to.url) {
+      return;
+    }
+    return { [from]: to.url };
+  } else if (!to.reference) {
+    return;
+  } else if (typeof to.reference.value === "string") {
+    return;
+  }
+  switch (to.reference.relationTo) {
+    // NOTE: astro doesn't support external redirects so if this is that then it won't work
+    case "pages":
+      return to.reference.value.slug ? { [from]: routes.page(to.reference.value.slug) } : void 0;
+    case "categories":
+      return to.reference.value.slug ? { [from]: routes.blog("category", to.reference.value.slug) } : void 0;
+    default:
+      return;
+  }
+}
+function createConfigTime(api, defaultRoutes) {
+  return {
+    /** The three documents the Astro config and `createClient` need. */
+    async fetchProjectSettings() {
+      const [project, appearance, options] = await Promise.all([
+        api.fetchCmsProject(),
+        api.fetchCmsGlobalCollection("appearance", { depth: 2 }),
+        api.fetchCmsGlobalCollection("options", { depth: 2 })
+      ]);
+      return { project, appearance, options };
+    },
+    // Redirects are emitted once at build time for the whole site. Use the
+    // default locale — prefixed paths are handled by page routing, not the
+    // redirect table.
+    async redirects() {
+      const docs = await api.fetchCmsCollection("redirects", {
+        depth: 2,
+        limit: 1e3
+      });
+      return Object.assign(
+        {},
+        ...docs?.map(({ from, to }) => createRedirect(defaultRoutes, from, to)).filter(Boolean) ?? []
+      );
+    },
+    /** The favicon source file, or `false` when there is none to read. */
+    async fetchIconBuffer(icon) {
+      if (icon.url) {
+        const response = await fetch(
+          icon.url.startsWith("/") ? api.apiUrl(icon.url, {}, false) : icon.url,
+          { headers: api.buildHeaders() }
+        );
+        if (response.ok) {
+          return Buffer.from(await response.arrayBuffer());
+        }
+      }
+      return false;
+    }
+  };
+}
+
+// src/form-proxy/rate-limit.ts
+function createRateLimiter({
+  limit,
+  windowMs,
+  now = Date.now
+}) {
+  const windows = /* @__PURE__ */ new Map();
+  function sweep(current) {
+    for (const [key, entry] of windows) {
+      if (current - entry.start > windowMs) {
+        windows.delete(key);
+      }
+    }
+  }
+  return {
+    allow(key) {
+      const current = now();
+      const entry = windows.get(key);
+      if (!entry || current - entry.start > windowMs) {
+        if (windows.size > 1e4) {
+          sweep(current);
+        }
+        windows.set(key, { start: current, count: 1 });
+        return true;
+      }
+      entry.count += 1;
+      return entry.count <= limit;
+    }
+  };
+}
+
+// src/form-proxy/http.ts
+function jsonResponse(body, status) {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { "Content-Type": "application/json" }
+  });
+}
+function declaredLength(request) {
+  const raw = request.headers.get("Content-Length");
+  if (raw === null) {
+    return null;
+  }
+  const n = Number(raw);
+  return Number.isFinite(n) ? n : null;
+}
+function exceedsLimit(request, maxBytes) {
+  const declared = declaredLength(request);
+  return declared !== null && declared > maxBytes;
+}
+async function readBodyWithin(request, maxBytes, tooLarge) {
+  if (exceedsLimit(request, maxBytes)) {
+    return { ok: false, response: jsonResponse({ error: tooLarge }, 413) };
+  }
+  const bytes = await request.arrayBuffer();
+  if (bytes.byteLength > maxBytes) {
+    return { ok: false, response: jsonResponse({ error: tooLarge }, 413) };
+  }
+  return { ok: true, value: bytes };
+}
+async function readJsonBody(request, maxBytes) {
+  const read = await readBodyWithin(request, maxBytes, "Payload too large");
+  if (!read.ok) {
+    return read;
+  }
+  try {
+    return {
+      ok: true,
+      value: JSON.parse(new TextDecoder().decode(read.value))
+    };
+  } catch {
+    return {
+      ok: false,
+      response: jsonResponse({ error: "Invalid JSON" }, 400)
+    };
+  }
+}
+async function readMultipartBody(request, maxBytes) {
+  const contentType = request.headers.get("Content-Type") ?? "";
+  if (!contentType.includes("multipart/form-data")) {
+    return {
+      ok: false,
+      response: jsonResponse({ error: "Expected multipart form data" }, 400)
+    };
+  }
+  const read = await readBodyWithin(request, maxBytes, "File too large");
+  if (!read.ok) {
+    return read;
+  }
+  try {
+    const value = await new Response(read.value, {
+      headers: { "Content-Type": contentType }
+    }).formData();
+    return { ok: true, value };
+  } catch {
+    return {
+      ok: false,
+      response: jsonResponse({ error: "Invalid multipart body" }, 400)
+    };
+  }
+}
+
+// src/form-proxy/cms-write.ts
+async function writeThroughCms(cms, formId, write, shape) {
+  let result;
+  try {
+    if (!await cms.formBelongsToProject(formId)) {
+      return jsonResponse({ error: "Invalid form id" }, 400);
+    }
+    result = await write();
+  } catch {
+    return jsonResponse({ error: shape.failed }, 502);
+  }
+  if (result.status >= 200 && result.status < 300) {
+    return jsonResponse(shape.success(result.id), 201);
+  }
+  const message = shape.passThrough[result.status];
+  if (message !== void 0) {
+    const fields = result.fields?.length ? { fields: result.fields } : {};
+    return jsonResponse({ error: message, ...fields }, result.status);
+  }
+  return jsonResponse({ error: shape.failed }, 502);
+}
+
+// src/form-proxy/submissions.ts
+var MAX_SUBMISSION_BYTES = 64 * 1024;
+var CMS_LOCALES = ["es", "en"];
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function honeypotFilled(value) {
+  return value !== void 0 && value !== null && value !== "";
+}
+async function handleFormSubmission(request, deps) {
+  if (deps.rateLimiter && !deps.rateLimiter.allow(deps.clientAddress)) {
+    return jsonResponse({ error: "Too many requests" }, 429);
+  }
+  const read = await readJsonBody(request, MAX_SUBMISSION_BYTES);
+  if (!read.ok) {
+    return read.response;
+  }
+  const body = read.value;
+  if (!isRecord(body)) {
+    return jsonResponse({ error: "Invalid data" }, 400);
+  }
+  if (typeof body.form !== "string" || !body.form) {
+    return jsonResponse({ error: "Invalid form id" }, 400);
+  }
+  if (body.project !== deps.projectId) {
+    return jsonResponse({ error: "Invalid project id" }, 400);
+  }
+  if (!isRecord(body.data)) {
+    return jsonResponse({ error: "Invalid data" }, 400);
+  }
+  if (honeypotFilled(body.honeypot)) {
+    return jsonResponse({ error: "Invalid submission" }, 400);
+  }
+  const form = body.form;
+  const data = body.data;
+  const locales = deps.locales ?? CMS_LOCALES;
+  const locale = typeof body.locale === "string" && locales.includes(body.locale) ? body.locale : void 0;
+  return writeThroughCms(
+    deps.cms,
+    form,
+    () => deps.cms.createSubmission(
+      { form, project: deps.projectId, data, honeypot: "" },
+      locale
+    ),
+    {
+      success: (id) => ({ ok: true, id }),
+      passThrough: { 400: "Invalid submission" },
+      failed: "Submission failed"
+    }
+  );
+}
+
+// src/form-proxy/uploads.ts
+function parsePayload(raw) {
+  if (typeof raw !== "string") {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null || typeof parsed.form !== "string" || !parsed.form) {
+      return null;
+    }
+    return { form: parsed.form, project: parsed.project };
+  } catch {
+    return null;
+  }
+}
+async function handleFormUpload(request, deps) {
+  if (deps.rateLimiter && !deps.rateLimiter.allow(deps.clientAddress)) {
+    return jsonResponse({ error: "Too many requests" }, 429);
+  }
+  const read = await readMultipartBody(request, MAX_REQUEST_BYTES);
+  if (!read.ok) {
+    return read.response;
+  }
+  const formData = read.value;
+  const file = formData.get("file");
+  if (!(file instanceof File)) {
+    return jsonResponse({ error: "Missing file" }, 400);
+  }
+  if (file.size > MAX_UPLOAD_BYTES) {
+    return jsonResponse({ error: "File too large" }, 413);
+  }
+  const payload = parsePayload(formData.get("_payload"));
+  if (!payload) {
+    return jsonResponse({ error: "Invalid form id" }, 400);
+  }
+  if (payload.project !== deps.projectId) {
+    return jsonResponse({ error: "Invalid project id" }, 400);
+  }
+  return writeThroughCms(
+    deps.cms,
+    payload.form,
+    () => deps.cms.createUpload(file, {
+      form: payload.form,
+      project: deps.projectId
+    }),
+    {
+      success: (id) => ({ doc: { id } }),
+      passThrough: { 400: "Invalid file", 413: "File too large" },
+      failed: "Upload failed"
+    }
+  );
+}
+
+// src/form-proxy/cms-errors.ts
+var FIELD_PATH = /^data\.([A-Za-z0-9_-]+)$/;
+var MAX_FIELDS = 50;
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function pathsOf(entry) {
+  if (!isRecord2(entry)) {
+    return [];
+  }
+  const paths = [];
+  if (typeof entry.path === "string") {
+    paths.push(entry.path);
+  }
+  const data = entry.data;
+  if (isRecord2(data) && Array.isArray(data.errors)) {
+    for (const nested of data.errors) {
+      if (isRecord2(nested) && typeof nested.path === "string") {
+        paths.push(nested.path);
+      }
+    }
+  }
+  return paths;
+}
+function refusedFieldNames(body) {
+  if (!isRecord2(body) || !Array.isArray(body.errors)) {
+    return [];
+  }
+  const names = /* @__PURE__ */ new Set();
+  for (const entry of body.errors) {
+    for (const path of pathsOf(entry)) {
+      const match = FIELD_PATH.exec(path);
+      if (match) {
+        names.add(match[1]);
+      }
+    }
+  }
+  return [...names].slice(0, MAX_FIELDS);
+}
+
+// src/form-proxy/cms-client.ts
+async function stripToStatusAndId(res) {
+  let body;
+  try {
+    body = await res.json();
+  } catch {
+    return { status: res.status };
+  }
+  if (!res.ok) {
+    return { status: res.status, fields: refusedFieldNames(body) };
+  }
+  const doc = body;
+  const id = doc?.doc?.id ?? doc?.id;
+  return { status: res.status, id: typeof id === "string" ? id : void 0 };
+}
+function createFormProxyCmsClient(api, apiUrl) {
+  function writeUrl(path, locale) {
+    const url = new URL(path, apiUrl);
+    url.searchParams.set("depth", "0");
+    if (locale) {
+      url.searchParams.set("locale", locale);
+    }
+    return url;
+  }
+  async function formBelongsToProject(formId) {
+    if (!/^[a-zA-Z0-9_-]+$/.test(formId)) {
+      return false;
+    }
+    const docs = await api.fetchCmsCollection("forms", {
+      depth: 0,
+      limit: 1,
+      query: { where: { id: { equals: formId } } }
+    });
+    return docs.some((doc) => doc.id === formId);
+  }
+  return {
+    formBelongsToProject,
+    async createSubmission(payload, locale) {
+      const res = await fetch(writeUrl("/api/form-submissions", locale), {
+        method: "POST",
+        headers: { ...api.buildHeaders(), "Content-Type": "application/json" },
+        body: JSON.stringify(payload)
+      });
+      return stripToStatusAndId(res);
+    },
+    // `form` in the payload is dropped by the CMS — the field is server-written
+    // there, and an upload carries no form until the submission claiming it
+    // arrives. It is sent anyway so an older CMS still records it, and nothing
+    // on this side reads it back.
+    async createUpload(file, payload) {
+      const body = new FormData();
+      body.append("file", file, file.name);
+      body.append("_payload", JSON.stringify(payload));
+      const res = await fetch(writeUrl("/api/form-uploads"), {
+        method: "POST",
+        headers: api.buildHeaders(),
+        body
+      });
+      return stripToStatusAndId(res);
+    }
+  };
+}
+
+// src/form-proxy/index.ts
+function clientAddress(context) {
+  try {
+    return context.clientAddress;
+  } catch {
+    return "unknown";
+  }
+}
+function createFormProxy(cms, project, locales) {
+  const submissionLimiter = createRateLimiter({
+    limit: 10,
+    windowMs: 6e4
+  });
+  const uploadLimiter = createRateLimiter({ limit: 20, windowMs: 6e4 });
+  async function buildProxyDeps(context, rateLimiter) {
+    return {
+      projectId: (await project()).id,
+      cms,
+      clientAddress: clientAddress(context),
+      rateLimiter,
+      locales
+    };
+  }
+  return {
+    cms,
+    submissionLimiter,
+    uploadLimiter,
+    buildProxyDeps,
+    handleFormSubmission,
+    handleFormUpload
+  };
+}
+
+// src/home-page.ts
+async function fetchHomePage(ctx, locale) {
+  const options = await ctx.cms(locale).options();
+  const configured = options.homepage?.page;
+  const id = typeof configured === "string" ? configured : configured?.id ?? null;
+  if (!id) {
+    return null;
+  }
+  const [doc] = await ctx.api.fetchCmsCollection("pages", {
+    locale,
+    fallback: "default",
+    status: "published",
+    limit: 1,
+    query: { where: { id: { equals: id } } }
+  });
+  if (!doc) {
+    return null;
+  }
+  const path = (doc.breadcrumbs?.at(-1)?.url ?? doc.slug ?? "").replace(
+    /^\//,
+    ""
+  );
+  return { ...doc, children: [], parent: void 0, path };
+}
+function createHomePage(ctx) {
+  const cache = /* @__PURE__ */ new Map();
+  function getHomePage(locale) {
+    let pending = cache.get(locale);
+    if (!pending) {
+      pending = fetchHomePage(ctx, locale);
+      cache.set(locale, pending);
+    }
+    return pending;
+  }
+  async function getHomePageRef(locale) {
+    const page = await getHomePage(locale);
+    return page ? { id: page.id, path: page.path } : null;
+  }
+  return { getHomePage, getHomePageRef };
+}
+
+// src/client.ts
+function createClient(options) {
+  const locales = defineLocales(options);
+  const api = createApi(options);
+  const createRoutes = defineRoutes(locales);
+  const cmsToHref = defineCmsToHref(createRoutes);
+  const instances = /* @__PURE__ */ new Map();
+  const ctx = {
+    api,
+    locales,
+    options,
+    cms: (locale) => cms(locale)
+  };
+  function cms(locale = locales.defaultLocale) {
+    let instance = instances.get(locale);
+    if (!instance) {
+      const base = buildCms(ctx, locale);
+      const extended = {};
+      for (const [key, extension] of Object.entries(
+        options.extensions ?? {}
+      )) {
+        extended[key] = extension({
+          api,
+          locale,
+          cms: ctx.cms,
+          createCollectionLoader,
+          createGlobalLoader
+        });
+      }
+      instance = { ...base, ...extended };
+      instances.set(locale, instance);
+    }
+    return instance;
+  }
+  const { getHomePage, getHomePageRef } = createHomePage(ctx);
+  const formProxy = createFormProxy(
+    createFormProxyCmsClient(api, options.apiUrl),
+    () => cms().project(),
+    locales.locales
+  );
+  return {
+    options,
+    locales,
+    api,
+    cms,
+    routes: createRoutes,
+    cmsToHref,
+    getHomePage,
+    getHomePageRef,
+    getBlogListing: createBlogListing(ctx),
+    /** Wires a single post document, e.g. a draft for live preview. */
+    wirePost: (post, locale) => wirePost(ctx, post, locale),
+    formProxy,
+    /** The fetches `astro.config.mjs` makes before the build starts. */
+    config: createConfigTime(api, createRoutes(locales.defaultLocale))
+  };
+}
+
+// src/resolve-menu-items.ts
+function customLink(label, url) {
+  return { type: "custom", label, url };
+}
+function sortByLabel(items) {
+  return [...items].sort((a, b) => {
+    const labelA = a.link?.label ?? "";
+    const labelB = b.link?.label ?? "";
+    return labelA.localeCompare(labelB);
+  });
+}
+function pageToSubmenuItem(routes, page) {
+  return {
+    type: "link",
+    link: customLink(page.title, routes.page(page))
+  };
+}
+function categoryToSubmenuItem(routes, category) {
+  return {
+    type: "link",
+    link: customLink(category.title, routes.blog("category", category.path))
+  };
+}
+function tagToSubmenuItem(routes, tag) {
+  return {
+    type: "link",
+    link: customLink(tag.title, routes.blog("tag", tag.slug))
+  };
+}
+function teamMemberToSubmenuItem(routes, member) {
+  return {
+    type: "link",
+    link: customLink(
+      `${member.firstName} ${member.lastName}`.trim(),
+      routes.team("member", member.slug)
+    )
+  };
+}
+function resolveNested(menuItem, data, routes, labels) {
+  const { nestedType } = menuItem;
+  if (nestedType === "nested-pages") {
+    const parentPage = menuItem.parentPage;
+    if (!parentPage || typeof parentPage === "string") {
+      return { submenuItems: menuItem.submenuItems };
+    }
+    const parentId = parentPage.id;
+    const wiredParent = data.pages.find((p) => p.id === parentId);
+    if (!wiredParent) {
+      return { submenuItems: menuItem.submenuItems };
+    }
+    const mainLink = customLink(wiredParent.title, routes.page(wiredParent));
+    return {
+      submenuItems: wiredParent.children.map(
+        (child) => pageToSubmenuItem(routes, child)
+      ),
+      mainLink,
+      hasMainLink: true
+    };
+  }
+  if (nestedType === "collection") {
+    const slug = menuItem.collectionSlug;
+    if (slug === "categories") {
+      return {
+        submenuItems: sortByLabel(
+          data.categories.map((c) => categoryToSubmenuItem(routes, c))
+        ),
+        hasMainLink: false
+      };
+    }
+    if (slug === "tags") {
+      return {
+        submenuItems: sortByLabel(
+          data.tags.map((t) => tagToSubmenuItem(routes, t))
+        ),
+        hasMainLink: false
+      };
+    }
+    if (slug === "team-members") {
+      return {
+        submenuItems: sortByLabel(
+          data.teamMembers.map((m) => teamMemberToSubmenuItem(routes, m))
+        ),
+        mainLink: customLink(labels.team, routes.team()),
+        hasMainLink: true
+      };
+    }
+    return { submenuItems: menuItem.submenuItems };
+  }
+  return { submenuItems: menuItem.submenuItems };
+}
+function resolveMenuItems(mainMenu, data, routes, labels) {
+  return mainMenu.map((entry) => {
+    const menuItem = entry.menuItem;
+    if (!menuItem || menuItem.type !== "nested") {
+      return entry;
+    }
+    const { submenuItems, mainLink, hasMainLink } = resolveNested(
+      menuItem,
+      data,
+      routes,
+      labels
+    );
+    const resolvedMainLink = mainLink ?? menuItem.mainLink;
+    const resolvedHasMainLink = hasMainLink !== void 0 ? hasMainLink : menuItem.hasMainLink;
+    return {
+      ...entry,
+      menuItem: {
+        ...menuItem,
+        submenuItems,
+        mainLink: resolvedMainLink,
+        hasMainLink: resolvedHasMainLink
+      }
+    };
+  });
+}
+export {
+  DEFAULT_APPEARANCE_FALLBACKS,
+  MAX_SUBMISSION_BYTES,
+  createClient,
+  createCollectionLoader,
+  createFormProxy,
+  createFormProxyCmsClient,
+  createGlobalLoader,
+  createRateLimiter,
+  defineCmsToHref,
+  defineLocales,
+  defineRoutes,
+  handleFormSubmission,
+  handleFormUpload,
+  mapWithConcurrency,
+  refusedFieldNames,
+  resolveMenuItems
+};
+//# sourceMappingURL=index.js.map