@riverbankcms/sdk 0.88.0 → 0.89.1

package/dist/server/server.mjs

@@ -1865,6 +1865,24 @@ var ENDPOINT_DEFINITIONS = {
     auth: "user",
     responseKind: "json"
   },
+  resendSiteInvitation: {
+    path: "/sites/{siteId}/members/invitations/{invitationId}/resend",
+    method: "POST",
+    errors: [
+      "auth:forbidden",
+      "resource:not_found",
+      "validation:invalid_input",
+      "external:service_error",
+      "server:internal_error"
+    ],
+    tags: [
+      "site-{siteId}",
+      "site-members-{siteId}",
+      "site-invite-{invitationId}"
+    ],
+    auth: "user",
+    responseKind: "json"
+  },
   transferSiteOwnership: {
     path: "/sites/{siteId}/members/transfer-ownership",
     method: "POST",
@@ -7042,7 +7060,7 @@ var SimpleCache = class {
 };
 
 // src/version.ts
-var SDK_VERSION = "0.88.0";
+var SDK_VERSION = "0.89.1";
 
 // src/client/error.ts
 var RiverbankApiError = class _RiverbankApiError extends Error {
@@ -7199,6 +7217,476 @@ function attachResilienceStatusToError(error, resilienceStatus) {
   return target;
 }
 
+// src/public-api/runtime.ts
+var PUBLIC_ENDPOINT_NAMES2 = [
+  "getSite",
+  "getContentByPath",
+  "listPublishedEntries",
+  "getPublishedEntryPreview",
+  "getPublicFormById",
+  "listPublicForms",
+  "getPublicBookingServices",
+  "getPublicChallenge",
+  "listPublicEvents",
+  "batchBlockLoaders",
+  "listPublicCourses",
+  "listPublicTeamMembers",
+  "listPublicProducts",
+  "listPublicPasses",
+  "listPublicMemberships",
+  "resolveEntrySubroute",
+  "resolveEventOccurrence",
+  "checkRedirect",
+  "getRoutableContent",
+  "getPublicRoutableContent",
+  "getPublicSitemapRoutes"
+];
+var API_ENDPOINTS2 = Object.freeze({
+  getSite: {
+    path: "/sites",
+    method: "GET",
+    revalidate: 900,
+    tags: ["riverbank:site", "riverbank:site:id:{id}", "riverbank:site:slug:{slug}", "riverbank:site:domain:{domain}"],
+    auth: "public",
+    responseKind: "json"
+  },
+  getContentByPath: {
+    path: "/sites/{siteId}/pages",
+    method: "GET",
+    tags: ["riverbank:site:{siteId}:routable-content"],
+    auth: "public",
+    responseKind: "json"
+  },
+  listPublishedEntries: {
+    path: "/public/content/{siteId}/{type}/entries",
+    method: "GET",
+    revalidate: 60,
+    tags: ["content-{siteId}-{type}"],
+    auth: "public",
+    responseKind: "json"
+  },
+  getPublishedEntryPreview: {
+    path: "/public/content/{siteId}/{type}/{slug}/preview",
+    method: "GET",
+    revalidate: 60,
+    tags: ["content-{siteId}-{type}-{slug}"],
+    auth: "public",
+    responseKind: "json"
+  },
+  getPublicFormById: {
+    path: "/public/forms/{formId}",
+    method: "GET",
+    revalidate: 60,
+    tags: ["riverbank:form:{formId}"],
+    auth: "public",
+    responseKind: "json"
+  },
+  listPublicForms: {
+    path: "/public/sites/{siteId}/forms",
+    method: "GET",
+    revalidate: 60,
+    tags: ["riverbank:site:{siteId}:forms"],
+    auth: "public",
+    responseKind: "json"
+  },
+  getPublicBookingServices: {
+    path: "/public/bookings/services",
+    method: "GET",
+    revalidate: 60,
+    tags: ["site-{siteId}"],
+    auth: "public",
+    responseKind: "json"
+  },
+  getPublicChallenge: {
+    path: "/public/challenge",
+    method: "GET",
+    auth: "public",
+    responseKind: "text"
+  },
+  listPublicEvents: {
+    path: "/public/sites/{siteId}/events",
+    method: "GET",
+    revalidate: 60,
+    tags: ["riverbank:site:{siteId}:public-events"],
+    auth: "public",
+    responseKind: "json"
+  },
+  batchBlockLoaders: {
+    path: "/public/sites/{siteId}/block-loaders/batch",
+    method: "POST",
+    auth: "public",
+    responseKind: "json"
+  },
+  listPublicCourses: {
+    path: "/public/sites/{siteId}/courses",
+    method: "GET",
+    revalidate: 60,
+    tags: ["riverbank:site:{siteId}:public-courses"],
+    auth: "public",
+    responseKind: "json"
+  },
+  listPublicTeamMembers: {
+    path: "/public/sites/{siteId}/team-members",
+    method: "GET",
+    revalidate: 60,
+    tags: ["riverbank:site:{siteId}:public-team-members"],
+    auth: "public",
+    responseKind: "json"
+  },
+  listPublicProducts: {
+    path: "/public/sites/{siteId}/products",
+    method: "GET",
+    revalidate: 300,
+    tags: ["riverbank:site:{siteId}:public-products"],
+    auth: "public",
+    responseKind: "json"
+  },
+  listPublicPasses: {
+    path: "/public/sites/{siteId}/bookings/products/passes",
+    method: "GET",
+    revalidate: 300,
+    tags: ["riverbank:site:{siteId}:public-passes"],
+    auth: "public",
+    responseKind: "json"
+  },
+  listPublicMemberships: {
+    path: "/public/sites/{siteId}/bookings/products/memberships",
+    method: "GET",
+    revalidate: 300,
+    tags: ["riverbank:site:{siteId}:public-memberships"],
+    auth: "public",
+    responseKind: "json"
+  },
+  resolveEntrySubroute: {
+    path: "/public/sites/{siteId}/routing/subroutes/resolve",
+    method: "GET",
+    revalidate: 60,
+    tags: ["site-{siteId}", "entry-subroute"],
+    auth: "public",
+    responseKind: "json"
+  },
+  resolveEventOccurrence: {
+    path: "/public/sites/{siteId}/events/occurrences/resolve",
+    method: "GET",
+    revalidate: 60,
+    tags: ["riverbank:site:{siteId}:public-events", "event-occurrence"],
+    auth: "public",
+    responseKind: "json"
+  },
+  checkRedirect: {
+    path: "/public/content/redirect",
+    method: "GET",
+    revalidate: 86400,
+    tags: ["redirect"],
+    auth: "public",
+    responseKind: "json"
+  },
+  getRoutableContent: {
+    path: "/sites/{siteId}/routable-content",
+    method: "GET",
+    revalidate: 60,
+    tags: ["riverbank:site:{siteId}:routable-content"],
+    auth: "user",
+    responseKind: "json"
+  },
+  getPublicRoutableContent: {
+    path: "/public/sites/{siteId}/routable-content",
+    method: "GET",
+    revalidate: 60,
+    tags: ["riverbank:site:{siteId}:routable-content"],
+    auth: "public",
+    responseKind: "json"
+  },
+  getPublicSitemapRoutes: {
+    path: "/public/sites/{siteId}/sitemap",
+    method: "GET",
+    revalidate: 60,
+    tags: ["riverbank:site:{siteId}:routable-content", "riverbank:site:{siteId}:settings"],
+    auth: "public",
+    responseKind: "json"
+  }
+});
+
+// src/client/runtimeCachePolicy.ts
+var DEFAULT_PUBLISHED_RUNTIME_CACHE_PAYLOAD_SCHEMA_VERSION = 1;
+var DEFAULT_STALE_TTL_SEC = 24 * 60 * 60;
+var DEFAULT_MEMORY_TTL_SEC = 60;
+var RUNTIME_CACHE_DURABILITY_OVERRIDES = {
+  getSite: {
+    kind: "durable-public-stale",
+    staleTtlSec: DEFAULT_STALE_TTL_SEC
+  },
+  getContentByPath: {
+    kind: "durable-public-stale",
+    staleTtlSec: DEFAULT_STALE_TTL_SEC
+  },
+  listPublishedEntries: {
+    kind: "memory-only",
+    reason: "durable_rollout_pending"
+  },
+  getPublishedEntryPreview: {
+    kind: "memory-only",
+    reason: "durable_rollout_pending"
+  },
+  getPublicFormById: {
+    kind: "memory-only",
+    reason: "durable_rollout_pending"
+  },
+  listPublicForms: {
+    kind: "memory-only",
+    reason: "durable_rollout_pending"
+  },
+  getPublicBookingServices: {
+    kind: "live-only",
+    reason: "safety_sensitive_booking"
+  },
+  getPublicChallenge: {
+    kind: "live-only",
+    reason: "challenge_endpoint"
+  },
+  listPublicEvents: {
+    kind: "memory-only",
+    reason: "durable_rollout_pending"
+  },
+  batchBlockLoaders: {
+    kind: "live-only",
+    reason: "opaque_batch_loader"
+  },
+  listPublicCourses: {
+    kind: "memory-only",
+    reason: "durable_rollout_pending"
+  },
+  listPublicTeamMembers: {
+    kind: "memory-only",
+    reason: "durable_rollout_pending"
+  },
+  listPublicProducts: {
+    kind: "memory-only",
+    reason: "durable_rollout_pending"
+  },
+  listPublicPasses: {
+    kind: "live-only",
+    reason: "safety_sensitive_booking"
+  },
+  listPublicMemberships: {
+    kind: "live-only",
+    reason: "safety_sensitive_booking"
+  },
+  resolveEntrySubroute: {
+    kind: "memory-only",
+    reason: "durable_rollout_pending"
+  },
+  resolveEventOccurrence: {
+    kind: "memory-only",
+    reason: "durable_rollout_pending"
+  },
+  checkRedirect: {
+    kind: "memory-only",
+    reason: "durable_rollout_pending"
+  },
+  getRoutableContent: {
+    kind: "live-only",
+    reason: "auth_required"
+  },
+  getPublicRoutableContent: {
+    kind: "memory-only",
+    reason: "durable_rollout_pending"
+  },
+  getPublicSitemapRoutes: {
+    kind: "memory-only",
+    reason: "durable_rollout_pending"
+  }
+};
+var PUBLIC_ENDPOINT_NAME_SET = new Set(PUBLIC_ENDPOINT_NAMES2);
+function isPublicEndpointName(endpoint) {
+  return PUBLIC_ENDPOINT_NAME_SET.has(endpoint);
+}
+function isTruthyParam(value) {
+  return value === true || value === "true" || value === 1 || value === "1";
+}
+function isPreviewRequest(endpoint, params) {
+  if (endpoint === "getContentByPath") {
+    return isTruthyParam(params.preview);
+  }
+  if (endpoint === "listPublishedEntries" || endpoint === "resolveEntrySubroute" || endpoint === "resolveEventOccurrence") {
+    return params.stage === "preview";
+  }
+  return false;
+}
+function getEndpointFreshTtlSec(endpoint) {
+  return API_ENDPOINTS2[endpoint].revalidate ?? DEFAULT_MEMORY_TTL_SEC;
+}
+function assertNever(value) {
+  throw new Error(`Unhandled runtime cache policy override: ${String(value)}`);
+}
+function resolveKnownEndpointPolicy(endpoint, params) {
+  if (isPreviewRequest(endpoint, params)) {
+    return { kind: "live-only", endpoint, reason: "preview_request" };
+  }
+  if (endpoint === "getSite" && isTruthyParam(params.force)) {
+    return { kind: "live-only", endpoint, reason: "force_refresh" };
+  }
+  const override = RUNTIME_CACHE_DURABILITY_OVERRIDES[endpoint];
+  if (override.kind === "live-only") {
+    return { kind: "live-only", endpoint, reason: override.reason };
+  }
+  const endpointDefinition = API_ENDPOINTS2[endpoint];
+  if (endpointDefinition.method !== "GET") {
+    return { kind: "live-only", endpoint, reason: "non_get_request" };
+  }
+  if (endpointDefinition.auth === "user") {
+    return { kind: "live-only", endpoint, reason: "auth_required" };
+  }
+  switch (override.kind) {
+    case "durable-public-stale":
+      return {
+        kind: "durable-public-stale",
+        endpoint,
+        freshTtlSec: getEndpointFreshTtlSec(endpoint),
+        staleTtlSec: override.staleTtlSec
+      };
+    case "memory-only":
+      return {
+        kind: "memory-only",
+        endpoint,
+        freshTtlSec: getEndpointFreshTtlSec(endpoint),
+        reason: override.reason
+      };
+    default:
+      return assertNever(override);
+  }
+}
+function resolveRuntimeCachePolicy(input) {
+  if (input.method && input.method.toUpperCase() !== "GET") {
+    return {
+      kind: "live-only",
+      endpoint: input.endpoint,
+      reason: "non_get_request"
+    };
+  }
+  if (!isPublicEndpointName(input.endpoint)) {
+    return {
+      kind: "live-only",
+      endpoint: input.endpoint,
+      reason: "unknown_endpoint"
+    };
+  }
+  return resolveKnownEndpointPolicy(input.endpoint, input.params ?? {});
+}
+function toNonEmptyString(value) {
+  if (value === null || value === void 0) return null;
+  if (typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean") {
+    return null;
+  }
+  const normalized = String(value).trim();
+  return normalized.length > 0 ? normalized : null;
+}
+function normalizeRuntimePublicPath(value) {
+  const raw = toNonEmptyString(value) ?? "/";
+  const withoutQuery = raw.split(/[?#]/, 1)[0] ?? "/";
+  const withLeadingSlash = withoutQuery.startsWith("/") ? withoutQuery : `/${withoutQuery}`;
+  const collapsed = withLeadingSlash.replace(/\/{2,}/g, "/");
+  const withoutTrailingSlash = collapsed.length > 1 ? collapsed.replace(/\/+$/g, "") : collapsed;
+  return withoutTrailingSlash || "/";
+}
+function normalizeRuntimeHostname(value) {
+  const trimmed = value.trim().toLowerCase();
+  const url = /^[a-z][a-z0-9+.-]*:\/\//.test(trimmed) ? new URL(trimmed) : new URL(`http://${trimmed}`);
+  return url.hostname.replace(/\.$/, "");
+}
+function normalizeScalar(value) {
+  return value.trim().toLowerCase();
+}
+function encodeKeyPart(key, value) {
+  return `${encodeURIComponent(key)}=${encodeURIComponent(value)}`;
+}
+function unsafeAsPublishedRuntimeCacheKey(value) {
+  return value;
+}
+function buildPublishedRuntimeCacheKey(endpoint, normalizedParams) {
+  const encodedParams = Object.entries(normalizedParams).sort(([left], [right]) => left.localeCompare(right)).map(([key, value]) => encodeKeyPart(key, value)).join(":");
+  return unsafeAsPublishedRuntimeCacheKey(
+    `published-runtime:v1:${endpoint}:${encodedParams}`
+  );
+}
+function selectSiteRuntimeIdentity(params) {
+  const slug = toNonEmptyString(params.slug);
+  if (slug !== null) return { slug: normalizeScalar(slug) };
+  const domain = toNonEmptyString(params.domain);
+  if (domain !== null) return { domain: normalizeRuntimeHostname(domain) };
+  const id = toNonEmptyString(params.id);
+  if (id !== null) return { id: normalizeScalar(id) };
+  return null;
+}
+function deriveGetSiteKey(params) {
+  const identity = selectSiteRuntimeIdentity(params);
+  if (identity === null) {
+    return {
+      ok: false,
+      error: {
+        kind: "missing_site_identity",
+        acceptedParams: ["slug", "domain", "id"]
+      }
+    };
+  }
+  const normalizedParams = {
+    ...identity,
+    currentPath: normalizeRuntimePublicPath(params.currentPath)
+  };
+  return {
+    ok: true,
+    endpoint: "getSite",
+    key: buildPublishedRuntimeCacheKey("getSite", normalizedParams),
+    normalizedParams
+  };
+}
+function deriveGetContentByPathKey(params) {
+  const siteId = toNonEmptyString(params.siteId);
+  if (siteId === null) {
+    return {
+      ok: false,
+      error: {
+        kind: "missing_required_param",
+        endpoint: "getContentByPath",
+        param: "siteId"
+      }
+    };
+  }
+  const normalizedParams = {
+    siteId: normalizeScalar(siteId),
+    path: normalizeRuntimePublicPath(params.path)
+  };
+  return {
+    ok: true,
+    endpoint: "getContentByPath",
+    key: buildPublishedRuntimeCacheKey("getContentByPath", normalizedParams),
+    normalizedParams
+  };
+}
+var DURABLE_RUNTIME_CACHE_KEY_DERIVERS = {
+  getSite: deriveGetSiteKey,
+  getContentByPath: deriveGetContentByPathKey
+};
+function derivePublishedRuntimeCacheKey(input) {
+  const policy = resolveRuntimeCachePolicy({
+    endpoint: input.endpoint,
+    method: "GET",
+    params: input.params
+  });
+  if (policy.kind !== "durable-public-stale") {
+    return {
+      ok: false,
+      error: { kind: "not_durable_eligible", policy }
+    };
+  }
+  switch (input.endpoint) {
+    case "getSite":
+      return DURABLE_RUNTIME_CACHE_KEY_DERIVERS.getSite(input.params);
+    case "getContentByPath":
+      return DURABLE_RUNTIME_CACHE_KEY_DERIVERS.getContentByPath(input.params);
+  }
+}
+
 // src/client/resilience.ts
 var DEFAULT_RETRY_CONFIG = {
   maxAttempts: 3,
@@ -7508,12 +7996,57 @@ setSdkVersion(SDK_VERSION);
 var DEFAULT_BROWSER_TIMEOUT_MS = 5e3;
 var DEFAULT_SERVER_TIMEOUT_MS = 8e3;
 var MAX_GET_ENTRIES_BY_IDENTIFIERS_REFS = 50;
+function isDurableRuntimeCacheTier(cacheTier) {
+  return cacheTier === "durable-fresh" || cacheTier === "durable-stale";
+}
+function isDegradedResilienceStatus(source, details) {
+  return source === "stale" || source === "error" || isDurableRuntimeCacheTier(details.cacheTier) && details.error !== void 0;
+}
 function generateRequestId2() {
   return `req-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
 }
 function toRecord(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
+function getRuntimePayloadSiteId(value) {
+  const site = toRecord(value).site;
+  if (!site || typeof site !== "object" || Array.isArray(site)) {
+    return null;
+  }
+  const id = site.id;
+  return typeof id === "string" && id.trim().length > 0 ? id : null;
+}
+function getRiverbankErrorInfo(error) {
+  if (error instanceof RiverbankApiError) {
+    return { code: error.code, message: error.message, status: error.status };
+  }
+  if (error instanceof Error) {
+    return { message: error.message };
+  }
+  return { message: String(error) };
+}
+function planPublishedRuntimeCache(input) {
+  const policy = resolveRuntimeCachePolicy({
+    endpoint: input.endpoint,
+    method: "GET",
+    params: input.params
+  });
+  if (policy.kind !== "durable-public-stale") {
+    return null;
+  }
+  const keyResult = derivePublishedRuntimeCacheKey(input);
+  if (!keyResult.ok) {
+    return null;
+  }
+  return {
+    cacheKey: keyResult.key,
+    endpoint: keyResult.endpoint,
+    normalizedParams: keyResult.normalizedParams,
+    freshTtlSec: policy.freshTtlSec,
+    staleTtlSec: policy.staleTtlSec,
+    siteId: input.siteId ?? null
+  };
+}
 function normalizeEntryIdentifierRefs(identifiers) {
   const trimmed = identifiers.map((identifier) => identifier.trim()).filter((identifier) => identifier.length > 0);
   if (trimmed.length === 0) {
@@ -7747,6 +8280,8 @@ function createRiverbankClient(config) {
       source,
       isPreview: details.isPreview,
       cacheKey: details.cacheKey,
+      cacheTier: details.cacheTier,
+      durableCache: details.durableCache,
       error: details.error,
       staleAgeSec: details.staleAgeSec,
       prebuildAgeSec: details.prebuildAgeSec,
@@ -7756,7 +8291,7 @@ function createRiverbankClient(config) {
     };
     lastStatus = status;
     config.resilience?.onStatusChange?.(status);
-    const nowDegraded = source === "stale" || source === "error";
+    const nowDegraded = isDegradedResilienceStatus(source, details);
     if (nowDegraded !== isDegraded) {
       isDegraded = nowDegraded;
       config.resilience?.onDegradedMode?.(nowDegraded, status);
@@ -7766,6 +8301,80 @@ function createRiverbankClient(config) {
       resilience: status
     };
   }
+  async function tryPublishedRuntimeCacheFallback(plan, statusDetails, errorInfo) {
+    const reader = config.publishedRuntimeCache?.read;
+    if (!plan || !reader) {
+      return null;
+    }
+    try {
+      const result = await reader({
+        cacheKey: plan.cacheKey,
+        endpoint: plan.endpoint,
+        payloadSchemaVersion: DEFAULT_PUBLISHED_RUNTIME_CACHE_PAYLOAD_SCHEMA_VERSION
+      });
+      if (result.kind === "miss") {
+        return {
+          kind: "miss",
+          diagnostic: {
+            outcome: "miss",
+            reason: result.reason
+          }
+        };
+      }
+      if (result.kind === "error") {
+        return {
+          kind: "error",
+          diagnostic: {
+            outcome: "error",
+            error: result.error
+          }
+        };
+      }
+      return {
+        kind: "hit",
+        result: emitStatus(
+          result.freshness === "fresh" ? "cache" : "stale",
+          result.payload,
+          statusDetails({
+            error: errorInfo,
+            staleAgeSec: result.staleAgeSec,
+            cacheTier: result.freshness === "fresh" ? "durable-fresh" : "durable-stale"
+          })
+        )
+      };
+    } catch (error) {
+      return {
+        kind: "error",
+        diagnostic: {
+          outcome: "error",
+          error: {
+            kind: "adapter_exception",
+            message: error instanceof Error ? error.message : String(error)
+          }
+        }
+      };
+    }
+  }
+  async function writePublishedRuntimeCache(plan, payload) {
+    const writer = config.publishedRuntimeCache?.write;
+    if (!plan || !writer) {
+      return;
+    }
+    try {
+      await writer({
+        cacheKey: plan.cacheKey,
+        endpoint: plan.endpoint,
+        normalizedParams: plan.normalizedParams,
+        payload,
+        siteId: plan.siteId ?? getRuntimePayloadSiteId(payload),
+        freshTtlSec: plan.freshTtlSec,
+        staleTtlSec: plan.staleTtlSec,
+        payloadSchemaVersion: DEFAULT_PUBLISHED_RUNTIME_CACHE_PAYLOAD_SCHEMA_VERSION,
+        writeReason: "live_success"
+      });
+    } catch {
+    }
+  }
   async function resilientFetch(cacheKey, fetcher, options) {
     const requestId = generateRequestId2();
     const startTime = Date.now();
@@ -7781,7 +8390,11 @@ function createRiverbankClient(config) {
     if (cacheEnabled && !options.force) {
       const fresh = cache.getFresh(cacheKey);
       if (fresh !== null) {
-        return emitStatus("cache", fresh, statusDetails());
+        return emitStatus(
+          "cache",
+          fresh,
+          statusDetails({ cacheTier: "memory-fresh" })
+        );
       }
     }
     if (resilienceEnabled && circuitBreaker.isOpen()) {
@@ -7793,6 +8406,7 @@ function createRiverbankClient(config) {
             stale.value,
             statusDetails({
               staleAgeSec: stale.staleAgeSec,
+              cacheTier: "memory-stale",
               error: {
                 code: "circuit_open",
                 message: "Circuit breaker is open"
@@ -7801,6 +8415,15 @@ function createRiverbankClient(config) {
           );
         }
       }
+      const durableFallback = allowFallbacks && !isPreview ? await tryPublishedRuntimeCacheFallback(
+        options.publishedRuntimeCache,
+        statusDetails,
+        { code: "circuit_open", message: "Circuit breaker is open" }
+      ) : null;
+      const durableCache = durableFallback?.kind === "miss" || durableFallback?.kind === "error" ? durableFallback.diagnostic : void 0;
+      if (durableFallback?.kind === "hit") {
+        return durableFallback.result;
+      }
       if (allowFallbacks && !isPreview && options.prebuildFallback) {
         const prebuildResult = options.prebuildFallback();
         if (prebuildResult) {
@@ -7809,6 +8432,8 @@ function createRiverbankClient(config) {
             prebuildResult.data,
             statusDetails({
               prebuildAgeSec: prebuildResult.prebuildAgeSec,
+              cacheTier: "prebuild",
+              durableCache,
               error: {
                 code: "circuit_open",
                 message: "Circuit breaker is open"
@@ -7822,6 +8447,7 @@ function createRiverbankClient(config) {
         "error",
         null,
         statusDetails({
+          durableCache,
           error: { code: "circuit_open", message: "Circuit breaker is open" }
         })
       );
@@ -7862,6 +8488,9 @@ function createRiverbankClient(config) {
       if (cacheEnabled) {
         cache.set(cacheKey, data);
       }
+      if (allowFallbacks && !isPreview) {
+        await writePublishedRuntimeCache(options.publishedRuntimeCache, data);
+      }
       return emitStatus("live", data, statusDetails());
     } catch (error) {
       if (resilienceEnabled && error instanceof Error) {
@@ -7870,44 +8499,47 @@ 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,
-            status: error.status
-          } : { message: error.message };
+          const errorInfo2 = getRiverbankErrorInfo(error);
           return emitStatus(
             "stale",
             stale.value,
             statusDetails({
               staleAgeSec: stale.staleAgeSec,
+              cacheTier: "memory-stale",
               error: errorInfo2
             })
           );
         }
       }
+      const errorInfo = getRiverbankErrorInfo(error);
+      const durableFallback = allowFallbacks && !isPreview ? await tryPublishedRuntimeCacheFallback(
+        options.publishedRuntimeCache,
+        statusDetails,
+        errorInfo
+      ) : null;
+      const durableCache = durableFallback?.kind === "miss" || durableFallback?.kind === "error" ? durableFallback.diagnostic : void 0;
+      if (durableFallback?.kind === "hit") {
+        return durableFallback.result;
+      }
       if (allowFallbacks && !isPreview && options.prebuildFallback) {
         const prebuildResult = options.prebuildFallback();
         if (prebuildResult) {
-          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
+              cacheTier: "prebuild",
+              durableCache,
+              error: errorInfo
             })
           );
         }
       }
-      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 })
+        statusDetails({ error: errorInfo, durableCache })
       );
       throw attachResilienceStatusToError(error, failure.resilience);
     }
@@ -7957,8 +8589,12 @@ function createRiverbankClient(config) {
       );
     }
     const siteIdentifier = slug || domain || id;
-    const cacheKey = `site:${siteIdentifier ?? "unknown"}:${currentPath ?? ""}`;
     const siteId = id || slug || domain;
+    const publishedRuntimeCache = planPublishedRuntimeCache({
+      endpoint: "getSite",
+      params: { slug, domain, id, currentPath, force }
+    });
+    const cacheKey = publishedRuntimeCache?.cacheKey ?? `site:${siteIdentifier ?? "unknown"}:${currentPath ?? ""}`;
     return resilientFetch(
       cacheKey,
       async (sig) => {
@@ -7981,13 +8617,19 @@ function createRiverbankClient(config) {
       {
         signal,
         force,
+        publishedRuntimeCache,
         prebuildFallback: prebuildLoader && siteId ? () => prebuildLoader.loadSite(siteId) : void 0
       }
     );
   }
   async function getPageWithResilienceInternal(params) {
     const { siteId, path, preview = false, signal } = params;
-    const cacheKey = `page:${siteId}:${path}:${preview}`;
+    const publishedRuntimeCache = planPublishedRuntimeCache({
+      endpoint: "getContentByPath",
+      params: { siteId, path, preview },
+      siteId
+    });
+    const cacheKey = publishedRuntimeCache?.cacheKey ?? `page:${siteId}:${path}:${preview}`;
     return resilientFetch(
       cacheKey,
       async (sig) => {
@@ -8000,6 +8642,7 @@ function createRiverbankClient(config) {
       {
         preview,
         signal,
+        publishedRuntimeCache,
         // Prebuild fallback only for published pages (not preview)
         prebuildFallback: prebuildLoader && !preview ? () => prebuildLoader.loadPage(siteId, path) : void 0
       }
@@ -8545,7 +9188,7 @@ function err(error) {
 }
 
 // ../core/src/assert-never.ts
-function assertNever(value, message = "Unexpected variant") {
+function assertNever2(value, message = "Unexpected variant") {
   throw new Error(`${message}: ${String(value)}`);
 }
 
@@ -9964,7 +10607,7 @@ function makeBoundaryId(previousBlockId, nextBlockId) {
   const next = encodeURIComponent(nextBlockId);
   return asDesignBoundaryId(`boundary:${previous}:${next}`);
 }
-function assertNever2(value, message = "Unhandled Theme V2 variant") {
+function assertNever3(value, message = "Unhandled Theme V2 variant") {
   throw new Error(`${message}: ${String(value)}`);
 }
 function brandNonEmptyString(value, label) {
@@ -16345,7 +16988,7 @@ function themedHeaderShadow(theme) {
     case "high":
       return { elevation: "lg" };
     default:
-      return assertNever2(
+      return assertNever3(
         theme.shadow.elevation,
         "Unhandled theme shadow elevation"
       );
@@ -26800,7 +27443,7 @@ function planSiteChromePlacement(positioning) {
         standaloneShellClassName: "fixed left-0 right-0 top-0 z-40 w-full"
       };
     default:
-      return assertNever2(positioning);
+      return assertNever3(positioning);
   }
 }
 
@@ -35411,7 +36054,7 @@ var publicProductsResponseSchema = z56.object({
 });
 
 // ../blocks/src/system/runtime/api/creditProducts.ts
-function assertNever3(value) {
+function assertNever4(value) {
   throw new Error(`Unhandled credit product case: ${String(value)}`);
 }
 function useCasesFromModules(modules) {
@@ -35444,7 +36087,7 @@ function getCreditProductCreditUnit(useCase) {
         perCreditSuffix: "credit"
       };
     default:
-      return assertNever3(useCase);
+      return assertNever4(useCase);
   }
 }
 function deriveCreditProductLabels(products, options = {}) {
@@ -39315,7 +39958,7 @@ function resolveLinkedContentEditSupport(contentType) {
     case "unsupported-domain-backed":
       return { kind: "unsupported-domain-backed", reason: metadata.reason };
     default:
-      return assertNever(metadata);
+      return assertNever2(metadata);
   }
 }
 function contentTypeKeyToLabel(key) {