@riverbankcms/sdk 0.7.0 → 0.7.2

package/dist/client/client.js

@@ -17332,10 +17332,10 @@ function resolveApiBaseUrl() {
 var revalidateTag = null;
 if (typeof window === "undefined") {
   try {
-    const nextCache = require("next/cache");
-    revalidateTag = nextCache.revalidateTag;
+    const dynamicRequire = new Function("modulePath", "return require(modulePath)");
+    const nextCache = dynamicRequire("next/cache");
+    revalidateTag = nextCache.revalidateTag ?? null;
   } catch {
-    revalidateTag = null;
   }
 }
 var sdkVersion;
@@ -17364,8 +17364,22 @@ var ApiRequestError = class extends Error {
     this.body = options.body;
     this.cause = options.cause;
     this.errorCode = options.errorCode;
+    this.retryAfterMs = options.retryAfterMs;
   }
 };
+function parseRetryAfterHeader(headerValue) {
+  if (!headerValue) return void 0;
+  if (/^\d+$/.test(headerValue)) {
+    const seconds = parseInt(headerValue, 10);
+    return seconds * 1e3;
+  }
+  const date = new Date(headerValue);
+  if (!isNaN(date.getTime())) {
+    const delayMs = date.getTime() - Date.now();
+    return delayMs > 0 ? delayMs : void 0;
+  }
+  return void 0;
+}
 function buildEndpointURL(baseURL, endpoint) {
   return baseURL + API_ENDPOINTS[endpoint].path;
 }
