@riverbankcms/sdk 0.77.1 → 0.78.2

package/dist/server/index.mjs

@@ -1770,7 +1770,16 @@ var ENDPOINT_DEFINITIONS = {
     revalidate: 60,
     tags: ["site-{siteId}", "content-{siteId}-{type}"],
     auth: "user",
-    responseKind: "json"
+    responseKind: "json",
+    errors: ["validation:invalid_input", "resource:not_found", "resource:conflict", "server:internal_error"]
+  },
+  reorderContentEntries: {
+    path: "/sites/{siteId}/content/{type}/order",
+    method: "POST",
+    tags: ["site-{siteId}", "content-{siteId}-{type}"],
+    auth: "user",
+    responseKind: "json",
+    errors: ["validation:invalid_input", "resource:not_found", "resource:conflict", "server:internal_error"]
   },
   getContentTemplate: {
     path: "/sites/{siteId}/content/types/{type}/template",
@@ -3922,6 +3931,14 @@ var ENDPOINT_DEFINITIONS = {
     responseKind: "json",
     errors: []
   },
+  applyDiscountCode: {
+    path: "/public/sites/{siteId}/bookings/discounts/apply",
+    method: "POST",
+    tags: ["site-{siteId}", "booking-discounts"],
+    auth: "public",
+    responseKind: "json",
+    errors: ["validation:invalid_input", "rate_limit:exceeded"]
+  },
   // Batch endpoint for block loader requests (reduces SSR fan-out)
   batchBlockLoaders: {
     path: "/public/sites/{siteId}/block-loaders/batch",
@@ -6375,18 +6392,21 @@ function buildEndpointURL(baseURL, endpoint) {
 function isFormDataBody(value) {
   return typeof FormData !== "undefined" && value instanceof FormData;
 }
+function isUnknownArray(value) {
+  return Array.isArray(value);
+}
 function appendQueryParam(queryParams, key, value) {
   if (value === void 0 || value === null) {
     return;
   }
-  if (Array.isArray(value)) {
+  if (isUnknownArray(value)) {
     const stack = [...value].reverse();
     while (stack.length > 0) {
       const item = stack.pop();
       if (item === void 0 || item === null) {
         continue;
       }
-      if (Array.isArray(item)) {
+      if (isUnknownArray(item)) {
         stack.push(...[...item].reverse());
         continue;
       }
@@ -6396,6 +6416,12 @@ function appendQueryParam(queryParams, key, value) {
   }
   queryParams.append(key, String(value));
 }
+function serializePathParam(endpoint, key, value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  throw new Error(`Invalid path param for endpoint ${String(endpoint)}: ${key} must be a string`);
+}
 function invalidateCacheTags(tags, params) {
   const resolved = getRevalidateTag();
   if (typeof window !== "undefined" || !resolved || !tags) return;
@@ -6534,8 +6560,9 @@ function createRawCMSClient(headers = {}, baseUrl) {
         const bracePlaceholder = `{${key}}`;
         const colonPlaceholder = `:${key}`;
         if (originalPath.includes(bracePlaceholder) || originalPath.includes(colonPlaceholder)) {
-          url = url.replace(bracePlaceholder, value);
-          url = url.replace(colonPlaceholder, value);
+          const stringValue = serializePathParam(endpoint, key, value);
+          url = url.replace(bracePlaceholder, stringValue);
+          url = url.replace(colonPlaceholder, stringValue);
         } else {
           unusedParams[key] = value;
         }
@@ -6809,7 +6836,7 @@ var SimpleCache = class {
 };
 
 // src/version.ts
-var SDK_VERSION = "0.77.1";
+var SDK_VERSION = "0.78.2";
 
 // src/client/error.ts
 var RiverbankApiError = class _RiverbankApiError extends Error {
@@ -6954,6 +6981,22 @@ var RiverbankApiError = class _RiverbankApiError extends Error {
     return lines.join("\n");
   }
 };
+var resilienceStatusSymbol = /* @__PURE__ */ Symbol.for("riverbankcms.sdk.resilienceStatus");
+function attachResilienceStatusToError(error, resilienceStatus) {
+  const target = error !== null && (typeof error === "object" || typeof error === "function") ? error : new Error(error === void 0 ? "Unknown error" : String(error));
+  Object.defineProperty(target, resilienceStatusSymbol, {
+    configurable: true,
+    enumerable: false,
+    value: resilienceStatus
+  });
+  return target;
+}
+function getResilienceStatusFromError(error) {
+  if (error === null || typeof error !== "object" && typeof error !== "function") {
+    return void 0;
+  }
+  return error[resilienceStatusSymbol];
+}
 
 // src/client/resilience.ts
 var DEFAULT_RETRY_CONFIG = {
@@ -7212,7 +7255,10 @@ var CircuitOpenError = class extends Error {
 var prebuildModule = null;
 function tryRequire(modulePath) {
   try {
-    const req = Function('return typeof require === "function" ? require : null')();
+    const getRequire = new Function(
+      'return typeof require === "function" ? require : null'
+    );
+    const req = getRequire();
     return req ? req(modulePath) : null;
   } catch {
     return null;
@@ -7231,7 +7277,9 @@ function getPrebuildModule() {
     return null;
   }
   try {
-    prebuildModule = tryRequire("../prebuild/loader");
+    prebuildModule = tryRequire(
+      "../prebuild/loader"
+    );
     return prebuildModule;
   } catch {
     return null;
@@ -7291,7 +7339,9 @@ function normalizePublicFormResult(result) {
 }
 function normalizePublicFormsResponse(response) {
   return {
-    forms: response.forms.map((form) => normalizePublicFormResponse({ form }).form)
+    forms: response.forms.map(
+      (form) => normalizePublicFormResponse({ form }).form
+    )
   };
 }
 function normalizePublicFormsResult(result) {
@@ -7490,7 +7540,10 @@ function createRiverbankClient(config) {
       isDegraded = nowDegraded;
       config.resilience?.onDegradedMode?.(nowDegraded, status);
     }
-    return data;
+    return {
+      data,
+      resilience: status
+    };
   }
   async function resilientFetch(cacheKey, fetcher, options) {
     const requestId = generateRequestId2();
@@ -7514,25 +7567,43 @@ function createRiverbankClient(config) {
       if (allowFallbacks && !isPreview && staleIfError) {
         const stale = cache.getStale(cacheKey);
         if (stale) {
-          return emitStatus("stale", stale.value, statusDetails({
-            staleAgeSec: stale.staleAgeSec,
-            error: { code: "circuit_open", message: "Circuit breaker is open" }
-          }));
+          return emitStatus(
+            "stale",
+            stale.value,
+            statusDetails({
+              staleAgeSec: stale.staleAgeSec,
+              error: {
+                code: "circuit_open",
+                message: "Circuit breaker is open"
+              }
+            })
+          );
         }
       }
       if (allowFallbacks && !isPreview && options.prebuildFallback) {
         const prebuildResult = options.prebuildFallback();
         if (prebuildResult) {
-          return emitStatus("prebuild", prebuildResult.data, statusDetails({
-            prebuildAgeSec: prebuildResult.prebuildAgeSec,
-            error: { code: "circuit_open", message: "Circuit breaker is open" }
-          }));
+          return emitStatus(
+            "prebuild",
+            prebuildResult.data,
+            statusDetails({
+              prebuildAgeSec: prebuildResult.prebuildAgeSec,
+              error: {
+                code: "circuit_open",
+                message: "Circuit breaker is open"
+              }
+            })
+          );
         }
       }
       const circuitState = circuitBreaker.getState();
-      emitStatus("error", null, statusDetails({
-        error: { code: "circuit_open", message: "Circuit breaker is open" }
-      }));
+      emitStatus(
+        "error",
+        null,
+        statusDetails({
+          error: { code: "circuit_open", message: "Circuit breaker is open" }
+        })
+      );
       throw new CircuitOpenError(circuitState);
     }
     try {
@@ -7559,7 +7630,9 @@ function createRiverbankClient(config) {
         circuitBreaker.recordSuccess();
       } else {
         try {
-          const response = await fetcher(options.signal ?? new AbortController().signal);
+          const response = await fetcher(
+            options.signal ?? new AbortController().signal
+          );
           data = unwrapResponse(response);
         } catch (error) {
           convertToTypedError(error);
@@ -7576,28 +7649,51 @@ function createRiverbankClient(config) {
       if (allowFallbacks && !isPreview && staleIfError && cacheEnabled) {
         const stale = cache.getStale(cacheKey);
         if (stale) {
-          const errorInfo2 = error instanceof RiverbankApiError ? { code: error.code, message: error.message } : { message: error.message };
-          return emitStatus("stale", stale.value, statusDetails({
-            staleAgeSec: stale.staleAgeSec,
-            error: errorInfo2
-          }));
+          const errorInfo2 = error instanceof RiverbankApiError ? {
+            code: error.code,
+            message: error.message,
+            status: error.status
+          } : { message: error.message };
+          return emitStatus(
+            "stale",
+            stale.value,
+            statusDetails({
+              staleAgeSec: stale.staleAgeSec,
+              error: errorInfo2
+            })
+          );
         }
       }
       if (allowFallbacks && !isPreview && options.prebuildFallback) {
         const prebuildResult = options.prebuildFallback();
         if (prebuildResult) {
-          const errorInfo2 = error instanceof RiverbankApiError ? { code: error.code, message: error.message } : { message: error.message };
-          return emitStatus("prebuild", prebuildResult.data, statusDetails({
-            prebuildAgeSec: prebuildResult.prebuildAgeSec,
-            error: errorInfo2
-          }));
+          const errorInfo2 = error instanceof RiverbankApiError ? {
+            code: error.code,
+            message: error.message,
+            status: error.status
+          } : { message: error.message };
+          return emitStatus(
+            "prebuild",
+            prebuildResult.data,
+            statusDetails({
+              prebuildAgeSec: prebuildResult.prebuildAgeSec,
+              error: errorInfo2
+            })
+          );
         }
       }
-      const errorInfo = error instanceof RiverbankApiError ? { code: error.code, message: error.message } : { message: error.message };
-      emitStatus("error", null, statusDetails({ error: errorInfo }));
-      throw error;
+      const errorInfo = error instanceof RiverbankApiError ? { code: error.code, message: error.message, status: error.status } : { message: error.message };
+      const failure = emitStatus(
+        "error",
+        null,
+        statusDetails({ error: errorInfo })
+      );
+      throw attachResilienceStatusToError(error, failure.resilience);
     }
   }
+  async function resilientFetchData(cacheKey, fetcher, options) {
+    return (await resilientFetch(cacheKey, fetcher, options)).data;
+  }
   function combineAbortSignals(...signals) {
     const controller = new AbortController();
     for (const signal of signals) {
@@ -7605,32 +7701,45 @@ function createRiverbankClient(config) {
         controller.abort(signal.reason);
         break;
       }
-      signal.addEventListener("abort", () => controller.abort(signal.reason), { once: true });
+      signal.addEventListener("abort", () => controller.abort(signal.reason), {
+        once: true
+      });
     }
     return controller.signal;
   }
   async function resolveEntrySubrouteInternal(args) {
     const { siteId, entryId, kind, segment, stage, signal } = args;
     const cacheKey = `entry-subroute:${siteId}:${entryId}:${kind}:${segment}:${stage ?? "published"}`;
-    return resilientFetch(cacheKey, async (sig) => {
-      return await apiClient({
-        endpoint: "resolveEntrySubroute",
-        params: { siteId, entryId, kind, segment, ...stage ? { stage } : {} },
-        options: { signal: sig }
-      });
-    }, { signal });
+    return resilientFetchData(
+      cacheKey,
+      async (sig) => {
+        return await apiClient({
+          endpoint: "resolveEntrySubroute",
+          params: {
+            siteId,
+            entryId,
+            kind,
+            segment,
+            ...stage ? { stage } : {}
+          },
+          options: { signal: sig }
+        });
+      },
+      { signal }
+    );
   }
-  return {
-    async getSite(params) {
-      const { slug, domain, id, signal, force, currentPath } = params;
-      if (!slug && !domain && !id) {
-        throw new Error(
-          `getSite() requires at least one identifier: slug, domain, or id. Received: ${JSON.stringify(params)}`
-        );
-      }
-      const cacheKey = `site:${slug || domain || id}:${currentPath ?? ""}`;
-      const siteId = id || slug || domain;
-      return resilientFetch(cacheKey, async (sig) => {
+  async function getSiteWithResilienceInternal(params) {
+    const { slug, domain, id, signal, force, currentPath } = params;
+    if (!slug && !domain && !id) {
+      throw new Error(
+        `getSite() requires at least one identifier: slug, domain, or id. Received: ${JSON.stringify(params)}`
+      );
+    }
+    const cacheKey = `site:${slug || domain || id}:${currentPath ?? ""}`;
+    const siteId = id || slug || domain;
+    return resilientFetch(
+      cacheKey,
+      async (sig) => {
         const apiParams = {};
         if (params.slug) apiParams.slug = params.slug;
         if (params.domain) apiParams.domain = params.domain;
@@ -7641,66 +7750,121 @@ function createRiverbankClient(config) {
           endpoint: "getSite",
           params: apiParams,
           // When force=true, bypass Next.js fetch caching (revalidate) as well.
-          options: { signal: sig, ...force ? { cache: "no-store" } : {} }
+          options: {
+            signal: sig,
+            ...force ? { cache: "no-store" } : {}
+          }
         });
-      }, {
+      },
+      {
         signal,
         force,
         prebuildFallback: prebuildLoader && siteId ? () => prebuildLoader.loadSite(siteId) : void 0
-      });
-    },
-    async getPage(params) {
-      const { siteId, path: path3, preview = false, signal } = params;
-      const cacheKey = `page:${siteId}:${path3}:${preview}`;
-      return resilientFetch(cacheKey, async (sig) => {
-        return await apiClient({ endpoint: "getContentByPath", params: { siteId }, body: { path: path3, preview }, options: { signal: sig } });
-      }, {
+      }
+    );
+  }
+  async function getPageWithResilienceInternal(params) {
+    const { siteId, path: path3, preview = false, signal } = params;
+    const cacheKey = `page:${siteId}:${path3}:${preview}`;
+    return resilientFetch(
+      cacheKey,
+      async (sig) => {
+        return await apiClient({
+          endpoint: "getContentByPath",
+          params: { siteId, path: path3, preview: String(preview) },
+          options: { signal: sig }
+        });
+      },
+      {
         preview,
         signal,
         // Prebuild fallback only for published pages (not preview)
         prebuildFallback: prebuildLoader && !preview ? () => prebuildLoader.loadPage(siteId, path3) : void 0
-      });
+      }
+    );
+  }
+  return {
+    async getSite(params) {
+      return (await getSiteWithResilienceInternal(params)).data;
+    },
+    async getSiteWithResilience(params) {
+      return getSiteWithResilienceInternal(params);
+    },
+    async getPage(params) {
+      return (await getPageWithResilienceInternal(params)).data;
+    },
+    async getPageWithResilience(params) {
+      return getPageWithResilienceInternal(params);
     },
     async getEntries(params) {
-      const { siteId, contentType, limit, offset, order, preview = false, mode, entryIds, includeMeta, signal } = params;
+      const {
+        siteId,
+        contentType,
+        limit,
+        offset,
+        order,
+        preview = false,
+        mode,
+        entryIds,
+        includeMeta,
+        signal
+      } = params;
       const entryIdsCacheKey = mode === "manual" && entryIds?.length ? entryIds.join(",") : "";
       const cacheKey = `entries:${siteId}:${contentType}:${limit ?? ""}:${offset ?? ""}:${order ?? ""}:${preview}:${mode ?? ""}:${entryIdsCacheKey}:${includeMeta ?? ""}`;
-      return resilientFetch(cacheKey, async (sig) => {
-        let orderParam;
-        if (order === "newest") {
-          orderParam = "published_at.desc";
-        } else if (order === "oldest") {
-          orderParam = "published_at.asc";
-        } else if (order === "title") {
-          orderParam = "title.asc";
-        }
-        const apiParams = {
-          siteId,
-          type: contentType,
-          ...typeof limit === "number" && { limit: String(limit) },
-          ...typeof offset === "number" && { offset: String(offset) },
-          ...includeMeta && { meta: "true" },
-          ...orderParam && { order: orderParam },
-          ...preview && { stage: "preview" },
-          ...mode === "manual" && entryIds?.length && {
-            mode: "manual",
-            entryIds: JSON.stringify(entryIds)
+      return resilientFetchData(
+        cacheKey,
+        async (sig) => {
+          let orderParam;
+          if (order === "newest") {
+            orderParam = "published_at.desc";
+          } else if (order === "oldest") {
+            orderParam = "published_at.asc";
+          } else if (order === "title") {
+            orderParam = "title.asc";
+          } else if (order === "manual") {
+            orderParam = "manual.asc";
           }
-        };
-        return await apiClient({ endpoint: "listPublishedEntries", params: apiParams, options: { signal: sig } });
-      }, {
-        preview,
-        signal,
-        // Prebuild fallback only for published entries (not preview, not manual mode)
-        prebuildFallback: prebuildLoader && !preview ? () => prebuildLoader.loadEntries(siteId, params) : void 0
-      });
+          const apiParams = {
+            siteId,
+            type: contentType,
+            ...typeof limit === "number" && { limit: String(limit) },
+            ...typeof offset === "number" && { offset: String(offset) },
+            ...includeMeta && { meta: "true" },
+            ...orderParam && { order: orderParam },
+            ...preview && { stage: "preview" },
+            ...mode === "manual" && entryIds?.length && {
+              mode: "manual",
+              entryIds: JSON.stringify(entryIds)
+            }
+          };
+          return await apiClient({
+            endpoint: "listPublishedEntries",
+            params: apiParams,
+            options: { signal: sig }
+          });
+        },
+        {
+          preview,
+          signal,
+          // Prebuild fallback only for published entries (not preview, not manual mode)
+          prebuildFallback: prebuildLoader && !preview ? () => prebuildLoader.loadEntries(siteId, params) : void 0
+        }
+      );
     },
     async getEntry(params) {
       const { siteId, contentType, slug, signal } = params;
       const cacheKey = `entry:${siteId}:${contentType}:${slug}`;
-      return resilientFetch(cacheKey, async (sig) => {
-        return await apiClient({ endpoint: "getPublishedEntryPreview", params: { siteId, type: contentType, slug }, options: { signal: sig } });
-      }, { signal });
+      return resilientFetchData(
+        cacheKey,
+        async (sig) => {
+          return await apiClient({
+            endpoint: "getPublishedEntryPreview",
+            params: { siteId, type: contentType, slug },
+            options: { signal: sig }
+          });
+        },
+        { signal }
+      );
     },
     async getPublicFormById(params) {
       const { formId, siteId, signal } = params;
@@ -7708,10 +7872,18 @@ function createRiverbankClient(config) {
         throw new Error("getPublicFormById() requires formId and siteId");
       }
       const cacheKey = `public-form:${siteId}:${formId}`;
-      return resilientFetch(cacheKey, async (sig) => {
-        const response = await apiClient({ endpoint: "getPublicFormById", params: { formId, siteId }, options: { signal: sig } });
-        return normalizePublicFormResult(response);
-      }, { signal });
+      return resilientFetchData(
+        cacheKey,
+        async (sig) => {
+          const response = await apiClient({
+            endpoint: "getPublicFormById",
+            params: { formId, siteId },
+            options: { signal: sig }
+          });
+          return normalizePublicFormResult(response);
+        },
+        { signal }
+      );
     },
     async getForms(params) {
       const { siteId, signal } = params;
@@ -7719,34 +7891,42 @@ function createRiverbankClient(config) {
         throw new Error("getForms() requires siteId");
       }
       const cacheKey = `forms:${siteId}`;
-      return resilientFetch(cacheKey, async (sig) => {
-        const response = await apiClient({ endpoint: "listPublicForms", params: { siteId }, options: { signal: sig } });
-        return normalizePublicFormsResult(response);
-      }, {
-        signal,
-        prebuildFallback: prebuildLoader ? () => {
-          const result = prebuildLoader.loadForms();
-          if (result) {
-            return {
-              data: {
-                forms: result.data.map((form) => ({
-                  id: form.id,
-                  slug: form.slug,
-                  name: form.name,
-                  schema: form.schema,
-                  settings: form.settings,
-                  schemaJson: form.schema,
-                  settingsJson: form.settings,
-                  createdAt: null,
-                  updatedAt: null
-                }))
-              },
-              prebuildAgeSec: result.prebuildAgeSec
-            };
-          }
-          return null;
-        } : void 0
-      });
+      return resilientFetchData(
+        cacheKey,
+        async (sig) => {
+          const response = await apiClient({
+            endpoint: "listPublicForms",
+            params: { siteId },
+            options: { signal: sig }
+          });
+          return normalizePublicFormsResult(response);
+        },
+        {
+          signal,
+          prebuildFallback: prebuildLoader ? () => {
+            const result = prebuildLoader.loadForms();
+            if (result) {
+              return {
+                data: {
+                  forms: result.data.map((form) => ({
+                    id: form.id,
+                    slug: form.slug,
+                    name: form.name,
+                    schema: form.schema,
+                    settings: form.settings,
+                    schemaJson: form.schema,
+                    settingsJson: form.settings,
+                    createdAt: null,
+                    updatedAt: null
+                  }))
+                },
+                prebuildAgeSec: result.prebuildAgeSec
+              };
+            }
+            return null;
+          } : void 0
+        }
+      );
     },
     async getPublicBookingServices(params) {
       const { siteId, ids, signal } = params;
@@ -7754,13 +7934,21 @@ function createRiverbankClient(config) {
         throw new Error("getPublicBookingServices() requires siteId");
       }
       const cacheKey = `public-booking-services:${siteId}:${ids ?? ""}`;
-      return resilientFetch(cacheKey, async (sig) => {
-        const apiParams = {
-          siteId,
-          ...ids && { ids }
-        };
-        return await apiClient({ endpoint: "getPublicBookingServices", params: apiParams, options: { signal: sig } });
-      }, { signal });
+      return resilientFetchData(
+        cacheKey,
+        async (sig) => {
+          const apiParams = {
+            siteId,
+            ...ids && { ids }
+          };
+          return await apiClient({
+            endpoint: "getPublicBookingServices",
+            params: apiParams,
+            options: { signal: sig }
+          });
+        },
+        { signal }
+      );
     },
     async listPublicEvents(params) {
       const {
@@ -7781,22 +7969,30 @@ function createRiverbankClient(config) {
         throw new Error("listPublicEvents() requires siteId");
       }
       const cacheKey = `public-events:${siteId}:${limit ?? ""}:${from ?? ""}:${to ?? ""}:${stage ?? ""}:${categoryIds ?? ""}:${venueId ?? ""}:${kind ?? ""}:${entryId ?? ""}:${seriesId ?? ""}:${includeOccurrenceId ?? ""}`;
-      return resilientFetch(cacheKey, async (sig) => {
-        const apiParams = {
-          siteId,
-          ...typeof limit === "number" && { limit: String(limit) },
-          ...from && { from },
-          ...to && { to },
-          ...stage && { stage },
-          ...categoryIds && { categoryIds },
-          ...venueId && { venueId },
-          ...kind && { kind },
-          ...entryId && { entryId },
-          ...seriesId && { seriesId },
-          ...includeOccurrenceId && { includeOccurrenceId }
-        };
-        return await apiClient({ endpoint: "listPublicEvents", params: apiParams, options: { signal: sig } });
-      }, { signal });
+      return resilientFetchData(
+        cacheKey,
+        async (sig) => {
+          const apiParams = {
+            siteId,
+            ...typeof limit === "number" && { limit: String(limit) },
+            ...from && { from },
+            ...to && { to },
+            ...stage && { stage },
+            ...categoryIds && { categoryIds },
+            ...venueId && { venueId },
+            ...kind && { kind },
+            ...entryId && { entryId },
+            ...seriesId && { seriesId },
+            ...includeOccurrenceId && { includeOccurrenceId }
+          };
+          return await apiClient({
+            endpoint: "listPublicEvents",
+            params: apiParams,
+            options: { signal: sig }
+          });
+        },
+        { signal }
+      );
     },
     async getPublicEventDetails(params) {
       const {
@@ -7820,37 +8016,44 @@ function createRiverbankClient(config) {
         throw new Error("getPublicEventDetails() requires siteId");
       }
       const cacheKey = `public-event-details:${siteId}:${limit ?? ""}:${from ?? ""}:${to ?? ""}:${afterStartsAt ?? ""}:${afterId ?? ""}:${stage ?? ""}:${categoryIds ?? ""}:${venueId ?? ""}:${staffMemberId ?? ""}:${kind ?? ""}:${entryId ?? ""}:${seriesId ?? ""}:${includeOccurrenceId ?? ""}`;
-      return resilientFetch(cacheKey, async (sig) => {
-        const requestId = "eventDetails";
-        const response = await apiClient({
-          endpoint: "batchBlockLoaders",
-          params: { siteId, ...stage && { stage } },
-          body: {
-            requests: [
-              {
-                id: requestId,
-                endpoint: "getPublicEventDetails",
-                params: {
-                  ...typeof limit === "number" && { limit: String(limit) },
-                  ...from && { from },
-                  ...to && { to },
-                  ...afterStartsAt && { afterStartsAt },
-                  ...afterId && { afterId },
-                  ...categoryIds && { categoryIds },
-                  ...venueId && { venueId },
-                  ...staffMemberId && { staffMemberId },
-                  ...kind && { kind },
-                  ...entryId && { entryId },
-                  ...seriesId && { seriesId },
-                  ...includeOccurrenceId && { includeOccurrenceId }
+      return resilientFetchData(
+        cacheKey,
+        async (sig) => {
+          const requestId = "eventDetails";
+          const response = await apiClient({
+            endpoint: "batchBlockLoaders",
+            params: { siteId, ...stage && { stage } },
+            body: {
+              requests: [
+                {
+                  id: requestId,
+                  endpoint: "getPublicEventDetails",
+                  params: {
+                    ...typeof limit === "number" && { limit: String(limit) },
+                    ...from && { from },
+                    ...to && { to },
+                    ...afterStartsAt && { afterStartsAt },
+                    ...afterId && { afterId },
+                    ...categoryIds && { categoryIds },
+                    ...venueId && { venueId },
+                    ...staffMemberId && { staffMemberId },
+                    ...kind && { kind },
+                    ...entryId && { entryId },
+                    ...seriesId && { seriesId },
+                    ...includeOccurrenceId && { includeOccurrenceId }
+                  }
                 }
-              }
-            ]
-          },
-          options: { signal: sig }
-        });
-        return normalizeBatchBlockLoaderResult(response, requestId);
-      }, { signal });
+              ]
+            },
+            options: { signal: sig }
+          });
+          return normalizeBatchBlockLoaderResult(
+            response,
+            requestId
+          );
+        },
+        { signal }
+      );
     },
     async listPublicCourses(params) {
       const { siteId, limit, stage, signal } = params;
@@ -7858,14 +8061,22 @@ function createRiverbankClient(config) {
         throw new Error("listPublicCourses() requires siteId");
       }
       const cacheKey = `public-courses:${siteId}:${limit ?? ""}:${stage ?? ""}`;
-      return resilientFetch(cacheKey, async (sig) => {
-        const apiParams = {
-          siteId,
-          ...typeof limit === "number" && { limit: String(limit) },
-          ...stage && { stage }
-        };
-        return await apiClient({ endpoint: "listPublicCourses", params: apiParams, options: { signal: sig } });
-      }, { signal });
+      return resilientFetchData(
+        cacheKey,
+        async (sig) => {
+          const apiParams = {
+            siteId,
+            ...typeof limit === "number" && { limit: String(limit) },
+            ...stage && { stage }
+          };
+          return await apiClient({
+            endpoint: "listPublicCourses",
+            params: apiParams,
+            options: { signal: sig }
+          });
+        },
+        { signal }
+      );
     },
     async listPublicTeamMembers(params) {
       const { siteId, stage, signal } = params;
@@ -7873,17 +8084,21 @@ function createRiverbankClient(config) {
         throw new Error("listPublicTeamMembers() requires siteId");
       }
       const cacheKey = `public-team-members:${siteId}:${stage ?? ""}`;
-      return resilientFetch(cacheKey, async (sig) => {
-        const apiParams = {
-          siteId,
-          ...stage && { stage }
-        };
-        return await apiClient({
-          endpoint: "listPublicTeamMembers",
-          params: apiParams,
-          options: { signal: sig }
-        });
-      }, { signal });
+      return resilientFetchData(
+        cacheKey,
+        async (sig) => {
+          const apiParams = {
+            siteId,
+            ...stage && { stage }
+          };
+          return await apiClient({
+            endpoint: "listPublicTeamMembers",
+            params: apiParams,
+            options: { signal: sig }
+          });
+        },
+        { signal }
+      );
     },
     async listPublicProducts(params) {
       const { siteId, stage, categorySelector, signal } = params;
@@ -7892,14 +8107,22 @@ function createRiverbankClient(config) {
       }
       const selectorKey = categorySelector ? categorySelector.kind === "category" ? `category:${categorySelector.productCategoryId}` : `current-category-page:${categorySelector.productCategoryEntryId}` : "";
       const cacheKey = `public-products:${siteId}:${stage ?? ""}:${selectorKey}`;
-      return resilientFetch(cacheKey, async (sig) => {
-        const apiParams = {
-          siteId,
-          ...stage && { stage },
-          ...encodePublicProductCategorySelector(categorySelector)
-        };
-        return await apiClient({ endpoint: "listPublicProducts", params: apiParams, options: { signal: sig } });
-      }, { signal });
+      return resilientFetchData(
+        cacheKey,
+        async (sig) => {
+          const apiParams = {
+            siteId,
+            ...stage && { stage },
+            ...encodePublicProductCategorySelector(categorySelector)
+          };
+          return await apiClient({
+            endpoint: "listPublicProducts",
+            params: apiParams,
+            options: { signal: sig }
+          });
+        },
+        { signal }
+      );
     },
     async listPublicPasses(params) {
       const { siteId, categories, signal } = params;
@@ -7907,13 +8130,21 @@ function createRiverbankClient(config) {
         throw new Error("listPublicPasses() requires siteId");
       }
       const cacheKey = `public-passes:${siteId}:${categories ?? ""}`;
-      return resilientFetch(cacheKey, async (sig) => {
-        const apiParams = {
-          siteId,
-          ...categories && { categories }
-        };
-        return await apiClient({ endpoint: "listPublicPasses", params: apiParams, options: { signal: sig } });
-      }, { signal });
+      return resilientFetchData(
+        cacheKey,
+        async (sig) => {
+          const apiParams = {
+            siteId,
+            ...categories && { categories }
+          };
+          return await apiClient({
+            endpoint: "listPublicPasses",
+            params: apiParams,
+            options: { signal: sig }
+          });
+        },
+        { signal }
+      );
     },
     async listPublicMemberships(params) {
       const { siteId, categories, signal } = params;
@@ -7921,25 +8152,44 @@ function createRiverbankClient(config) {
         throw new Error("listPublicMemberships() requires siteId");
       }
       const cacheKey = `public-memberships:${siteId}:${categories ?? ""}`;
-      return resilientFetch(cacheKey, async (sig) => {
-        const apiParams = {
-          siteId,
-          ...categories && { categories }
-        };
-        return await apiClient({ endpoint: "listPublicMemberships", params: apiParams, options: { signal: sig } });
-      }, { signal });
+      return resilientFetchData(
+        cacheKey,
+        async (sig) => {
+          const apiParams = {
+            siteId,
+            ...categories && { categories }
+          };
+          return await apiClient({
+            endpoint: "listPublicMemberships",
+            params: apiParams,
+            options: { signal: sig }
+          });
+        },
+        { signal }
+      );
     },
     async resolveEntrySubroute(params) {
       const { siteId, entryId, kind, segment, stage, signal } = params;
       if (!siteId || !entryId || !kind || !segment) {
-        throw new Error("resolveEntrySubroute() requires siteId, entryId, kind, and segment");
+        throw new Error(
+          "resolveEntrySubroute() requires siteId, entryId, kind, and segment"
+        );
       }
-      return resolveEntrySubrouteInternal({ siteId, entryId, kind, segment, stage, signal });
+      return resolveEntrySubrouteInternal({
+        siteId,
+        entryId,
+        kind,
+        segment,
+        stage,
+        signal
+      });
     },
     async resolveEventOccurrence(params) {
       const { siteId, entryId, segment, signal } = params;
       if (!siteId || !entryId || !segment) {
-        throw new Error("resolveEventOccurrence() requires siteId, entryId, and segment");
+        throw new Error(
+          "resolveEventOccurrence() requires siteId, entryId, and segment"
+        );
       }
       const result = await resolveEntrySubrouteInternal({
         siteId,
@@ -7958,13 +8208,17 @@ function createRiverbankClient(config) {
         throw new Error("checkRedirect() requires siteId and path");
       }
       const cacheKey = `redirect:${siteId}:${path3}`;
-      return resilientFetch(cacheKey, async (sig) => {
-        return await apiClient({
-          endpoint: "checkRedirect",
-          params: { site: siteId, path: path3 },
-          options: { signal: sig }
-        });
-      }, { signal });
+      return resilientFetchData(
+        cacheKey,
+        async (sig) => {
+          return await apiClient({
+            endpoint: "checkRedirect",
+            params: { site: siteId, path: path3 },
+            options: { signal: sig }
+          });
+        },
+        { signal }
+      );
     },
     async getAllPublishedRoutes(params) {
       const { siteId, signal } = params;
@@ -7972,13 +8226,17 @@ function createRiverbankClient(config) {
         throw new Error("getAllPublishedRoutes() requires siteId");
       }
       const cacheKey = `routable-content:${siteId}:published`;
-      return resilientFetch(cacheKey, async (sig) => {
-        return await apiClient({
-          endpoint: "getPublicRoutableContent",
-          params: { siteId, publishedOnly: "true" },
-          options: { signal: sig }
-        });
-      }, { signal });
+      return resilientFetchData(
+        cacheKey,
+        async (sig) => {
+          return await apiClient({
+            endpoint: "getPublicRoutableContent",
+            params: { siteId, publishedOnly: "true" },
+            options: { signal: sig }
+          });
+        },
+        { signal }
+      );
     },
     async getSitemapRoutes(params) {
       const { siteId, page, pageSize, signal } = params;
@@ -7986,17 +8244,21 @@ function createRiverbankClient(config) {
         throw new Error("getSitemapRoutes() requires siteId");
       }
       const cacheKey = `sitemap:${siteId}:${page ?? 1}:${pageSize ?? "default"}`;
-      return resilientFetch(cacheKey, async (sig) => {
-        return await apiClient({
-          endpoint: "getPublicSitemapRoutes",
-          params: {
-            siteId,
-            ...page ? { page: String(page) } : {},
-            ...pageSize ? { pageSize: String(pageSize) } : {}
-          },
-          options: { signal: sig }
-        });
-      }, { signal });
+      return resilientFetchData(
+        cacheKey,
+        async (sig) => {
+          return await apiClient({
+            endpoint: "getPublicSitemapRoutes",
+            params: {
+              siteId,
+              ...page ? { page: String(page) } : {},
+              ...pageSize ? { pageSize: String(pageSize) } : {}
+            },
+            options: { signal: sig }
+          });
+        },
+        { signal }
+      );
     },
     clearCache() {
       cache.clear();
@@ -8833,5 +9095,6 @@ export {
   canUsePrebuild,
   createPrebuildLoader,
   createRiverbankClient,
+  getResilienceStatusFromError,
   prebuildCache
 };