@cmssy/core 9.9.0 → 10.0.0

package/dist/internal.cjs

@@ -0,0 +1,939 @@
+'use strict';
+
+// src/data/http.ts
+var CmssyRequestError = class extends Error {
+  status;
+  constructor(message, status) {
+    super(message);
+    this.name = "CmssyRequestError";
+    this.status = status;
+  }
+};
+var DEFAULT_RETRY_STATUSES = [429, 503];
+function retryAfterMs(response) {
+  const raw = response.headers?.get("retry-after");
+  if (!raw) return null;
+  const seconds = Number(raw);
+  if (Number.isFinite(seconds)) return Math.max(0, seconds * 1e3);
+  const date = Date.parse(raw);
+  if (Number.isFinite(date)) return Math.max(0, date - Date.now());
+  return null;
+}
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(new Error("cmssy: request aborted"));
+      return;
+    }
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    function onAbort() {
+      clearTimeout(timer);
+      reject(new Error("cmssy: request aborted"));
+    }
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+async function fetchWithRetry(doFetch, url, init, retry) {
+  if (retry === false || retry === void 0) {
+    return doFetch(url, init);
+  }
+  const maxRetries = retry.maxRetries ?? 3;
+  const baseDelayMs = retry.baseDelayMs ?? 300;
+  const maxDelayMs = retry.maxDelayMs ?? 3e3;
+  const retryStatuses = retry.retryStatuses ?? DEFAULT_RETRY_STATUSES;
+  let response = await doFetch(url, init);
+  for (let attempt = 0; attempt < maxRetries; attempt++) {
+    if (response.ok || !retryStatuses.includes(response.status)) {
+      return response;
+    }
+    const backoff = baseDelayMs * 2 ** attempt;
+    const wait = Math.min(retryAfterMs(response) ?? backoff, maxDelayMs);
+    await sleep(wait, init.signal);
+    response = await doFetch(url, init);
+  }
+  return response;
+}
+async function postGraphql(url, query, variables, options) {
+  const doFetch = options.fetch ?? globalThis.fetch;
+  if (typeof doFetch !== "function") {
+    throw new Error(
+      "cmssy: no fetch implementation available - pass options.fetch"
+    );
+  }
+  const response = await fetchWithRetry(
+    doFetch,
+    url,
+    {
+      method: "POST",
+      headers: { "content-type": "application/json", ...options.headers },
+      body: JSON.stringify({ query, variables }),
+      signal: options.signal
+    },
+    options.retry
+  );
+  if (!response.ok) {
+    let detail = "";
+    try {
+      const body = await response.json();
+      if (body.errors && body.errors.length > 0) {
+        detail = ` - ${body.errors.map((error) => error.message ?? "GraphQL error").join("; ")}`;
+      }
+    } catch {
+      detail = "";
+    }
+    throw new CmssyRequestError(
+      `cmssy: ${options.label} failed (${response.status})${detail}`,
+      response.status
+    );
+  }
+  let json;
+  try {
+    json = await response.json();
+  } catch {
+    throw new Error(`cmssy: invalid JSON response from the ${options.label}`);
+  }
+  if (json.errors && json.errors.length > 0) {
+    const message = json.errors.map((error) => error.message ?? "GraphQL error").join("; ");
+    throw new Error(`cmssy: ${options.label} error - ${message}`);
+  }
+  return json.data;
+}
+
+// src/content/content-client.ts
+var DEFAULT_CMSSY_API_URL = "https://api.cmssy.io/graphql";
+function resolveApiUrl(apiUrl) {
+  const explicit = apiUrl?.trim();
+  if (explicit) return explicit;
+  const env = globalThis.process?.env;
+  const fromEnv = env?.CMSSY_API_URL?.trim() ?? "";
+  return fromEnv.length > 0 ? fromEnv : DEFAULT_CMSSY_API_URL;
+}
+function resolvePublicUrl(config) {
+  const base = resolveApiUrl(config.apiUrl).replace(/\/graphql\/?$/, "");
+  return `${base}/public/${config.org}/${config.workspaceSlug}/graphql`;
+}
+var PUBLIC_PAGE_QUERY = `query PublicPage($workspaceSlug: String!, $slug: String!, $previewSecret: String) {
+  public {
+    page {
+      get(workspaceSlug: $workspaceSlug, slug: $slug, previewSecret: $previewSecret) {
+        id
+        blocks { id type content style advanced }
+        publishedBlocks { id type content style advanced }
+      }
+    }
+  }
+}`;
+var PUBLIC_PAGE_DEV_QUERY = `query PublicPage($workspaceSlug: String!, $slug: String!, $previewSecret: String, $devPreview: Boolean) {
+  public {
+    page {
+      get(workspaceSlug: $workspaceSlug, slug: $slug, previewSecret: $previewSecret, devPreview: $devPreview) {
+        id
+        blocks { id type content style advanced }
+        publishedBlocks { id type content style advanced }
+      }
+    }
+  }
+}`;
+var PUBLIC_PAGE_BY_ID_QUERY = `query PublicPageById($workspaceSlug: String!, $pageId: ID!) {
+  public {
+    page {
+      getById(workspaceSlug: $workspaceSlug, pageId: $pageId) {
+        id
+        publishedBlocks { id type content style advanced }
+      }
+    }
+  }
+}`;
+var PUBLIC_PAGES_QUERY = `query PublicPages($workspaceSlug: String!) {
+  public {
+    page {
+      list(workspaceSlug: $workspaceSlug) {
+        id
+        slug
+        updatedAt
+        publishedAt
+      }
+    }
+  }
+}`;
+var PUBLIC_PAGE_META_QUERY = `query PublicPageMeta($workspaceSlug: String!, $slug: String!) {
+  public {
+    page {
+      get(workspaceSlug: $workspaceSlug, slug: $slug) {
+        id
+        seoTitle
+        seoDescription
+        seoKeywords
+        displayName
+      }
+    }
+  }
+}`;
+var PUBLIC_PAGE_LAYOUTS_QUERY = `query PublicPageLayouts($workspaceSlug: String!, $pageSlug: String!, $previewSecret: String) {
+  public {
+    page {
+      layouts(workspaceSlug: $workspaceSlug, pageSlug: $pageSlug, previewSecret: $previewSecret) {
+        position
+        blocks { id type content style advanced order isActive }
+        settings { desktopWidth mobileBehavior }
+      }
+    }
+  }
+}`;
+function normalizeSlug(path) {
+  if (Array.isArray(path)) {
+    const joined = path.filter(Boolean).join("/");
+    return joined ? `/${joined}` : "/";
+  }
+  if (!path || path === "/") return "/";
+  return path.startsWith("/") ? path : `/${path}`;
+}
+async function fetchPage(config, path, options = {}) {
+  const slug = normalizeSlug(path);
+  const trimmedSecret = options.previewSecret?.trim();
+  const previewSecret = trimmedSecret ? trimmedSecret : null;
+  const devToken = options.devToken?.trim();
+  const devPreview = Boolean(options.devPreview && devToken);
+  const headers = {};
+  if (devPreview && devToken) {
+    headers["authorization"] = `Bearer ${devToken}`;
+    if (options.workspaceId) {
+      headers["x-workspace-id"] = options.workspaceId;
+    }
+  }
+  const data = await postGraphql(
+    resolvePublicUrl(config),
+    devPreview ? PUBLIC_PAGE_DEV_QUERY : PUBLIC_PAGE_QUERY,
+    {
+      workspaceSlug: config.workspaceSlug,
+      slug,
+      previewSecret,
+      ...devPreview ? { devPreview: true } : {}
+    },
+    {
+      fetch: options.fetch,
+      signal: options.signal,
+      headers,
+      retry: options.retry ?? {},
+      label: "page fetch"
+    }
+  );
+  const page = data?.public?.page?.get;
+  if (!page) return null;
+  const draft = previewSecret !== null || devPreview;
+  const blocks = (draft ? page.blocks : page.publishedBlocks) ?? [];
+  return { id: page.id, blocks };
+}
+async function fetchPageById(config, pageId, options = {}) {
+  const data = await postGraphql(
+    resolvePublicUrl(config),
+    PUBLIC_PAGE_BY_ID_QUERY,
+    { workspaceSlug: config.workspaceSlug, pageId },
+    {
+      fetch: options.fetch,
+      signal: options.signal,
+      retry: options.retry ?? {},
+      label: "page-by-id fetch"
+    }
+  );
+  const page = data?.public?.page?.getById;
+  if (!page) return null;
+  return { id: page.id, blocks: page.publishedBlocks ?? [] };
+}
+async function fetchPages(config, options = {}) {
+  const data = await postGraphql(
+    resolvePublicUrl(config),
+    PUBLIC_PAGES_QUERY,
+    { workspaceSlug: config.workspaceSlug },
+    {
+      fetch: options.fetch,
+      signal: options.signal,
+      retry: options.retry ?? {},
+      label: "pages fetch"
+    }
+  );
+  return data?.public?.page?.list ?? [];
+}
+async function fetchPageMeta(config, path, options = {}) {
+  const slug = normalizeSlug(path);
+  const data = await postGraphql(
+    resolvePublicUrl(config),
+    PUBLIC_PAGE_META_QUERY,
+    { workspaceSlug: config.workspaceSlug, slug },
+    {
+      fetch: options.fetch,
+      signal: options.signal,
+      retry: options.retry ?? {},
+      label: "page meta fetch"
+    }
+  );
+  return data?.public?.page?.get ?? null;
+}
+async function fetchLayouts(config, path, options = {}) {
+  const pageSlug = normalizeSlug(path);
+  const trimmedSecret = options.previewSecret?.trim();
+  const previewSecret = trimmedSecret ? trimmedSecret : null;
+  const data = await postGraphql(
+    resolvePublicUrl(config),
+    PUBLIC_PAGE_LAYOUTS_QUERY,
+    { workspaceSlug: config.workspaceSlug, pageSlug, previewSecret },
+    {
+      fetch: options.fetch,
+      signal: options.signal,
+      retry: options.retry ?? {},
+      label: "layouts fetch"
+    }
+  );
+  return data?.public?.page?.layouts ?? [];
+}
+
+// src/content/get-block-content.ts
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function looksLikeLocaleKey(key) {
+  return /^[a-z]{2}(-[A-Za-z]{2})?$/.test(key);
+}
+function getBlockContentForLanguage(content, locale, defaultLocale = "en", availableLocales) {
+  if (!isPlainObject(content)) return {};
+  const isLocale = availableLocales ? (key) => availableLocales.includes(key) : looksLikeLocaleKey;
+  const localeEntries = Object.entries(content).filter(
+    ([key, value]) => isLocale(key) && isPlainObject(value)
+  );
+  if (localeEntries.length === 0) return { ...content };
+  const localeMap = Object.fromEntries(localeEntries);
+  const nonTranslatable = {};
+  for (const [key, value] of Object.entries(content)) {
+    if (!(isLocale(key) && isPlainObject(value))) nonTranslatable[key] = value;
+  }
+  const fallbackKey = Object.keys(localeMap)[0];
+  const chosen = localeMap[locale] ?? localeMap[defaultLocale] ?? localeMap[fallbackKey];
+  return { ...nonTranslatable, ...chosen };
+}
+function asBucket(value) {
+  return isPlainObject(value) ? value : {};
+}
+
+// src/data/graphql-request.ts
+async function graphqlRequest(config, query, variables, options = {}, label = "request") {
+  const url = options.public ? resolvePublicUrl(config) : resolveApiUrl(config.apiUrl);
+  return postGraphql(url, query, variables, {
+    fetch: options.fetch,
+    signal: options.signal,
+    headers: options.headers,
+    retry: options.retry,
+    label
+  });
+}
+
+// src/data/queries.ts
+var SITE_CONFIG_QUERY = `query PublicSiteConfig($workspaceSlug: String!) {
+  public {
+    siteConfig(workspaceSlug: $workspaceSlug) {
+      id
+      workspaceId
+      siteName
+      defaultLanguage
+      enabledLanguages
+      enabledFeatures
+      notFoundPageId
+      previewUrl
+      branding {
+        brandName
+        logoUrl
+        faviconUrl
+        ogImageUrl
+      }
+    }
+  }
+}`;
+var MODEL_DEFINITIONS_QUERY = `query PublicModelDefinitions($workspaceId: String!) {
+  public {
+    model {
+      definitions(workspaceId: $workspaceId) {
+        id name slug description icon color displayField recordCount
+      }
+    }
+  }
+}`;
+var MODEL_RECORDS_QUERY = `query PublicModelRecords($workspaceId: String!, $modelSlug: String!, $filter: JSON, $sort: String, $locale: String, $limit: Int, $offset: Int, $populate: [String!]) {
+  public {
+    model {
+      records(workspaceId: $workspaceId, modelSlug: $modelSlug, filter: $filter, sort: $sort, locale: $locale, limit: $limit, offset: $offset, populate: $populate) {
+        items { id modelId data status createdAt updatedAt }
+        total
+        hasMore
+      }
+    }
+  }
+}`;
+var FORM_QUERY = `query PublicForm($formId: ID!) {
+  public {
+    form {
+      get(formId: $formId) {
+        id
+        name
+        slug
+        description
+        fields {
+          id name fieldType label placeholder helpText
+          defaultValue width order showWhen requiredWhen
+          options { value label disabled }
+          validation { required minLength maxLength minValue maxValue pattern customMessage }
+        }
+        settings {
+          actionType submitButtonLabel successMessage errorMessage
+          redirectUrl requireLogin enableCaptcha
+        }
+      }
+    }
+  }
+}`;
+var SUBMIT_FORM_MUTATION = `mutation SubmitForm($formId: ID!, $input: SubmitFormInput!) {
+  public {
+    form {
+      submit(formId: $formId, input: $input) {
+        success message submissionId redirectUrl accessToken customer
+      }
+    }
+  }
+}`;
+
+// src/data/settings-client.ts
+async function fetchSiteConfig(config, options = {}) {
+  const data = await graphqlRequest(
+    config,
+    SITE_CONFIG_QUERY,
+    { workspaceSlug: config.workspaceSlug },
+    { ...options, public: true, retry: options.retry ?? {} },
+    "site config query"
+  );
+  return data.public?.siteConfig ?? null;
+}
+async function resolveWorkspaceId(config, options = {}) {
+  const siteConfig = await fetchSiteConfig(config, options);
+  if (!siteConfig?.workspaceId) {
+    throw new Error(
+      `cmssy: could not resolve workspaceId for "${config.workspaceSlug}"`
+    );
+  }
+  return siteConfig.workspaceId;
+}
+var workspaceIdCache = /* @__PURE__ */ new Map();
+function cachedWorkspaceId(config) {
+  const key = `${resolveApiUrl(config.apiUrl)}::${config.workspaceSlug}`;
+  const existing = workspaceIdCache.get(key);
+  if (existing) return existing;
+  const fresh = resolveWorkspaceId(config).catch((err) => {
+    workspaceIdCache.delete(key);
+    throw err;
+  });
+  workspaceIdCache.set(key, fresh);
+  return fresh;
+}
+function clearWorkspaceIdCache() {
+  workspaceIdCache.clear();
+}
+
+// src/data/client.ts
+function createCmssyClient(input) {
+  const config = {
+    ...input,
+    apiUrl: resolveApiUrl(input.apiUrl)
+  };
+  let cachedWorkspaceId2;
+  let inFlight;
+  function resolveWorkspaceId2(options) {
+    if (cachedWorkspaceId2) return Promise.resolve(cachedWorkspaceId2);
+    if (!inFlight) {
+      inFlight = resolveWorkspaceId(config, options).then((id) => {
+        cachedWorkspaceId2 = id;
+        return id;
+      }).finally(() => {
+        inFlight = void 0;
+      });
+    }
+    return inFlight;
+  }
+  return {
+    config,
+    resolveWorkspaceId: resolveWorkspaceId2,
+    query(document2, variables = {}, options) {
+      return graphqlRequest(
+        config,
+        document2,
+        variables,
+        options,
+        "graphql operation"
+      );
+    },
+    async queryScoped(document2, variables = {}, options = {}) {
+      const { workspaceId: provided, headers, ...rest } = options;
+      const workspaceId = provided ?? await resolveWorkspaceId2({ ...rest, headers });
+      const hasWorkspaceId = variables.workspaceId !== void 0 && variables.workspaceId !== null;
+      const scopedVariables = /\$workspaceId\b/.test(document2) && !hasWorkspaceId ? { ...variables, workspaceId } : variables;
+      return graphqlRequest(
+        config,
+        document2,
+        scopedVariables,
+        { ...rest, headers: { ...headers, "x-workspace-id": workspaceId } },
+        "graphql operation"
+      );
+    }
+  };
+}
+
+// src/data/resolve-forms.ts
+function collectFormIds(blocks, locale, defaultLocale) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const block of blocks) {
+    const content = getBlockContentForLanguage(
+      block.content,
+      locale,
+      defaultLocale
+    );
+    const formId = content.formId;
+    if (typeof formId === "string" && formId.trim()) ids.add(formId);
+  }
+  return [...ids];
+}
+async function resolveForms(config, blocks, locale, defaultLocale, options) {
+  const ids = collectFormIds(blocks, locale, defaultLocale);
+  if (ids.length === 0) return {};
+  const client = createCmssyClient(config);
+  const entries = await Promise.all(
+    ids.map(async (id) => {
+      try {
+        const data = await client.queryScoped(FORM_QUERY, { formId: id }, options);
+        return [id, data.public.form.get];
+      } catch (err) {
+        if (typeof console !== "undefined") {
+          console.warn(`[cmssy] failed to resolve form ${id}`, err);
+        }
+        return [id, null];
+      }
+    })
+  );
+  const forms = {};
+  for (const [id, def] of entries) {
+    if (def) forms[id] = def;
+  }
+  return forms;
+}
+
+// src/data/site-locales.ts
+var TTL_MS = 6e4;
+var MAX_ENTRIES = 64;
+var cache = /* @__PURE__ */ new Map();
+function localesFromSiteConfig(siteConfig) {
+  const defaultLocale = siteConfig?.defaultLanguage || "en";
+  const enabled = siteConfig?.enabledLanguages ?? [];
+  return {
+    defaultLocale,
+    locales: enabled.length > 0 ? enabled : [defaultLocale]
+  };
+}
+async function resolveSiteLocales(config, options) {
+  const key = `${resolveApiUrl(config.apiUrl)}::${config.org}::${config.workspaceSlug}`;
+  const cached = cache.get(key);
+  if (cached && cached.expires > Date.now()) return cached.value;
+  cache.delete(key);
+  let value;
+  try {
+    const data = await graphqlRequest(
+      config,
+      SITE_CONFIG_QUERY,
+      { workspaceSlug: config.workspaceSlug },
+      { ...options, public: true, retry: options?.retry ?? {} },
+      "site config"
+    );
+    value = localesFromSiteConfig(data.public?.siteConfig ?? null);
+  } catch {
+    value = { defaultLocale: "en", locales: ["en"] };
+  }
+  if (cache.size >= MAX_ENTRIES) cache.clear();
+  cache.set(key, { value, expires: Date.now() + TTL_MS });
+  return value;
+}
+function splitLocaleFromPath(path, siteLocales) {
+  const first = path?.[0];
+  if (first && first !== siteLocales.defaultLocale && siteLocales.locales.includes(first)) {
+    return { locale: first, path: path.slice(1) };
+  }
+  return { locale: siteLocales.defaultLocale, path };
+}
+
+// src/data/localize-href.ts
+var PROTOCOL_OR_RELATIVE = /^([a-z][a-z0-9+.-]*:|\/\/)/i;
+function isExternalHref(href) {
+  const value = href.trim();
+  if (!value) return true;
+  if (value.startsWith("#")) return true;
+  return PROTOCOL_OR_RELATIVE.test(value);
+}
+function stripLeadingLocale(path, locale) {
+  const segments = path.split("/");
+  const first = segments[1];
+  if (first && first !== locale.default && locale.enabled.includes(first)) {
+    segments.splice(1, 1);
+    const rest = segments.join("/");
+    return rest === "" ? "/" : rest;
+  }
+  return path;
+}
+function addLocalePrefix(path, target, locale) {
+  if (target === locale.default) return path;
+  if (path === "/") return `/${target}`;
+  return `/${target}${path}`;
+}
+function localizeHref(href, locale) {
+  const value = href.trim();
+  if (isExternalHref(value)) return href;
+  const boundary = value.search(/[?#]/);
+  const path = boundary === -1 ? value : value.slice(0, boundary);
+  const suffix = boundary === -1 ? "" : value.slice(boundary);
+  if (!path.startsWith("/")) return href;
+  const bare = stripLeadingLocale(path, locale);
+  return `${addLocalePrefix(bare, locale.current, locale)}${suffix}`;
+}
+function buildLocaleSwitchHref(target, pathname, locale) {
+  const path = pathname && pathname.startsWith("/") ? pathname : "/";
+  const bare = stripLeadingLocale(path, locale);
+  return addLocalePrefix(bare, target, locale);
+}
+var ANCHOR_HREF = /(<a\b(?:"[^"]*"|'[^']*'|[^>])*?\shref=)(["'])(.*?)\2/gi;
+function localizeHtmlLinks(html, locale) {
+  return html.replace(
+    ANCHOR_HREF,
+    (_match, prefix, quote, url) => `${prefix}${quote}${localizeHref(url, locale)}${quote}`
+  );
+}
+
+// src/data/relation-resolver.ts
+var RECORDS_BY_IDS_QUERY = `query PublicRecordsByIds($workspaceId: String!, $ids: [String!]!, $locale: String) {
+  public {
+    model {
+      recordsByIds(workspaceId: $workspaceId, ids: $ids, locale: $locale) {
+        id modelId data status createdAt updatedAt
+      }
+    }
+  }
+}`;
+var BY_IDS_CHUNK = 50;
+var COLLECTION_DEFAULT_LIMIT = 50;
+function relationModel(field) {
+  return field.relationTo?.startsWith("model:") ? field.relationTo.slice("model:".length) : void 0;
+}
+function storedIds(value) {
+  if (typeof value === "string" && value) return [value];
+  if (Array.isArray(value)) {
+    return value.filter((id) => typeof id === "string" && !!id);
+  }
+  return [];
+}
+function collectRefs(entries, schemas) {
+  const refs = [];
+  for (const entry of entries) {
+    const schema = schemas[entry.type];
+    if (!schema) continue;
+    for (const [key, field] of Object.entries(schema)) {
+      if (field.type !== "relation") continue;
+      const model = relationModel(field);
+      if (!model) continue;
+      refs.push({ content: entry.content, key, field, model });
+    }
+  }
+  return refs;
+}
+function isResolvedRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && typeof value.id === "string" && typeof value.data === "object";
+}
+function isListShaped(field) {
+  return field.relationMode === "all" || field.relationType === "hasMany" || field.multiple === true;
+}
+function normalizeRelationContent(content, schema, resolved) {
+  for (const [key, field] of Object.entries(schema)) {
+    if (field.type !== "relation") continue;
+    const value = content[key];
+    const fallback = resolved?.[key];
+    if (isListShaped(field)) {
+      if (Array.isArray(value)) {
+        const records = value.filter(isResolvedRecord);
+        if (records.length > 0 || value.length === 0) {
+          content[key] = records;
+          continue;
+        }
+      }
+      content[key] = Array.isArray(fallback) ? fallback.filter(isResolvedRecord) : [];
+    } else if (!isResolvedRecord(value)) {
+      if (value != null && value !== "" && isResolvedRecord(fallback)) {
+        content[key] = fallback;
+      } else {
+        delete content[key];
+      }
+    }
+  }
+}
+function collectionKey(ref) {
+  return [ref.model, ref.field.sort ?? "", ref.field.limit ?? ""].join("\0");
+}
+async function resolveRelationContent(config, entries, schemas, locale, requestOptions = {}) {
+  const refs = collectRefs(entries, schemas);
+  if (refs.length === 0) return;
+  const client = createCmssyClient(config);
+  const pickedIds = /* @__PURE__ */ new Set();
+  const collections = /* @__PURE__ */ new Map();
+  for (const ref of refs) {
+    if (ref.field.relationMode === "all") {
+      collections.set(collectionKey(ref), {
+        model: ref.model,
+        sort: ref.field.sort,
+        limit: ref.field.limit
+      });
+    } else {
+      for (const id of storedIds(ref.content[ref.key])) pickedIds.add(id);
+    }
+  }
+  let recordsById;
+  let collectionItems;
+  try {
+    [recordsById, collectionItems] = await Promise.all([
+      fetchPickedRecords(client, [...pickedIds], locale, requestOptions),
+      fetchCollections(client, collections, locale, requestOptions)
+    ]);
+  } catch (err) {
+    if (typeof console !== "undefined") {
+      console.error("[cmssy] relation resolution failed", err);
+    }
+    for (const ref of refs) {
+      if (ref.field.relationMode === "all" || Array.isArray(ref.content[ref.key])) {
+        ref.content[ref.key] = [];
+      } else {
+        delete ref.content[ref.key];
+      }
+    }
+    return;
+  }
+  for (const ref of refs) {
+    if (ref.field.relationMode === "all") {
+      ref.content[ref.key] = collectionItems.get(collectionKey(ref)) ?? [];
+      continue;
+    }
+    const value = ref.content[ref.key];
+    if (Array.isArray(value)) {
+      ref.content[ref.key] = storedIds(value).map((id) => recordsById.get(id)).filter((record) => !!record);
+    } else if (typeof value === "string" && value) {
+      const record = recordsById.get(value);
+      if (record) ref.content[ref.key] = record;
+      else delete ref.content[ref.key];
+    } else {
+      delete ref.content[ref.key];
+    }
+  }
+}
+async function fetchPickedRecords(client, ids, locale, requestOptions = {}) {
+  const byId = /* @__PURE__ */ new Map();
+  const chunks = [];
+  for (let i = 0; i < ids.length; i += BY_IDS_CHUNK) {
+    chunks.push(ids.slice(i, i + BY_IDS_CHUNK));
+  }
+  await Promise.all(
+    chunks.map(async (chunk) => {
+      const result = await client.queryScoped(
+        RECORDS_BY_IDS_QUERY,
+        { ids: chunk, locale: locale ?? null },
+        requestOptions
+      );
+      for (const record of result.public.model.recordsByIds) {
+        byId.set(record.id, record);
+      }
+    })
+  );
+  return byId;
+}
+async function fetchCollections(client, collections, locale, requestOptions = {}) {
+  const byKey = /* @__PURE__ */ new Map();
+  await Promise.all(
+    [...collections.entries()].map(async ([key, { model, sort, limit }]) => {
+      const result = await client.queryScoped(
+        MODEL_RECORDS_QUERY,
+        {
+          modelSlug: model,
+          sort: sort ?? null,
+          limit: limit ?? COLLECTION_DEFAULT_LIMIT,
+          locale: locale ?? null
+        },
+        requestOptions
+      );
+      byKey.set(key, result.public.model.records.items);
+    })
+  );
+  return byKey;
+}
+
+// src/locale.ts
+var CMSSY_LOCALE_HEADER = "x-cmssy-locale";
+async function localeForPathname(config, pathname) {
+  const siteLocales = await resolveSiteLocales(config);
+  const segments = pathname.split("/").filter(Boolean);
+  return splitLocaleFromPath(segments, siteLocales).locale;
+}
+async function splitCmssyLocale(config, path) {
+  const siteLocales = await resolveSiteLocales(config);
+  return splitLocaleFromPath(path, siteLocales);
+}
+async function localeForPath(config, path) {
+  const siteLocales = await resolveSiteLocales(config);
+  const segments = Array.isArray(path) ? path.filter(Boolean) : path.split("/").filter(Boolean);
+  return splitLocaleFromPath(segments, siteLocales).locale;
+}
+
+// src/seo-paths.ts
+function normalizeSlug2(slug) {
+  if (slug === "/" || slug === "") return "/";
+  return slug.startsWith("/") ? slug : `/${slug}`;
+}
+function localizedPath(slug, locale, defaultLocale) {
+  const normalized = normalizeSlug2(slug);
+  const base = normalized === "/" ? "" : normalized;
+  return locale === defaultLocale ? base || "/" : `/${locale}${base}`;
+}
+
+// src/bridge/messages.ts
+function normalizeOrigin(origin) {
+  const trimmed = origin.trim();
+  if (trimmed === "*") return "*";
+  try {
+    return new URL(trimmed).origin;
+  } catch {
+    return trimmed;
+  }
+}
+function resolveInitialTarget(editorOrigin) {
+  const list = (Array.isArray(editorOrigin) ? editorOrigin : [editorOrigin]).map((origin) => normalizeOrigin(origin));
+  if (list.includes("*")) return "*";
+  if (list.length === 1) return list[0];
+  const referrerOrigin = typeof document !== "undefined" && document.referrer ? normalizeOrigin(document.referrer) : "";
+  return list.find((origin) => origin === referrerOrigin) ?? list[0];
+}
+
+// src/secret-match.ts
+var MAX_SECRET_LENGTH = 256;
+async function cmssySecretsMatch(a, b) {
+  if (a.length > MAX_SECRET_LENGTH || b.length > MAX_SECRET_LENGTH) {
+    return false;
+  }
+  const encoder = new TextEncoder();
+  const [ha, hb] = await Promise.all([
+    crypto.subtle.digest("SHA-256", encoder.encode(a)),
+    crypto.subtle.digest("SHA-256", encoder.encode(b))
+  ]);
+  const va = new Uint8Array(ha);
+  const vb = new Uint8Array(hb);
+  let diff = 0;
+  for (let i = 0; i < va.length; i += 1) {
+    diff |= (va[i] ?? 0) ^ (vb[i] ?? 0);
+  }
+  return diff === 0;
+}
+
+// src/config.ts
+var DEFAULT_CMSSY_EDITOR_ORIGINS = [
+  "https://cmssy.io",
+  "https://www.cmssy.io"
+];
+function parseEditorOriginEnv(raw) {
+  if (!raw) return void 0;
+  const parts = raw.split(",").map((o) => o.trim()).filter((o) => o.length > 0);
+  if (parts.length === 0) return void 0;
+  return parts.length === 1 ? parts[0] : parts;
+}
+function isDevelopment() {
+  return typeof process !== "undefined" && process.env.NODE_ENV === "development";
+}
+function resolveEditorOrigin(editorOrigin) {
+  const value = editorOrigin ?? (typeof process !== "undefined" ? parseEditorOriginEnv(process.env.CMSSY_EDITOR_ORIGIN) : void 0);
+  if (value === void 0) {
+    return isDevelopment() ? "*" : DEFAULT_CMSSY_EDITOR_ORIGINS;
+  }
+  if (Array.isArray(value)) {
+    const cleaned = value.filter((o) => o && o.trim().length > 0);
+    return cleaned.length > 0 ? cleaned : DEFAULT_CMSSY_EDITOR_ORIGINS;
+  }
+  return value.trim().length > 0 ? value : DEFAULT_CMSSY_EDITOR_ORIGINS;
+}
+
+// src/csp.ts
+function toCspOrigin(origin) {
+  if (origin === "*") return "*";
+  let parsed;
+  try {
+    parsed = new URL(origin);
+  } catch {
+    throw new Error(`cmssy: invalid editorOrigin "${origin}"`);
+  }
+  if (parsed.origin === "null") {
+    throw new Error(`cmssy: editorOrigin "${origin}" has no usable origin`);
+  }
+  return parsed.origin;
+}
+function frameAncestors(editorOrigin) {
+  const resolved = resolveEditorOrigin(editorOrigin);
+  const origins = Array.isArray(resolved) ? resolved : [resolved];
+  if (origins.length === 0) {
+    throw new Error(
+      "cmssy: editorOrigin must contain at least one valid origin"
+    );
+  }
+  const normalized = origins.map((origin) => toCspOrigin(origin.trim()));
+  return `frame-ancestors ${normalized.join(" ")}`;
+}
+function cmssyCspHeaders(options) {
+  return {
+    "Content-Security-Policy": frameAncestors(options.editorOrigin)
+  };
+}
+
+exports.CMSSY_LOCALE_HEADER = CMSSY_LOCALE_HEADER;
+exports.FORM_QUERY = FORM_QUERY;
+exports.MODEL_DEFINITIONS_QUERY = MODEL_DEFINITIONS_QUERY;
+exports.MODEL_RECORDS_QUERY = MODEL_RECORDS_QUERY;
+exports.RECORDS_BY_IDS_QUERY = RECORDS_BY_IDS_QUERY;
+exports.SITE_CONFIG_QUERY = SITE_CONFIG_QUERY;
+exports.SUBMIT_FORM_MUTATION = SUBMIT_FORM_MUTATION;
+exports.asBucket = asBucket;
+exports.buildLocaleSwitchHref = buildLocaleSwitchHref;
+exports.cachedWorkspaceId = cachedWorkspaceId;
+exports.clearWorkspaceIdCache = clearWorkspaceIdCache;
+exports.cmssyCspHeaders = cmssyCspHeaders;
+exports.cmssySecretsMatch = cmssySecretsMatch;
+exports.collectFormIds = collectFormIds;
+exports.fetchLayouts = fetchLayouts;
+exports.fetchPage = fetchPage;
+exports.fetchPageById = fetchPageById;
+exports.fetchPageMeta = fetchPageMeta;
+exports.fetchPages = fetchPages;
+exports.fetchSiteConfig = fetchSiteConfig;
+exports.getBlockContentForLanguage = getBlockContentForLanguage;
+exports.isDevelopment = isDevelopment;
+exports.localeForPath = localeForPath;
+exports.localeForPathname = localeForPathname;
+exports.localesFromSiteConfig = localesFromSiteConfig;
+exports.localizeHref = localizeHref;
+exports.localizeHtmlLinks = localizeHtmlLinks;
+exports.localizedPath = localizedPath;
+exports.normalizeRelationContent = normalizeRelationContent;
+exports.normalizeSlug = normalizeSlug;
+exports.resolveApiUrl = resolveApiUrl;
+exports.resolveForms = resolveForms;
+exports.resolveInitialTarget = resolveInitialTarget;
+exports.resolvePublicUrl = resolvePublicUrl;
+exports.resolveRelationContent = resolveRelationContent;
+exports.resolveSiteLocales = resolveSiteLocales;
+exports.resolveWorkspaceId = resolveWorkspaceId;
+exports.splitCmssyLocale = splitCmssyLocale;
+exports.splitLocaleFromPath = splitLocaleFromPath;
+exports.toCspOrigin = toCspOrigin;