@bettercms-ai/sdk 1.34.0 → 1.35.0

package/dist/sections.d.cts

@@ -0,0 +1,49 @@
+import { B as BetterCMSReadClient } from './read-client-tNsCHy0p.cjs';
+import { BcmsSiteConfig, BcmsSiteOptions } from './config.cjs';
+import '@bettercms-ai/types';
+
+interface SectionsFragment {
+    html: string;
+    css: string;
+    scripts: string;
+}
+/** Fetch a page's sections (`home` is `/`). Null when the page is not published. */
+declare function fetchSections(opts: {
+    apiUrl: string;
+    projectId: string;
+    slug: string;
+    fetch?: typeof fetch;
+}): Promise<SectionsFragment | null>;
+/** The fragment as one string for `{@html}` / `v-html`: its stylesheet, its markup, its scripts. */
+declare function sectionsMarkup(fragment: SectionsFragment | null | undefined): string;
+/**
+ * Run the scripts inside `root`. A server-rendered first load runs them itself; a client-side
+ * navigation inserts the markup with innerHTML, where a <script> never runs, so the forms,
+ * sliders and tabs of the new page would be dead. Each script runs once per element.
+ */
+declare function runSectionScripts(root: Element): void;
+interface BcmsSite {
+    config: BcmsSiteConfig;
+    /** The read client for a request: drafts while its draft cookie holds a valid token. */
+    client(request?: Request): Promise<BetterCMSReadClient>;
+    /** A published page's sections (`home` is `/`); pass the framework's `fetch` on the server. */
+    sections(slug: string, fetchImpl?: typeof fetch): Promise<SectionsFragment | null>;
+    /** GET handler for the draft path the editor opens (`/api/draft`). */
+    draftEnable(request: Request): Promise<Response>;
+    /** GET handler that leaves draft mode. */
+    draftDisable(request: Request): Response;
+}
+/**
+ * Everything a server-rendered site needs from BetterCMS, built once from its settings: the
+ * precedence every adapter shares (options, `<PREFIX>BCMS_*`, `BCMS_*`), the read client per
+ * request, the sections fragment and the draft routes. The SvelteKit and Nuxt adapters are this
+ * with their env prefix.
+ */
+declare function createBcmsSite(options: BcmsSiteOptions & {
+    env?: Record<string, string | undefined>;
+    draftSecret?: string;
+    prefixes: string[];
+    adapter: string;
+}): BcmsSite;
+
+export { type BcmsSite, type SectionsFragment, createBcmsSite, fetchSections, runSectionScripts, sectionsMarkup };

package/dist/sections.d.ts

@@ -0,0 +1,49 @@
+import { B as BetterCMSReadClient } from './read-client-tNsCHy0p.js';
+import { BcmsSiteConfig, BcmsSiteOptions } from './config.js';
+import '@bettercms-ai/types';
+
+interface SectionsFragment {
+    html: string;
+    css: string;
+    scripts: string;
+}
+/** Fetch a page's sections (`home` is `/`). Null when the page is not published. */
+declare function fetchSections(opts: {
+    apiUrl: string;
+    projectId: string;
+    slug: string;
+    fetch?: typeof fetch;
+}): Promise<SectionsFragment | null>;
+/** The fragment as one string for `{@html}` / `v-html`: its stylesheet, its markup, its scripts. */
+declare function sectionsMarkup(fragment: SectionsFragment | null | undefined): string;
+/**
+ * Run the scripts inside `root`. A server-rendered first load runs them itself; a client-side
+ * navigation inserts the markup with innerHTML, where a <script> never runs, so the forms,
+ * sliders and tabs of the new page would be dead. Each script runs once per element.
+ */
+declare function runSectionScripts(root: Element): void;
+interface BcmsSite {
+    config: BcmsSiteConfig;
+    /** The read client for a request: drafts while its draft cookie holds a valid token. */
+    client(request?: Request): Promise<BetterCMSReadClient>;
+    /** A published page's sections (`home` is `/`); pass the framework's `fetch` on the server. */
+    sections(slug: string, fetchImpl?: typeof fetch): Promise<SectionsFragment | null>;
+    /** GET handler for the draft path the editor opens (`/api/draft`). */
+    draftEnable(request: Request): Promise<Response>;
+    /** GET handler that leaves draft mode. */
+    draftDisable(request: Request): Response;
+}
+/**
+ * Everything a server-rendered site needs from BetterCMS, built once from its settings: the
+ * precedence every adapter shares (options, `<PREFIX>BCMS_*`, `BCMS_*`), the read client per
+ * request, the sections fragment and the draft routes. The SvelteKit and Nuxt adapters are this
+ * with their env prefix.
+ */
+declare function createBcmsSite(options: BcmsSiteOptions & {
+    env?: Record<string, string | undefined>;
+    draftSecret?: string;
+    prefixes: string[];
+    adapter: string;
+}): BcmsSite;
+
+export { type BcmsSite, type SectionsFragment, createBcmsSite, fetchSections, runSectionScripts, sectionsMarkup };

package/dist/sections.js

@@ -0,0 +1,486 @@
+// src/errors.ts
+var ErrorCodes = {
+  CONTENT_NOT_FOUND: "CONTENT_NOT_FOUND",
+  UNAUTHORIZED: "UNAUTHORIZED",
+  FORBIDDEN: "FORBIDDEN",
+  RATE_LIMITED: "RATE_LIMITED",
+  INTERNAL_ERROR: "INTERNAL_ERROR",
+  VALIDATION_ERROR: "VALIDATION_ERROR",
+  NETWORK_ERROR: "NETWORK_ERROR",
+  ADMIN_NOT_IMPLEMENTED: "ADMIN_NOT_IMPLEMENTED"
+};
+function statusToCode(status) {
+  if (status === 404) return ErrorCodes.CONTENT_NOT_FOUND;
+  if (status === 401) return ErrorCodes.UNAUTHORIZED;
+  if (status === 403) return ErrorCodes.FORBIDDEN;
+  if (status === 429) return ErrorCodes.RATE_LIMITED;
+  if (status >= 500) return ErrorCodes.INTERNAL_ERROR;
+  if (status === 422) return ErrorCodes.VALIDATION_ERROR;
+  return ErrorCodes.INTERNAL_ERROR;
+}
+var BetterCMSError = class _BetterCMSError extends Error {
+  status;
+  code;
+  /**
+   * Raw machine-readable `code` from the response body (e.g. "PROJECT_DELETED"),
+   * when the API supplies one. Distinct from `code` (which is derived from the
+   * HTTP status), this lets callers branch on a specific server condition that
+   * shares a status with others (e.g. 409 slug-conflict vs 409 project-deleted).
+   */
+  bodyCode;
+  /**
+   * Per-field validation messages from a 400 `{ errors: { field: message } }` body.
+   * The backend returns validation failures in this shape (not `message`/`error`), so
+   * without this the SDK collapsed every validation 400 to a bare "Bad Request" with no
+   * hint which field or rule failed (FLO-474). Mirrors the forms client's `fieldErrors`.
+   */
+  fieldErrors;
+  /**
+   * The parsed response body, when there was one.
+   *
+   * Several refusals carry STRUCTURED detail that neither `message` nor `fieldErrors` can hold,
+   * and which is the whole point of the refusal: a component publish 409s with the full
+   * `readiness` tuple (what evidence is missing, whether a human still has to approve it) and
+   * 422s with the `issues` naming the Layouts it would break. Collapsing those to a sentence
+   * leaves a caller able to report that something failed and not what to do about it.
+   */
+  body;
+  constructor(message, status, code, bodyCode, fieldErrors, body) {
+    super(message);
+    this.name = "BetterCMSError";
+    this.status = status;
+    this.code = code;
+    this.bodyCode = bodyCode;
+    this.fieldErrors = fieldErrors;
+    this.body = body;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _BetterCMSError);
+    }
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      status: this.status,
+      code: this.code,
+      bodyCode: this.bodyCode,
+      fieldErrors: this.fieldErrors
+    };
+  }
+  /**
+   * Factory — creates a BetterCMSError from a failed fetch Response. Reads the body's
+   * `message` (or `error`) for the human message and `code` for a machine-readable
+   * condition surfaced as `bodyCode`. Validation failures arrive as `{ errors: {...} }`
+   * (no `message`/`error`), so fall back to the first field error for the message and
+   * expose the full map as `fieldErrors` (FLO-474).
+   */
+  static async from(res) {
+    let message = res.statusText || "An error occurred";
+    let bodyCode;
+    let fieldErrors;
+    let code = statusToCode(res.status);
+    let raw;
+    try {
+      const body = await res.json();
+      if (body?.errors && typeof body.errors === "object") {
+        fieldErrors = body.errors;
+        code = ErrorCodes.VALIDATION_ERROR;
+      }
+      if (body?.message) message = body.message;
+      else if (body?.error) message = body.error;
+      else if (fieldErrors) {
+        const [field, detail] = Object.entries(fieldErrors).find(
+          ([, v]) => typeof v === "string" && v.length > 0
+        ) ?? [];
+        if (field) message = `${field}: ${detail}`;
+      }
+      if (body?.code) bodyCode = body.code;
+      raw = body;
+    } catch {
+    }
+    return new _BetterCMSError(message, res.status, code, bodyCode, fieldErrors, raw);
+  }
+};
+
+// src/retry.ts
+var RETRY_STATUSES = [429, 503];
+var MAX_RETRIES = 3;
+var MAX_DELAY_MS = 65e3;
+var BASE_DELAY_MS = 1e3;
+var JITTER_MS = 250;
+function isRetryableStatus(status) {
+  return RETRY_STATUSES.includes(status);
+}
+function retryAfterMs(res) {
+  const raw = res.headers?.get?.("retry-after");
+  if (!raw) return null;
+  const seconds = Number(raw);
+  if (Number.isFinite(seconds)) {
+    return Math.min(Math.max(seconds, 0) * 1e3, MAX_DELAY_MS);
+  }
+  const at = Date.parse(raw);
+  if (!Number.isNaN(at)) {
+    return Math.min(Math.max(0, at - Date.now()), MAX_DELAY_MS);
+  }
+  return null;
+}
+function backoffMs(attempt, res) {
+  const fromServer = res ? retryAfterMs(res) : null;
+  const base = Math.min(fromServer ?? BASE_DELAY_MS * 2 ** attempt, MAX_DELAY_MS - JITTER_MS);
+  return base + Math.random() * JITTER_MS;
+}
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+// src/read-client.ts
+var DEFAULT_TIMEOUT = 1e4;
+function qs(params) {
+  const sp = new URLSearchParams();
+  for (const [k, v] of Object.entries(params)) {
+    if (v !== void 0 && v !== "") sp.set(k, String(v));
+  }
+  const s = sp.toString();
+  return s ? `?${s}` : "";
+}
+function unwrap(json) {
+  if (json && typeof json === "object") {
+    const o = json;
+    const isPayload = "id" in o || "slug" in o || "items" in o;
+    if (!isPayload && "data" in o) return o.data;
+  }
+  return json;
+}
+function tokenSlug(token) {
+  try {
+    const part = token.split(".")[1];
+    if (!part) return null;
+    const json = atob(part.replace(/-/g, "+").replace(/_/g, "/"));
+    return JSON.parse(json).entrySlug ?? null;
+  } catch {
+    return null;
+  }
+}
+function createRequestCache() {
+  const inflight = /* @__PURE__ */ new Map();
+  const settled = /* @__PURE__ */ new Map();
+  const copy = (value) => typeof structuredClone === "function" ? structuredClone(value) : JSON.parse(JSON.stringify(value));
+  return async function collapse(url, fetcher) {
+    if (settled.has(url)) return copy(settled.get(url));
+    const pending = inflight.get(url);
+    if (pending) return copy(await pending);
+    const run = (async () => {
+      try {
+        const value = await fetcher();
+        settled.set(url, value);
+        return value;
+      } finally {
+        inflight.delete(url);
+      }
+    })();
+    inflight.set(url, run);
+    return copy(await run);
+  };
+}
+function createClient(options) {
+  const apiUrl = options.apiUrl.replace(/\/+$/, "");
+  const { workspace, apiKey, perspective = "published", previewToken } = options;
+  const defaultProjectId = options.projectId;
+  const timeout = options.timeout ?? DEFAULT_TIMEOUT;
+  const base = `${apiUrl}/api/v1/delivery/${workspace}`;
+  const headers = () => {
+    const h = { "Content-Type": "application/json" };
+    if (apiKey) h["X-API-Key"] = apiKey;
+    return h;
+  };
+  const collapse = options.cache && perspective === "published" ? createRequestCache() : void 0;
+  const fetchJSON = (url) => collapse ? collapse(url, () => request(url)) : request(url);
+  async function request(url) {
+    let lastError;
+    for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), timeout);
+      try {
+        const res = await globalThis.fetch(url, {
+          headers: headers(),
+          signal: controller.signal
+        });
+        clearTimeout(timer);
+        if (res.ok) return await res.json();
+        const retryable = attempt < MAX_RETRIES && isRetryableStatus(res.status);
+        if (!retryable) throw await BetterCMSError.from(res);
+        await sleep(backoffMs(attempt, res));
+      } catch (err) {
+        clearTimeout(timer);
+        if (err instanceof Error && err.name === "AbortError") {
+          throw new BetterCMSError("Request timeout", 408, "NETWORK_ERROR");
+        }
+        if (err instanceof BetterCMSError) throw err;
+        lastError = err;
+        if (attempt < MAX_RETRIES) {
+          await sleep(backoffMs(attempt));
+          continue;
+        }
+        throw new BetterCMSError(
+          `Network error: ${err instanceof Error ? err.message : String(err)}`,
+          0,
+          "NETWORK_ERROR"
+        );
+      }
+    }
+    throw lastError ?? new BetterCMSError("Unreachable", 0, "NETWORK_ERROR");
+  }
+  const draft = perspective === "drafts";
+  const stega = options.stega ?? draft;
+  return {
+    perspective,
+    async getEntry(slug, opts) {
+      const url = draft && previewToken ? `${apiUrl}/api/v1/preview/${encodeURIComponent(slug)}${qs({
+        token: previewToken,
+        depth: opts?.depth,
+        select: opts?.select?.join(","),
+        stega: stega ? "1" : void 0
+      })}` : `${base}/content-entries/${encodeURIComponent(slug)}${qs({
+        depth: opts?.depth,
+        select: opts?.select?.join(","),
+        perspective: draft ? "draft" : void 0,
+        stega: draft && stega ? "1" : void 0,
+        projectId: defaultProjectId
+      })}`;
+      return unwrap(await fetchJSON(url));
+    },
+    async listEntries(opts) {
+      const url = `${base}/content-entries${qs({
+        model: opts?.model,
+        page: opts?.page,
+        perPage: opts?.perPage,
+        depth: opts?.depth,
+        select: opts?.select?.join(","),
+        perspective: draft ? "draft" : void 0,
+        stega: draft && stega ? "1" : void 0,
+        projectId: defaultProjectId
+      })}`;
+      return unwrap(await fetchJSON(url));
+    },
+    async getPage(slug) {
+      if (draft && previewToken && tokenSlug(previewToken) === slug) {
+        const url = `${apiUrl}/api/v1/preview/${encodeURIComponent(slug)}${qs({
+          token: previewToken,
+          stega: stega ? "1" : void 0
+        })}`;
+        const d = unwrap(await fetchJSON(url));
+        return {
+          slug: d.slug,
+          title: d.title,
+          metaTitle: d.metaTitle ?? null,
+          metaDescription: d.metaDescription ?? null,
+          metaJson: d.metaJson ?? null,
+          blocks: d.blockJson ?? [],
+          // C3: the DRAFT field styles, present only when the page styles a field.
+          ...d.fieldStyles ? { fieldStyles: d.fieldStyles } : {},
+          updatedAt: d.updatedAt ?? null,
+          publishedAt: d.publishedAt ?? null
+        };
+      }
+      let page = 1;
+      for (; ; ) {
+        const list = await this.listPages({ page, perPage: 100 });
+        const found = list.items.find((p) => p.slug === slug);
+        if (found) return found;
+        if (!list.hasNextPage) return null;
+        page += 1;
+      }
+    },
+    async listPages(opts) {
+      const url = `${base}/pages${qs({
+        page: opts?.page,
+        perPage: opts?.perPage,
+        projectId: defaultProjectId
+      })}`;
+      return unwrap(await fetchJSON(url));
+    },
+    async listComponents() {
+      const url = `${base}/components${qs({
+        perspective: draft ? "draft" : void 0,
+        token: draft ? previewToken : void 0,
+        projectId: defaultProjectId
+      })}`;
+      return unwrap(await fetchJSON(url));
+    },
+    async getLayout() {
+      const url = `${base}/layout${qs({ perspective: draft ? "draft" : void 0, projectId: defaultProjectId })}`;
+      try {
+        return unwrap(await fetchJSON(url));
+      } catch (error) {
+        if (error instanceof BetterCMSError && error.status === 404) return null;
+        throw error;
+      }
+    },
+    async listForms(opts) {
+      const url = `${base}/forms${qs({
+        projectId: opts?.projectId ?? defaultProjectId
+      })}`;
+      return unwrap(
+        await fetchJSON(url)
+      );
+    },
+    tag(resource, id) {
+      return id ? `bcms:${workspace}:${resource}:${id}` : `bcms:${workspace}:${resource}`;
+    }
+  };
+}
+
+// src/config.ts
+var DEFAULT_MEDIA_URL = "https://cdn.bettercms.ai";
+function resolveBcmsConfig(input) {
+  const env = input.env ?? {};
+  const fromEnv = (name) => {
+    for (const p of input.prefixes) {
+      const v = env[`${p}BCMS_${name}`];
+      if (v) return v;
+    }
+    return void 0;
+  };
+  let snap;
+  const snapshot = () => snap ??= input.snapshot?.() ?? {};
+  const o = input.options ?? {};
+  const config = {
+    apiUrl: (o.apiUrl ?? fromEnv("API_URL") ?? snapshot().apiUrl ?? "").replace(/\/+$/, ""),
+    workspace: o.workspace ?? fromEnv("WORKSPACE") ?? snapshot().workspace ?? "",
+    projectId: o.projectId ?? fromEnv("PROJECT_ID") ?? snapshot().projectId,
+    mediaUrl: (o.mediaUrl ?? fromEnv("MEDIA_URL") ?? DEFAULT_MEDIA_URL).replace(/\/+$/, ""),
+    studioUrl: o.studioUrl ?? fromEnv("STUDIO_URL")
+  };
+  const missing = ["apiUrl", "workspace"].filter((k) => !config[k]);
+  return { config, missing };
+}
+
+// src/draft.ts
+var DRAFT_COOKIE = "bcms-draft";
+var enc = new TextEncoder();
+function base64url(bytes) {
+  const b = btoa(String.fromCharCode(...new Uint8Array(bytes)));
+  return b.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+async function hmac(value, secret) {
+  const key = await crypto.subtle.importKey("raw", enc.encode(secret), { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
+  return base64url(await crypto.subtle.sign("HMAC", key, enc.encode(value)));
+}
+async function signValue(value, secret) {
+  return `${value}.${await hmac(value, secret)}`;
+}
+async function verifyValue(signed, secret) {
+  const idx = signed.lastIndexOf(".");
+  if (idx < 0) return null;
+  const value = signed.slice(0, idx);
+  const sig = signed.slice(idx + 1);
+  const expected = await hmac(value, secret);
+  if (sig.length !== expected.length) return null;
+  let diff = 0;
+  for (let i = 0; i < sig.length; i++) diff |= sig.charCodeAt(i) ^ expected.charCodeAt(i);
+  return diff === 0 ? value : null;
+}
+function safeRedirectPath(to) {
+  return to.startsWith("/") && !to.startsWith("//") && !to.startsWith("/\\") ? to : "/";
+}
+function decodeTokenSlug(token) {
+  try {
+    const part = token.split(".")[1];
+    if (!part) return null;
+    const bytes = Uint8Array.from(atob(part.replace(/-/g, "+").replace(/_/g, "/")), (c) => c.charCodeAt(0));
+    const json = JSON.parse(new TextDecoder().decode(bytes));
+    return json.entrySlug ?? null;
+  } catch {
+    return null;
+  }
+}
+async function previewTokenValid(apiUrl, token, fetchImpl = fetch) {
+  const slug = decodeTokenSlug(token);
+  if (!slug) return false;
+  const res = await fetchImpl(`${apiUrl.replace(/\/+$/, "")}/api/v1/preview/${encodeURIComponent(slug)}?token=${encodeURIComponent(token)}`);
+  await res.body?.cancel().catch(() => {
+  });
+  return res.ok;
+}
+async function draftTokenFrom(cookieHeader, secret) {
+  if (!cookieHeader || !secret) return null;
+  const m = new RegExp(`(?:^|;\\s*)${DRAFT_COOKIE}=([^;]+)`).exec(cookieHeader);
+  if (!m) return null;
+  try {
+    return await verifyValue(decodeURIComponent(m[1]), secret);
+  } catch {
+    return null;
+  }
+}
+async function draftEnableResponse(request, opts) {
+  const url = new URL(request.url);
+  const token = url.searchParams.get("token");
+  if (!opts.secret) return new Response("BCMS_DRAFT_SECRET is not configured", { status: 500 });
+  if (!token) return new Response("Missing token", { status: 400 });
+  if (!await previewTokenValid(opts.apiUrl, token, opts.fetchImpl)) return new Response("Invalid or expired token", { status: 401 });
+  const cookie = `${DRAFT_COOKIE}=${encodeURIComponent(await signValue(token, opts.secret))}; Path=/; HttpOnly; SameSite=Lax; Max-Age=86400${url.protocol === "https:" ? "; Secure" : ""}`;
+  return new Response(null, { status: 302, headers: { Location: safeRedirectPath(url.searchParams.get("redirect") ?? "/"), "Set-Cookie": cookie } });
+}
+function draftDisableResponse(request) {
+  const url = new URL(request.url);
+  return new Response(null, {
+    status: 302,
+    headers: { Location: safeRedirectPath(url.searchParams.get("redirect") ?? "/"), "Set-Cookie": `${DRAFT_COOKIE}=; Path=/; HttpOnly; SameSite=Lax; Max-Age=0` }
+  });
+}
+
+// src/sections.ts
+async function fetchSections(opts) {
+  const doFetch = opts.fetch ?? fetch;
+  const url = `${opts.apiUrl.replace(/\/+$/, "")}/api/v1/sites/fragment/${encodeURIComponent(opts.projectId)}/${encodeURIComponent(opts.slug || "home")}`;
+  const res = await doFetch(url, { headers: { accept: "application/json" } });
+  if (res.status === 404) return null;
+  if (!res.ok) throw new BetterCMSError(`Sections for "${opts.slug}" could not be read (${res.status})`, res.status, res.status === 403 ? ErrorCodes.FORBIDDEN : ErrorCodes.INTERNAL_ERROR);
+  return (await res.json()).data;
+}
+function sectionsMarkup(fragment) {
+  if (!fragment) return "";
+  return `<style>${fragment.css}</style>${fragment.html}${fragment.scripts}`;
+}
+function runSectionScripts(root) {
+  for (const old of Array.from(root.querySelectorAll("script"))) {
+    if (old.hasAttribute("data-bcms-ran")) continue;
+    const fresh = document.createElement("script");
+    for (const attr of Array.from(old.attributes)) fresh.setAttribute(attr.name, attr.value);
+    fresh.setAttribute("data-bcms-ran", "");
+    fresh.textContent = old.textContent;
+    old.replaceWith(fresh);
+  }
+}
+function createBcmsSite(options) {
+  const env = options.env ?? {};
+  const { config, missing } = resolveBcmsConfig({ options, env, prefixes: [...options.prefixes, ""] });
+  if (missing.length > 0) {
+    const names = missing.map((m) => `${options.prefixes[0]}BCMS_${m === "apiUrl" ? "API_URL" : "WORKSPACE"}`).join(" and ");
+    throw new Error(`[${options.adapter}] Missing ${names}: set them, or pass them to createBcms().`);
+  }
+  const secret = options.draftSecret ?? env.BCMS_DRAFT_SECRET;
+  return {
+    config,
+    async client(request) {
+      const token = request ? await draftTokenFrom(request.headers.get("cookie"), secret) : null;
+      return createClient({
+        apiUrl: config.apiUrl,
+        workspace: config.workspace,
+        projectId: config.projectId,
+        ...token ? { perspective: "drafts", previewToken: token } : {}
+      });
+    },
+    sections(slug, fetchImpl) {
+      if (!config.projectId) throw new Error(`[${options.adapter}] Sections need the project: set ${options.prefixes[0]}BCMS_PROJECT_ID.`);
+      return fetchSections({ apiUrl: config.apiUrl, projectId: config.projectId, slug, fetch: fetchImpl });
+    },
+    draftEnable: (request) => draftEnableResponse(request, { apiUrl: config.apiUrl, secret }),
+    draftDisable: draftDisableResponse
+  };
+}
+export {
+  createBcmsSite,
+  fetchSections,
+  runSectionScripts,
+  sectionsMarkup
+};
+//# sourceMappingURL=sections.js.map