@riverbankcms/sdk 0.88.0 → 0.89.1

package/dist/server/index.mjs

@@ -1832,6 +1832,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",
@@ -7009,7 +7027,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 {
@@ -7172,80 +7190,654 @@ function getResilienceStatusFromError(error) {
   return error[resilienceStatusSymbol];
 }
 
-// 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
-};
-var PERMANENT_NETWORK_ERROR_CODES = /* @__PURE__ */ new Set([
-  "ECONNREFUSED",
-  // Server is not running / port not listening
-  "ENOTFOUND",
-  // DNS lookup failed - hostname doesn't exist
-  "EAI_AGAIN"
-  // DNS lookup timeout (usually permanent for invalid hosts)
-]);
-var TRANSIENT_NETWORK_ERROR_CODES = /* @__PURE__ */ new Set([
-  "ECONNRESET",
-  // Connection was reset mid-request (server dropped it)
-  "EPIPE",
-  // Broken pipe (connection closed while writing)
-  "ETIMEDOUT",
-  // Connection timed out (could be temporary congestion)
-  "ESOCKETTIMEDOUT"
-  // Socket timeout
-]);
-var NODE_NETWORK_ERROR_CODES = /* @__PURE__ */ new Set([
-  // Permanent
-  "ECONNREFUSED",
-  "ENOTFOUND",
-  "EAI_AGAIN",
-  // Transient
-  "ECONNRESET",
-  "EPIPE",
-  "ETIMEDOUT",
-  "ESOCKETTIMEDOUT"
-]);
-function isNodeNetworkErrorCode(code) {
-  return !code.includes(":") && NODE_NETWORK_ERROR_CODES.has(code);
-}
-function getErrorCodeFromCause(error) {
-  let current = error;
-  while (current) {
-    const nodeError = current;
-    if (nodeError.code && typeof nodeError.code === "string") {
-      if (isNodeNetworkErrorCode(nodeError.code)) {
-        return nodeError.code;
-      }
-    }
-    const errorWithCause = current;
-    current = errorWithCause.cause;
+// 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"
   }
-  return void 0;
+});
+function buildEndpointURL2(baseURL, endpoint) {
+  return baseURL + API_ENDPOINTS2[endpoint].path;
 }
-function isTransientError(error) {
-  if (error instanceof RiverbankApiError) {
-    const errorCode = getErrorCodeFromCause(error);
-    if (errorCode && PERMANENT_NETWORK_ERROR_CODES.has(errorCode)) {
-      return false;
-    }
-    if (error.status === 0) return true;
-    if (error.status === 429) return true;
-    if (error.status >= 500) return true;
-    return false;
-  }
-  if (error instanceof TypeError) {
-    const errorCode = getErrorCodeFromCause(error);
-    if (errorCode) {
-      if (PERMANENT_NETWORK_ERROR_CODES.has(errorCode)) {
-        return false;
+
+// 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 isPublishedRuntimeCacheKeyEndpoint(value) {
+  return typeof value === "string" && Object.prototype.hasOwnProperty.call(DURABLE_RUNTIME_CACHE_KEY_DERIVERS, value);
+}
+function parsePublishedRuntimeCacheKey(value) {
+  const details = parsePublishedRuntimeCacheKeyDetails(value);
+  if (!details.ok) {
+    return details;
+  }
+  return {
+    ok: true,
+    key: details.key,
+    endpoint: details.endpoint
+  };
+}
+function parsePublishedRuntimeCacheKeyDetails(value) {
+  if (typeof value !== "string") {
+    return { ok: false, error: "not_string" };
+  }
+  const parts = value.split(":");
+  if (parts[0] !== "published-runtime" || parts[1] !== "v1") {
+    return { ok: false, error: "invalid_prefix" };
+  }
+  const endpoint = parts[2];
+  if (!isPublishedRuntimeCacheKeyEndpoint(endpoint)) {
+    return { ok: false, error: "unknown_endpoint" };
+  }
+  const normalizedParams = {};
+  for (const part of parts.slice(3)) {
+    const separatorIndex = part.indexOf("=");
+    if (separatorIndex <= 0) {
+      return { ok: false, error: "invalid_param_encoding" };
+    }
+    try {
+      const key = decodeURIComponent(part.slice(0, separatorIndex));
+      const paramValue = decodeURIComponent(part.slice(separatorIndex + 1));
+      normalizedParams[key] = paramValue;
+    } catch {
+      return { ok: false, error: "invalid_param_encoding" };
+    }
+  }
+  if (!hasExpectedPublishedRuntimeCacheKeyParams(endpoint, normalizedParams)) {
+    return { ok: false, error: "invalid_param_encoding" };
+  }
+  return {
+    ok: true,
+    key: unsafeAsPublishedRuntimeCacheKey(value),
+    endpoint,
+    normalizedParams
+  };
+}
+function hasExpectedPublishedRuntimeCacheKeyParams(endpoint, normalizedParams) {
+  const keys = Object.keys(normalizedParams).sort();
+  switch (endpoint) {
+    case "getSite": {
+      const identityKeys = ["domain", "id", "slug"].filter(
+        (key) => normalizedParams[key] !== void 0
+      );
+      return identityKeys.length === 1 && normalizedParams.currentPath !== void 0 && keys.every(
+        (key) => ["currentPath", "domain", "id", "slug"].includes(key)
+      );
+    }
+    case "getContentByPath":
+      return normalizedParams.path !== void 0 && normalizedParams.siteId !== void 0 && keys.every((key) => ["path", "siteId"].includes(key));
+  }
+}
+function parsePublishedRuntimeCachePayloadSchemaVersion(value) {
+  if (typeof value !== "number") {
+    return { ok: false, error: "not_number" };
+  }
+  if (!Number.isInteger(value)) {
+    return { ok: false, error: "not_integer" };
+  }
+  if (value <= 0) {
+    return { ok: false, error: "not_positive" };
+  }
+  return {
+    ok: true,
+    value
+  };
+}
+function classifyPublishedRuntimeCacheFreshness(input) {
+  const freshUntilMs = Date.parse(input.freshUntil);
+  const staleUntilMs = Date.parse(input.staleUntil);
+  if (Number.isNaN(freshUntilMs)) {
+    return { kind: "invalid_timestamp", field: "freshUntil" };
+  }
+  if (Number.isNaN(staleUntilMs)) {
+    return { kind: "invalid_timestamp", field: "staleUntil" };
+  }
+  const nowMs = input.now.getTime();
+  if (nowMs > staleUntilMs) {
+    return { kind: "expired" };
+  }
+  if (nowMs <= freshUntilMs) {
+    return { kind: "fresh", staleAgeSec: 0 };
+  }
+  return {
+    kind: "stale",
+    staleAgeSec: Math.floor((nowMs - freshUntilMs) / 1e3)
+  };
+}
+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,
+  baseDelayMs: 200,
+  maxDelayMs: 2e3,
+  jitter: "full"
+};
+var DEFAULT_CIRCUIT_BREAKER_CONFIG = {
+  failureThreshold: 5,
+  resetTimeoutMs: 3e4,
+  halfOpenMaxRequests: 2
+};
+var PERMANENT_NETWORK_ERROR_CODES = /* @__PURE__ */ new Set([
+  "ECONNREFUSED",
+  // Server is not running / port not listening
+  "ENOTFOUND",
+  // DNS lookup failed - hostname doesn't exist
+  "EAI_AGAIN"
+  // DNS lookup timeout (usually permanent for invalid hosts)
+]);
+var TRANSIENT_NETWORK_ERROR_CODES = /* @__PURE__ */ new Set([
+  "ECONNRESET",
+  // Connection was reset mid-request (server dropped it)
+  "EPIPE",
+  // Broken pipe (connection closed while writing)
+  "ETIMEDOUT",
+  // Connection timed out (could be temporary congestion)
+  "ESOCKETTIMEDOUT"
+  // Socket timeout
+]);
+var NODE_NETWORK_ERROR_CODES = /* @__PURE__ */ new Set([
+  // Permanent
+  "ECONNREFUSED",
+  "ENOTFOUND",
+  "EAI_AGAIN",
+  // Transient
+  "ECONNRESET",
+  "EPIPE",
+  "ETIMEDOUT",
+  "ESOCKETTIMEDOUT"
+]);
+function isNodeNetworkErrorCode(code) {
+  return !code.includes(":") && NODE_NETWORK_ERROR_CODES.has(code);
+}
+function getErrorCodeFromCause(error) {
+  let current = error;
+  while (current) {
+    const nodeError = current;
+    if (nodeError.code && typeof nodeError.code === "string") {
+      if (isNodeNetworkErrorCode(nodeError.code)) {
+        return nodeError.code;
+      }
+    }
+    const errorWithCause = current;
+    current = errorWithCause.cause;
+  }
+  return void 0;
+}
+function isTransientError(error) {
+  if (error instanceof RiverbankApiError) {
+    const errorCode = getErrorCodeFromCause(error);
+    if (errorCode && PERMANENT_NETWORK_ERROR_CODES.has(errorCode)) {
+      return false;
+    }
+    if (error.status === 0) return true;
+    if (error.status === 429) return true;
+    if (error.status >= 500) return true;
+    return false;
+  }
+  if (error instanceof TypeError) {
+    const errorCode = getErrorCodeFromCause(error);
+    if (errorCode) {
+      if (PERMANENT_NETWORK_ERROR_CODES.has(errorCode)) {
+        return false;
       }
       if (TRANSIENT_NETWORK_ERROR_CODES.has(errorCode)) {
         return true;
@@ -7481,12 +8073,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) {
@@ -7720,6 +8357,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,
@@ -7729,7 +8368,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);
@@ -7739,6 +8378,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();
@@ -7754,7 +8467,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()) {
@@ -7766,6 +8483,7 @@ function createRiverbankClient(config) {
             stale.value,
             statusDetails({
               staleAgeSec: stale.staleAgeSec,
+              cacheTier: "memory-stale",
               error: {
                 code: "circuit_open",
                 message: "Circuit breaker is open"
@@ -7774,6 +8492,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) {
@@ -7782,6 +8509,8 @@ function createRiverbankClient(config) {
             prebuildResult.data,
             statusDetails({
               prebuildAgeSec: prebuildResult.prebuildAgeSec,
+              cacheTier: "prebuild",
+              durableCache,
               error: {
                 code: "circuit_open",
                 message: "Circuit breaker is open"
@@ -7795,6 +8524,7 @@ function createRiverbankClient(config) {
         "error",
         null,
         statusDetails({
+          durableCache,
           error: { code: "circuit_open", message: "Circuit breaker is open" }
         })
       );
@@ -7835,6 +8565,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) {
@@ -7843,44 +8576,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);
     }
@@ -7930,8 +8666,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) => {
@@ -7954,13 +8694,19 @@ function createRiverbankClient(config) {
       {
         signal,
         force,
+        publishedRuntimeCache,
         prebuildFallback: prebuildLoader && siteId ? () => prebuildLoader.loadSite(siteId) : void 0
       }
     );
   }
   async function getPageWithResilienceInternal(params) {
     const { siteId, path: path3, preview = false, signal } = params;
-    const cacheKey = `page:${siteId}:${path3}:${preview}`;
+    const publishedRuntimeCache = planPublishedRuntimeCache({
+      endpoint: "getContentByPath",
+      params: { siteId, path: path3, preview },
+      siteId
+    });
+    const cacheKey = publishedRuntimeCache?.cacheKey ?? `page:${siteId}:${path3}:${preview}`;
     return resilientFetch(
       cacheKey,
       async (sig) => {
@@ -7973,6 +8719,7 @@ function createRiverbankClient(config) {
       {
         preview,
         signal,
+        publishedRuntimeCache,
         // Prebuild fallback only for published pages (not preview)
         prebuildFallback: prebuildLoader && !preview ? () => prebuildLoader.loadPage(siteId, path3) : void 0
       }
@@ -9106,176 +9853,6 @@ function createPrebuildLoader(config) {
   return new PrebuildLoader(config);
 }
 
-// src/public-api/runtime.ts
-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"
-  }
-});
-function buildEndpointURL2(baseURL, endpoint) {
-  return baseURL + API_ENDPOINTS2[endpoint].path;
-}
-
 // src/types/block-kinds.ts
 var SYSTEM_BLOCK_KINDS = [
   // Layout blocks
@@ -9329,14 +9906,23 @@ var SYSTEM_BLOCK_KINDS = [
 ];
 export {
   API_ENDPOINTS2 as API_ENDPOINTS,
+  DEFAULT_PUBLISHED_RUNTIME_CACHE_PAYLOAD_SCHEMA_VERSION,
   PrebuildLoader,
   RiverbankApiError,
   SDK_CORRELATION_HEADER_NAMES,
   SYSTEM_BLOCK_KINDS,
   buildEndpointURL2 as buildEndpointURL,
   canUsePrebuild,
+  classifyPublishedRuntimeCacheFreshness,
   createPrebuildLoader,
   createRiverbankClient,
+  derivePublishedRuntimeCacheKey,
   getResilienceStatusFromError,
-  prebuildCache
+  isPublishedRuntimeCacheKeyEndpoint,
+  normalizeRuntimePublicPath,
+  parsePublishedRuntimeCacheKey,
+  parsePublishedRuntimeCacheKeyDetails,
+  parsePublishedRuntimeCachePayloadSchemaVersion,
+  prebuildCache,
+  resolveRuntimeCachePolicy
 };