@@ -17582,6 +17596,7 @@ function createParsedClient(rawClient) {
     if (!response.ok) {
       const body = await parseErrorBody(response);
       const requestId = response.headers.get("x-request-id") ?? void 0;
+      const retryAfterMs = parseRetryAfterHeader(response.headers.get("retry-after"));
       throw new ApiRequestError(
         `Request to ${String(endpoint)} failed with status ${response.status}`,
         {
@@ -17590,7 +17605,8 @@ function createParsedClient(rawClient) {
           method: config.method,
           auth,
           requestId,
-          body
+          body,
+          retryAfterMs
         }
       );
     }
@@ -17638,38 +17654,117 @@ var SimpleCache = class {
     this.cache = /* @__PURE__ */ new Map();
     this.maxSize = options.maxSize ?? 100;
     this.ttl = options.ttl ?? 3e5;
+    this.staleTtl = options.staleTtl ?? 3e5;
+  }
+  /**
+   * Get a fresh value (within TTL)
+   * @returns The value if fresh, null otherwise
+   */
+  getFresh(key) {
+    const entry = this.cache.get(key);
+    if (!entry) return null;
+    const now = Date.now();
+    if (now <= entry.freshUntil) {
+      return entry.value;
+    }
+    return null;
   }
-  get(key) {
+  /**
+   * Get a value that may be stale (past TTL but within staleTtl)
+   * @returns Object with value and stale age, or null if expired
+   */
+  getStale(key) {
     const entry = this.cache.get(key);
-    if (!entry) return void 0;
-    if (Date.now() > entry.expires) {
+    if (!entry) return null;
+    const now = Date.now();
+    if (now > entry.staleUntil) {
       this.cache.delete(key);
-      return void 0;
+      return null;
     }
-    return entry.value;
+    const staleAgeSec = now <= entry.freshUntil ? 0 : Math.floor((now - entry.freshUntil) / 1e3);
+    return {
+      value: entry.value,
+      staleAgeSec
+    };
   }
-  set(key, value) {
-    if (this.cache.size >= this.maxSize) {
-      const firstKey = this.cache.keys().next().value;
-      if (firstKey) {
-        this.cache.delete(firstKey);
-      }
+  /**
+   * Store a value with TTL and stale window
+   */
+  set(key, value, options) {
+    const ttl = options?.ttl ?? this.ttl;
+    const staleTtl = options?.staleTtl ?? this.staleTtl;
+    const now = Date.now();
+    if (this.cache.size >= this.maxSize && !this.cache.has(key)) {
+      this.evictOne(now);
     }
     this.cache.set(key, {
       value,
-      expires: Date.now() + this.ttl
+      createdAt: now,
+      freshUntil: now + ttl,
+      staleUntil: now + ttl + staleTtl
     });
   }
+  /**
+   * Evict one entry to make room for a new one
+   * Priority: oldest stale entry, then oldest fresh entry
+   */
+  evictOne(now) {
+    let oldestStaleKey = null;
+    let oldestStaleTime = Infinity;
+    let oldestFreshKey = null;
+    let oldestFreshTime = Infinity;
+    for (const [key, entry] of this.cache) {
+      if (now > entry.freshUntil) {
+        if (entry.createdAt < oldestStaleTime) {
+          oldestStaleTime = entry.createdAt;
+          oldestStaleKey = key;
+        }
+      } else {
+        if (entry.createdAt < oldestFreshTime) {
+          oldestFreshTime = entry.createdAt;
+          oldestFreshKey = key;
+        }
+      }
+    }
+    const keyToEvict = oldestStaleKey ?? oldestFreshKey;
+    if (keyToEvict) {
+      this.cache.delete(keyToEvict);
+    }
+  }
+  /**
+   * Remove all fully expired entries (past staleUntil)
+   */
+  prune() {
+    const now = Date.now();
+    for (const [key, entry] of this.cache) {
+      if (now > entry.staleUntil) {
+        this.cache.delete(key);
+      }
+    }
+  }
+  /**
+   * Clear all entries
+   */
   clear() {
     this.cache.clear();
   }
+  /**
+   * Check if a key exists and is not fully expired
+   */
   has(key) {
-    return this.get(key) !== void 0;
+    const entry = this.cache.get(key);
+    if (!entry) return false;
+    const now = Date.now();
+    if (now > entry.staleUntil) {
+      this.cache.delete(key);
+      return false;
+    }
+    return now <= entry.freshUntil;
   }
 };
 
 // src/version.ts
-var SDK_VERSION = "0.7.0";
+var SDK_VERSION = "0.7.2";
 
 // src/client/error.ts
 var RiverbankApiError = class _RiverbankApiError extends Error {
@@ -17681,8 +17776,31 @@ var RiverbankApiError = class _RiverbankApiError extends Error {
     this.status = apiError.status;
     this.fieldErrors = apiError.fieldErrors;
     this.timestamp = apiError.timestamp;
+    this.retryAfterMs = "retryAfterMs" in apiError ? apiError.retryAfterMs : void 0;
+    this.isRetryable = this.computeRetryable();
     Object.setPrototypeOf(this, _RiverbankApiError.prototype);
   }
+  /**
+   * Compute whether this error is retryable based on HTTP status code.
+   * - 0 (network errors - no HTTP response): retryable
+   * - 429 (rate limit): retryable
+   * - 5xx (server errors): retryable
+   * - 4xx (client errors, except 429): NOT retryable
+   */
+  computeRetryable() {
+    if (this.status === 0) return true;
+    if (this.status === 429) return true;
+    if (this.status >= 500) return true;
+    return false;
+  }
+  /**
+   * Check if this is a network error (no HTTP response received)
+   *
+   * Matches: network:connection_error, network:timeout, network:dns_error
+   */
+  isNetworkError() {
+    return this.code.startsWith("network:");
+  }
   /**
    * Check if this error matches a specific error code
    *
@@ -17741,9 +17859,215 @@ var RiverbankApiError = class _RiverbankApiError extends Error {
   }
 };
 
+// src/client/resilience.ts
+var DEFAULT_RETRY_CONFIG = {
+  maxAttempts: 3,
+  baseDelayMs: 200,
+  maxDelayMs: 2e3,
+  jitter: "full"
+};
+var DEFAULT_CIRCUIT_BREAKER_CONFIG = {
+  failureThreshold: 5,
+  resetTimeoutMs: 3e4,
+  halfOpenMaxRequests: 2
+};
+function isTransientError(error) {
+  if (error instanceof RiverbankApiError) {
+    if (error.status === 0) return true;
+    if (error.status === 429) return true;
+    if (error.status >= 500) return true;
+    return false;
+  }
+  return true;
+}
+function calculateBackoff(attempt, config) {
+  const baseDelayMs = config.baseDelayMs ?? DEFAULT_RETRY_CONFIG.baseDelayMs;
+  const maxDelayMs = config.maxDelayMs ?? DEFAULT_RETRY_CONFIG.maxDelayMs;
+  const jitter = config.jitter ?? DEFAULT_RETRY_CONFIG.jitter;
+  const exponential = baseDelayMs * Math.pow(2, attempt - 1);
+  const capped = Math.min(exponential, maxDelayMs);
+  if (jitter === "full") {
+    return Math.random() * capped;
+  }
+  return capped;
+}
+var CircuitBreaker = class {
+  constructor(config) {
+    this.state = "closed";
+    this.failureCount = 0;
+    this.successCount = 0;
+    this.openUntil = 0;
+    this.halfOpenRequests = 0;
+    this.config = {
+      failureThreshold: config?.failureThreshold ?? DEFAULT_CIRCUIT_BREAKER_CONFIG.failureThreshold,
+      resetTimeoutMs: config?.resetTimeoutMs ?? DEFAULT_CIRCUIT_BREAKER_CONFIG.resetTimeoutMs,
+      halfOpenMaxRequests: config?.halfOpenMaxRequests ?? DEFAULT_CIRCUIT_BREAKER_CONFIG.halfOpenMaxRequests
+    };
+  }
+  /**
+   * Check if circuit is open (requests should be blocked)
+   * Also handles automatic transition from open to half-open after timeout
+   */
+  isOpen() {
+    if (this.state === "open" && Date.now() >= this.openUntil) {
+      this.transitionTo("half-open");
+    }
+    return this.state === "open";
+  }
+  /**
+   * Check if a request can be attempted
+   * - closed: always yes
+   * - open: always no
+   * - half-open: limited number of probes
+   */
+  canAttempt() {
+    if (this.state === "closed") return true;
+    if (this.state === "open") return false;
+    return this.halfOpenRequests < this.config.halfOpenMaxRequests;
+  }
+  /**
+   * Increment half-open request counter (call before making request in half-open)
+   */
+  incrementHalfOpenRequests() {
+    if (this.state === "half-open") {
+      this.halfOpenRequests++;
+    }
+  }
+  /**
+   * Record a successful request
+   */
+  recordSuccess() {
+    if (this.state === "half-open") {
+      this.successCount++;
+      if (this.successCount >= this.config.halfOpenMaxRequests) {
+        this.transitionTo("closed");
+      }
+    } else {
+      this.failureCount = 0;
+    }
+  }
+  /**
+   * Record a failed request
+   * Only counts transient failures toward circuit breaker threshold
+   */
+  recordFailure(error) {
+    if (!isTransientError(error)) return;
+    this.failureCount++;
+    if (this.state === "half-open") {
+      this.transitionTo("open");
+    } else if (this.failureCount >= this.config.failureThreshold) {
+      this.transitionTo("open");
+    }
+  }
+  /**
+   * Get current circuit state
+   */
+  getState() {
+    return {
+      state: this.state,
+      failureCount: this.failureCount,
+      openUntil: this.state === "open" ? this.openUntil : void 0
+    };
+  }
+  /**
+   * Transition to a new state
+   */
+  transitionTo(newState) {
+    this.state = newState;
+    if (newState === "open") {
+      this.openUntil = Date.now() + this.config.resetTimeoutMs;
+    } else if (newState === "half-open") {
+      this.halfOpenRequests = 0;
+      this.successCount = 0;
+    } else if (newState === "closed") {
+      this.failureCount = 0;
+      this.successCount = 0;
+      this.halfOpenRequests = 0;
+    }
+  }
+};
+async function fetchWithTimeoutAndRetry(fetcher, config) {
+  const maxAttempts = config.maxAttempts ?? DEFAULT_RETRY_CONFIG.maxAttempts;
+  const requestTimeoutMs = config.requestTimeoutMs ?? 8e3;
+  let lastError;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), requestTimeoutMs);
+      try {
+        const result = await fetcher(controller.signal);
+        return result;
+      } finally {
+        clearTimeout(timeoutId);
+      }
+    } catch (error) {
+      lastError = error;
+      const shouldRetry = shouldRetryError(error, config.retryOn);
+      if (!shouldRetry) {
+        throw error;
+      }
+      if (attempt < maxAttempts) {
+        const delay = getRetryDelay(error, attempt, config);
+        await sleep(delay);
+      }
+    }
+  }
+  throw lastError;
+}
+function shouldRetryError(error, customRetryOn) {
+  if (customRetryOn) {
+    const statusCode = error instanceof RiverbankApiError ? error.status : void 0;
+    return customRetryOn(error, statusCode);
+  }
+  return isTransientError(error);
+}
+function getRetryDelay(error, attempt, config) {
+  if (error instanceof RiverbankApiError && error.retryAfterMs) {
+    return error.retryAfterMs;
+  }
+  return calculateBackoff(attempt, config);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var CircuitOpenError = class extends Error {
+  constructor(state) {
+    super("Circuit breaker is open");
+    this.name = "CircuitOpenError";
+    this.circuitState = state;
+  }
+};
+
 // src/client/index.ts
 setSdkVersion(SDK_VERSION);
+var DEFAULT_BROWSER_TIMEOUT_MS = 5e3;
+var DEFAULT_SERVER_TIMEOUT_MS = 8e3;
+function generateRequestId2() {
+  return `req-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+}
+function isAbortError(error) {
+  if (error instanceof DOMException && error.name === "AbortError") {
+    return true;
+  }
+  if (error instanceof Error && error.name === "AbortError") {
+    return true;
+  }
+  return false;
+}
+function getNetworkErrorCode(error) {
+  const message = error.message.toLowerCase();
+  if (message.includes("timeout") || message.includes("timed out")) {
+    return "network:timeout";
+  }
+  if (message.includes("dns") || message.includes("getaddrinfo") || message.includes("enotfound")) {
+    return "network:dns_error";
+  }
+  return "network:connection_error";
+}
 function convertToTypedError(error) {
+  if (isAbortError(error)) {
+    throw error;
+  }
   if (error instanceof ApiEnvelopeError) {
     throw new RiverbankApiError({
       code: error.code,
@@ -17757,15 +18081,30 @@ function convertToTypedError(error) {
   if (error instanceof ApiRequestError && error.body && typeof error.body === "object") {
     const body = error.body;
     if (isApiError(body)) {
-      throw new RiverbankApiError(body.error);
+      const envelopeError = body.error;
+      throw new RiverbankApiError({
+        ...envelopeError,
+        retryAfterMs: error.retryAfterMs
+      });
     }
   }
+  if (error instanceof TypeError || error instanceof Error && !("status" in error)) {
+    const networkError = error;
+    throw new RiverbankApiError({
+      code: getNetworkErrorCode(networkError),
+      message: networkError.message || "Network request failed",
+      requestId: `local-${Date.now()}`,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      status: 0
+      // No HTTP response received
+    });
+  }
   throw error;
 }
 function createRiverbankClient(config) {
   if (!config.baseUrl) {
     throw new Error(
-      "baseUrl is required when creating a Builder client. Expected format: https://dashboard.example.com/api (must include /api path)"
+      "baseUrl is required when creating a Riverbank client. Expected format: https://dashboard.example.com/api (must include /api path)"
     );
   }
   if (!config.baseUrl.endsWith("/api")) {
@@ -17776,59 +18115,179 @@ function createRiverbankClient(config) {
   const cacheEnabled = config.cache?.enabled ?? true;
   const cacheTTL = (config.cache?.ttl ?? 300) * 1e3;
   const cacheMaxSize = config.cache?.maxSize ?? 100;
+  const resilienceEnabled = config.resilience?.enabled ?? true;
+  const staleIfError = config.resilience?.staleIfError ?? true;
+  const staleTtlMs = (config.resilience?.staleTtlSec ?? 300) * 1e3;
+  const requestTimeoutMs = config.resilience?.requestTimeoutMs ?? (typeof window !== "undefined" ? DEFAULT_BROWSER_TIMEOUT_MS : DEFAULT_SERVER_TIMEOUT_MS);
+  const retryConfig = {
+    maxAttempts: config.resilience?.retry?.maxAttempts ?? DEFAULT_RETRY_CONFIG.maxAttempts,
+    baseDelayMs: config.resilience?.retry?.baseDelayMs ?? DEFAULT_RETRY_CONFIG.baseDelayMs,
+    maxDelayMs: config.resilience?.retry?.maxDelayMs ?? DEFAULT_RETRY_CONFIG.maxDelayMs,
+    jitter: config.resilience?.retry?.jitter ?? DEFAULT_RETRY_CONFIG.jitter,
+    retryOn: config.resilience?.retry?.retryOn
+  };
+  const circuitBreakerConfig = {
+    failureThreshold: config.resilience?.circuitBreaker?.failureThreshold ?? DEFAULT_CIRCUIT_BREAKER_CONFIG.failureThreshold,
+    resetTimeoutMs: config.resilience?.circuitBreaker?.resetTimeoutMs ?? DEFAULT_CIRCUIT_BREAKER_CONFIG.resetTimeoutMs,
+    halfOpenMaxRequests: config.resilience?.circuitBreaker?.halfOpenMaxRequests ?? DEFAULT_CIRCUIT_BREAKER_CONFIG.halfOpenMaxRequests
+  };
   const apiClient = createBearerAPIClient(config.apiKey, config.baseUrl);
   const cache = new SimpleCache({
     maxSize: cacheMaxSize,
-    ttl: cacheTTL
+    ttl: cacheTTL,
+    staleTtl: staleTtlMs
   });
-  async function cachedFetch(cacheKey, fetcher, options) {
-    if (cacheEnabled && !options?.force) {
-      const cached = cache.get(cacheKey);
-      if (cached !== void 0) {
-        return cached;
+  const circuitBreaker = new CircuitBreaker(circuitBreakerConfig);
+  let lastStatus = null;
+  let isDegraded = false;
+  function emitStatus(source, data, details) {
+    const status = {
+      source,
+      isPreview: details.isPreview,
+      cacheKey: details.cacheKey,
+      error: details.error,
+      staleAgeSec: details.staleAgeSec,
+      circuit: circuitBreaker.getState(),
+      requestId: details.requestId,
+      durationMs: details.durationMs
+    };
+    lastStatus = status;
+    config.resilience?.onStatusChange?.(status);
+    const nowDegraded = source === "stale" || source === "error";
+    if (nowDegraded !== isDegraded) {
+      isDegraded = nowDegraded;
+      config.resilience?.onDegradedMode?.(nowDegraded, status);
+    }
+    return data;
+  }
+  async function resilientFetch(cacheKey, fetcher, options) {
+    const requestId = generateRequestId2();
+    const startTime = Date.now();
+    const isPreview = options.preview ?? false;
+    const statusDetails = (extra = {}) => ({
+      requestId,
+      cacheKey,
+      isPreview,
+      durationMs: Date.now() - startTime,
+      ...extra
+    });
+    if (cacheEnabled && !options.force) {
+      const fresh = cache.getFresh(cacheKey);
+      if (fresh !== null) {
+        return emitStatus("cache", fresh, statusDetails());
+      }
+    }
+    if (resilienceEnabled && circuitBreaker.isOpen()) {
+      if (!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" }
+          }));
+        }
+      }
+      if (!options.force) {
+        const circuitState = circuitBreaker.getState();
+        emitStatus("error", null, statusDetails({
+          error: { code: "circuit_open", message: "Circuit breaker is open" }
+        }));
+        throw new CircuitOpenError(circuitState);
       }
     }
-    let data;
     try {
-      const response = await fetcher();
-      data = unwrapResponse(response);
+      let data;
+      if (resilienceEnabled) {
+        if (circuitBreaker.getState().state === "half-open") {
+          circuitBreaker.incrementHalfOpenRequests();
+        }
+        data = await fetchWithTimeoutAndRetry(
+          async (timeoutSignal) => {
+            const combinedSignal = options.signal ? combineAbortSignals(timeoutSignal, options.signal) : timeoutSignal;
+            try {
+              const response = await fetcher(combinedSignal);
+              return unwrapResponse(response);
+            } catch (error) {
+              convertToTypedError(error);
+            }
+          },
+          {
+            ...retryConfig,
+            requestTimeoutMs
+          }
+        );
+        circuitBreaker.recordSuccess();
+      } else {
+        try {
+          const response = await fetcher(options.signal ?? new AbortController().signal);
+          data = unwrapResponse(response);
+        } catch (error) {
+          convertToTypedError(error);
+        }
+      }
+      if (cacheEnabled) {
+        cache.set(cacheKey, data);
+      }
+      return emitStatus("live", data, statusDetails());
     } catch (error) {
-      convertToTypedError(error);
+      if (resilienceEnabled && error instanceof Error) {
+        circuitBreaker.recordFailure(error);
+      }
+      if (!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 errorInfo = error instanceof RiverbankApiError ? { code: error.code, message: error.message } : { message: error.message };
+      emitStatus("error", null, statusDetails({ error: errorInfo }));
+      throw error;
     }
-    if (cacheEnabled) {
-      cache.set(cacheKey, data);
+  }
+  function combineAbortSignals(...signals) {
+    const controller = new AbortController();
+    for (const signal of signals) {
+      if (signal.aborted) {
+        controller.abort(signal.reason);
+        break;
+      }
+      signal.addEventListener("abort", () => controller.abort(signal.reason), { once: true });
     }
-    return data;
+    return controller.signal;
   }
   return {
     async getSite(params) {
-      const { slug, domain, id } = params;
+      const { slug, domain, id, signal } = 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}`;
-      return cachedFetch(cacheKey, async () => {
+      return resilientFetch(cacheKey, async (sig) => {
         const apiParams = {};
         if (params.slug) apiParams.slug = params.slug;
         if (params.domain) apiParams.domain = params.domain;
         if (params.id) apiParams.id = params.id;
-        return await apiClient({ endpoint: "getSite", params: apiParams });
-      });
+        return await apiClient({ endpoint: "getSite", params: apiParams, options: { signal: sig } });
+      }, { signal });
     },
     async getPage(params) {
-      const { siteId, path, preview = false } = params;
+      const { siteId, path, preview = false, signal } = params;
       const cacheKey = `page:${siteId}:${path}:${preview}`;
-      return cachedFetch(cacheKey, async () => {
-        return await apiClient({ endpoint: "getContentByPath", params: { siteId }, body: { path, preview } });
-      });
+      return resilientFetch(cacheKey, async (sig) => {
+        return await apiClient({ endpoint: "getContentByPath", params: { siteId }, body: { path, preview }, options: { signal: sig } });
+      }, { preview, signal });
     },
     async getEntries(params) {
-      const { siteId, contentType, limit, offset, order, preview = false, mode, entryIds, includeMeta } = 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 cachedFetch(cacheKey, async () => {
+      return resilientFetch(cacheKey, async (sig) => {
         let orderParam;
         if (order === "newest") {
           orderParam = "published_at.desc";
@@ -17850,47 +18309,47 @@ function createRiverbankClient(config) {
             entryIds: JSON.stringify(entryIds)
           }
         };
-        return await apiClient({ endpoint: "listPublishedEntries", params: apiParams });
-      });
+        return await apiClient({ endpoint: "listPublishedEntries", params: apiParams, options: { signal: sig } });
+      }, { preview, signal });
     },
     async getEntry(params) {
-      const { siteId, contentType, slug } = params;
+      const { siteId, contentType, slug, signal } = params;
       const cacheKey = `entry:${siteId}:${contentType}:${slug}`;
-      return cachedFetch(cacheKey, async () => {
-        return await apiClient({ endpoint: "getPublishedEntryPreview", params: { siteId, type: contentType, slug } });
-      });
+      return resilientFetch(cacheKey, async (sig) => {
+        return await apiClient({ endpoint: "getPublishedEntryPreview", params: { siteId, type: contentType, slug }, options: { signal: sig } });
+      }, { signal });
     },
     async getPublicFormById(params) {
-      const { formId } = params;
+      const { formId, signal } = params;
       if (!formId) {
         throw new Error("getPublicFormById() requires formId");
       }
       const cacheKey = `public-form:${formId}`;
-      return cachedFetch(cacheKey, async () => {
-        return await apiClient({ endpoint: "getPublicFormById", params: { formId } });
-      });
+      return resilientFetch(cacheKey, async (sig) => {
+        return await apiClient({ endpoint: "getPublicFormById", params: { formId }, options: { signal: sig } });
+      }, { signal });
     },
     async getPublicBookingServices(params) {
-      const { siteId, ids } = params;
+      const { siteId, ids, signal } = params;
       if (!siteId) {
         throw new Error("getPublicBookingServices() requires siteId");
       }
       const cacheKey = `public-booking-services:${siteId}:${ids ?? ""}`;
-      return cachedFetch(cacheKey, async () => {
+      return resilientFetch(cacheKey, async (sig) => {
         const apiParams = {
           siteId,
           ...ids && { ids }
         };
-        return await apiClient({ endpoint: "getPublicBookingServices", params: apiParams });
-      });
+        return await apiClient({ endpoint: "getPublicBookingServices", params: apiParams, options: { signal: sig } });
+      }, { signal });
     },
     async listPublicEvents(params) {
-      const { siteId, limit, from, to, stage } = params;
+      const { siteId, limit, from, to, stage, signal } = params;
       if (!siteId) {
         throw new Error("listPublicEvents() requires siteId");
       }
       const cacheKey = `public-events:${siteId}:${limit ?? ""}:${from ?? ""}:${to ?? ""}:${stage ?? ""}`;
-      return cachedFetch(cacheKey, async () => {
+      return resilientFetch(cacheKey, async (sig) => {
         const apiParams = {
           siteId,
           ...typeof limit === "number" && { limit: String(limit) },
@@ -17898,40 +18357,46 @@ function createRiverbankClient(config) {
           ...to && { to },
           ...stage && { stage }
         };
-        return await apiClient({ endpoint: "listPublicEvents", params: apiParams });
-      });
+        return await apiClient({ endpoint: "listPublicEvents", params: apiParams, options: { signal: sig } });
+      }, { signal });
     },
     async resolveEventOccurrence(params) {
-      const { siteId, entryId, segment } = params;
+      const { siteId, entryId, segment, signal } = params;
       if (!siteId || !entryId || !segment) {
         throw new Error("resolveEventOccurrence() requires siteId, entryId, and segment");
       }
       const cacheKey = `event-occurrence:${siteId}:${entryId}:${segment}`;
-      return cachedFetch(cacheKey, async () => {
+      return resilientFetch(cacheKey, async (sig) => {
         return await apiClient({
           endpoint: "resolveEventOccurrence",
-          params: { siteId, entryId, segment }
+          params: { siteId, entryId, segment },
+          options: { signal: sig }
         });
-      });
+      }, { signal });
     },
     async checkRedirect(params) {
-      const { siteId, path } = params;
+      const { siteId, path, signal } = params;
       if (!siteId || !path) {
         throw new Error("checkRedirect() requires siteId and path");
       }
       const cacheKey = `redirect:${siteId}:${path}`;
-      return cachedFetch(cacheKey, async () => {
+      return resilientFetch(cacheKey, async (sig) => {
         return await apiClient({
           endpoint: "checkRedirect",
-          params: { site: siteId, path }
+          params: { site: siteId, path },
+          options: { signal: sig }
         });
-      });
+      }, { signal });
     },
     clearCache() {
       cache.clear();
+    },
+    getLastEmittedStatus() {
+      return lastStatus;
+    },
+    getCircuitState() {
+      return circuitBreaker.getState();
     }
-    // Cast to RiverbankClient to satisfy overloaded getEntries signature
-    // The implementation correctly returns the right type based on includeMeta
   };
 }
 // Annotate the CommonJS export names for ESM import in node: