@riverbankcms/sdk 0.85.0 → 0.89.1

package/dist/cli/index.mjs

@@ -109,6 +109,57 @@ var init_collections = __esm({
   }
 });
 
+// ../core/src/assert-never.ts
+function assertNever(value, message = "Unexpected variant") {
+  throw new Error(`${message}: ${String(value)}`);
+}
+var init_assert_never = __esm({
+  "../core/src/assert-never.ts"() {
+  }
+});
+
+// ../core/src/currency-format.ts
+function resolveCurrencyLocale(currencyCode, override) {
+  return CURRENCY_LOCALE_BY_CODE[currencyCode] ?? "en";
+}
+function formatCurrencyAmount(amountCents, currency, options) {
+  const currencyCode = currency.toUpperCase();
+  const locale = resolveCurrencyLocale(currencyCode);
+  try {
+    const exactFormatter = new Intl.NumberFormat(locale, {
+      style: "currency",
+      currency: currencyCode
+    });
+    const fractionDigits = options?.decimals === "auto" ? {
+      minimumFractionDigits: 0,
+      maximumFractionDigits: exactFormatter.resolvedOptions().maximumFractionDigits
+    } : {};
+    return new Intl.NumberFormat(locale, {
+      style: "currency",
+      currency: currencyCode,
+      ...fractionDigits
+    }).format(amountCents / 100);
+  } catch {
+    return `${(amountCents / 100).toFixed(2)} ${currencyCode}`;
+  }
+}
+var CURRENCY_LOCALE_BY_CODE;
+var init_currency_format = __esm({
+  "../core/src/currency-format.ts"() {
+    CURRENCY_LOCALE_BY_CODE = {
+      USD: "en-US",
+      GBP: "en-GB",
+      EUR: "de-DE",
+      AUD: "en-AU",
+      CAD: "en-CA",
+      NZD: "en-NZ",
+      JPY: "ja-JP",
+      CNY: "zh-CN",
+      CHF: "de-CH"
+    };
+  }
+});
+
 // ../core/src/event-pricing.ts
 function publicEventPricingType(pricing) {
   switch (pricing.kind) {
@@ -129,6 +180,7 @@ function isFreePublicEventPriceDisplay(display) {
       return display.display.kind === "free";
     case "exact":
     case "from":
+    case "range":
     case "mixed":
     case "unavailable":
       return false;
@@ -343,15 +395,6 @@ var init_business_address = __esm({
   }
 });
 
-// ../core/src/assert-never.ts
-function assertNever(value, message = "Unexpected variant") {
-  throw new Error(`${message}: ${String(value)}`);
-}
-var init_assert_never = __esm({
-  "../core/src/assert-never.ts"() {
-  }
-});
-
 // ../core/src/narrow-result.ts
 var init_narrow_result = __esm({
   "../core/src/narrow-result.ts"() {
@@ -454,12 +497,6 @@ var init_csv_types = __esm({
   }
 });
 
-// ../core/src/currency-format.ts
-var init_currency_format = __esm({
-  "../core/src/currency-format.ts"() {
-  }
-});
-
 // ../core/src/email-format.ts
 var init_email_format = __esm({
   "../core/src/email-format.ts"() {
@@ -490,6 +527,12 @@ var init_stable_json = __esm({
   }
 });
 
+// ../core/src/site-route-target.ts
+var init_site_route_target = __esm({
+  "../core/src/site-route-target.ts"() {
+  }
+});
+
 // ../core/src/index.ts
 var init_src = __esm({
   "../core/src/index.ts"() {
@@ -536,6 +579,7 @@ var init_src = __esm({
     init_string();
     init_uuid();
     init_stable_json();
+    init_site_route_target();
   }
 });
 
@@ -17955,15 +17999,53 @@ var init_newsletterForm = __esm({
       title: "Newsletter Form",
       description: "Newsletter subscription form with preset field configurations.",
       fields: [
+        {
+          id: "destinationProvider",
+          type: "select",
+          label: "Send signups to",
+          description: "Choose where new subscribers from this form should go.",
+          defaultValue: "riverbank",
+          required: true,
+          ui: { intent: "behavior" },
+          options: [
+            { value: "riverbank", label: "Riverbank newsletter" }
+          ]
+        },
         {
           id: "listId",
           type: "reference",
           label: "Newsletter list",
           description: "Select the list new subscribers should be added to.",
-          required: true,
+          required: false,
           referenceKind: "newsletterList",
           allowManualEntry: false,
-          ui: { intent: "behavior" }
+          ui: {
+            intent: "behavior",
+            visibleWhen: { field: "destinationProvider", equals: "riverbank" }
+          }
+        },
+        {
+          id: "mailchimpAudienceId",
+          type: "reference",
+          label: "Mailchimp audience",
+          description: "Choose the Mailchimp audience for new subscribers.",
+          required: false,
+          referenceKind: "mailchimpAudience",
+          allowManualEntry: false,
+          ui: {
+            intent: "behavior",
+            visibleWhen: { field: "destinationProvider", equals: "mailchimp" }
+          }
+        },
+        {
+          id: "mailchimpTags",
+          type: "text",
+          label: "Mailchimp tags",
+          description: "Optional tags to apply in Mailchimp, separated by commas or semicolons.",
+          ui: {
+            intent: "behavior",
+            visibleWhen: { field: "destinationProvider", equals: "mailchimp" }
+          }
         },
         {
           id: "preset",
@@ -18010,13 +18092,18 @@ var init_newsletterForm = __esm({
           id: "tags",
           type: "text",
           label: "Tags (optional)",
-          description: "Optional tags to apply on subscribe (comma or semicolon separated)."
+          description: "Optional tags to apply on subscribe (comma or semicolon separated).",
+          ui: {
+            intent: "behavior",
+            visibleWhen: { field: "destinationProvider", equals: "riverbank" }
+          }
         }
       ],
       layout: [
         el(
           "newsletter-form",
           withApiBindings({
+            destinationProvider: { $bind: { from: "destinationProvider" } },
             listId: { $bind: { from: "listId" } },
             preset: { $bind: { from: "preset" } },
             includePhone: { $bind: { from: "includePhone" } },
@@ -18522,6 +18609,83 @@ var init_media2 = __esm({
     ]);
   }
 });
+function createHardBreakNode() {
+  return { type: "hardBreak" };
+}
+function parseRichTextInlineMarkdown(text2) {
+  const out = [];
+  const pushText = (value, marks) => {
+    if (!value) return;
+    out.push(
+      marks && marks.length > 0 ? { type: "text", text: value, marks } : { type: "text", text: value }
+    );
+  };
+  let rest = text2;
+  while (rest.length > 0) {
+    const start = rest.indexOf("**");
+    if (start === -1) {
+      pushText(rest);
+      break;
+    }
+    const end = rest.indexOf("**", start + 2);
+    if (end === -1) {
+      pushText(rest);
+      break;
+    }
+    pushText(rest.slice(0, start));
+    pushText(rest.slice(start + 2, end), [{ type: "bold" }]);
+    rest = rest.slice(end + 2);
+  }
+  return out;
+}
+function parseRichTextParagraphInlineMarkdown(text2) {
+  return text2.split("\n").flatMap((line, index) => {
+    const lineNodes = parseRichTextInlineMarkdown(line.trim());
+    return index === 0 ? lineNodes : [createHardBreakNode(), ...lineNodes];
+  });
+}
+function createRichTextDocFromMarkdown(markdown) {
+  const normalized = markdown.replace(/\r\n/g, "\n").trim();
+  if (!normalized) return { type: "doc", content: [] };
+  const paragraphs = normalized.split(/\n{2,}/).map((paragraph) => paragraph.trim()).filter(Boolean);
+  return {
+    type: "doc",
+    content: paragraphs.map((paragraph) => {
+      const inline2 = parseRichTextParagraphInlineMarkdown(paragraph);
+      return inline2.length > 0 ? { type: "paragraph", content: inline2 } : { type: "paragraph" };
+    })
+  };
+}
+var TipTapMarkSchema, TipTapNodeSchema, RichTextDocSchema;
+var init_richTextSchema = __esm({
+  "../blocks/src/system/manifest/richTextSchema.ts"() {
+    TipTapMarkSchema = z.object({
+      type: z.string(),
+      attrs: z.record(z.string(), z.unknown()).optional()
+    });
+    TipTapNodeSchema = z.lazy(
+      () => z.object({
+        type: z.string(),
+        content: z.array(TipTapNodeSchema).optional(),
+        text: z.string().optional(),
+        attrs: z.record(z.string(), z.unknown()).optional(),
+        marks: z.array(TipTapMarkSchema).optional()
+      })
+    );
+    z.union([
+      // Canonical: TipTap document directly
+      TipTapNodeSchema,
+      // Legacy (read-tolerance only): wrapped in { doc: {...} }
+      z.object({
+        doc: TipTapNodeSchema
+      })
+    ]);
+    RichTextDocSchema = z.object({
+      type: z.literal("doc"),
+      content: z.array(TipTapNodeSchema)
+    });
+  }
+});
 var bookingDepositRefundPolicySchema, bookingInstalmentPlanSchema, bookingFlexibleBalanceDueDateRuleSchema, bookingFlexibleBalanceConfigSchema, blockBookingPaymentCollectionOptionSchema, blockBookingPaymentTermsSchema;
 var init_bookingPaymentTerms = __esm({
   "../blocks/src/system/blocks/shared/bookingPaymentTerms.ts"() {
@@ -18660,6 +18824,7 @@ var eventPresetSchema, eventScheduleScopeSchema, eventDestinationModeSchema, eve
 var init_schemas2 = __esm({
   "../blocks/src/system/blocks/events/shared/schemas.ts"() {
     init_media2();
+    init_richTextSchema();
     init_bookingPaymentTerms();
     init_schemas();
     eventPresetSchema = z.enum(["event", "class", "workshop", "retreat", "performance"]);
@@ -18692,7 +18857,13 @@ var init_schemas2 = __esm({
       z.object({ kind: z.literal("free"), currency: z.string() }),
       z.object({ kind: z.literal("exact"), amount: z.number(), currency: z.string() }),
       z.object({ kind: z.literal("from"), amount: z.number(), currency: z.string() }),
-      z.object({ kind: z.literal("mixed"), paidFromAmount: z.number(), currency: z.string() }),
+      z.object({ kind: z.literal("range"), minAmount: z.number(), maxAmount: z.number(), currency: z.string() }),
+      z.object({
+        kind: z.literal("mixed"),
+        paidFromAmount: z.number(),
+        paidToAmount: z.number(),
+        currency: z.string()
+      }),
       z.object({ kind: z.literal("unavailable"), currency: z.string() }),
       z.object({ kind: z.literal("course"), display: publicCoursePriceDisplaySchema })
     ]);
@@ -18700,7 +18871,13 @@ var init_schemas2 = __esm({
       z.object({ kind: z.literal("free"), currency: z.string() }),
       z.object({ kind: z.literal("exact"), amount: z.number(), currency: z.string() }),
       z.object({ kind: z.literal("from"), amount: z.number(), currency: z.string() }),
-      z.object({ kind: z.literal("mixed"), paidFromAmount: z.number(), currency: z.string() }),
+      z.object({ kind: z.literal("range"), minAmount: z.number(), maxAmount: z.number(), currency: z.string() }),
+      z.object({
+        kind: z.literal("mixed"),
+        paidFromAmount: z.number(),
+        paidToAmount: z.number(),
+        currency: z.string()
+      }),
       z.object({ kind: z.literal("unavailable"), currency: z.string() })
     ]);
     publicEventAttendanceModeSchema = z.enum(["in_person", "online"]);
@@ -18785,6 +18962,9 @@ var init_schemas2 = __esm({
       seriesId: z.string(),
       title: z.string(),
       description: z.string().nullable(),
+      content: z.object({
+        body: RichTextDocSchema.nullable().optional()
+      }).optional(),
       presentation: z.object({
         cardTitleOverride: z.string().nullable().optional(),
         summary: z.string().nullable().optional(),
@@ -19167,10 +19347,21 @@ function readLegacyPriceDisplay(value, currency) {
         amount: readAmount(value.amount) ?? 0,
         currency: displayCurrency
       } : { kind: "unavailable", currency };
+    case "range": {
+      const minAmount = readAmount(value.minAmount);
+      const maxAmount = readAmount(value.maxAmount);
+      return minAmount !== null && maxAmount !== null ? {
+        kind: "range",
+        minAmount,
+        maxAmount,
+        currency: displayCurrency
+      } : { kind: "unavailable", currency };
+    }
     case "mixed":
       return readAmount(value.paidFromAmount) !== null ? {
         kind: "mixed",
         paidFromAmount: readAmount(value.paidFromAmount) ?? 0,
+        paidToAmount: readAmount(value.paidToAmount) ?? readAmount(value.paidFromAmount) ?? 0,
         currency: displayCurrency
       } : { kind: "unavailable", currency };
     case "unavailable":
@@ -19425,6 +19616,7 @@ var init_event_registration_interactive = __esm({
       successMessage: z.string().optional(),
       waitlistMessage: z.string().optional(),
       buttonVariant: registrationButtonVariantSchema.optional(),
+      overlayEnabled: z.boolean().optional(),
       spamProtectionEnabled: z.boolean().optional(),
       stage: previewStageSchema.optional(),
       supportEmail: z.string().optional()
@@ -19448,6 +19640,7 @@ var init_event_registration_interactive = __esm({
       successMessage: z.string().optional(),
       waitlistMessage: z.string().optional(),
       buttonVariant: registrationButtonVariantSchema.optional(),
+      overlayEnabled: z.boolean().optional(),
       spamProtectionEnabled: z.boolean().optional(),
       supportEmail: z.string().optional()
     });
@@ -19480,6 +19673,7 @@ var init_event_registration_interactive = __esm({
           successMessage: source.successMessage,
           waitlistMessage: source.waitlistMessage,
           buttonVariant: source.buttonVariant,
+          overlayEnabled: source.overlayEnabled,
           spamProtectionEnabled: source.spamProtectionEnabled,
           supportEmail: source.supportEmail
         }
@@ -20503,10 +20697,7 @@ var init_shop_commerce_shared = __esm({
 
 // ../blocks/src/system/runtime/nodes/commerce/shared/display.ts
 function formatCommercePrice(cents, currency) {
-  return new Intl.NumberFormat("en-US", {
-    style: "currency",
-    currency: currency.toUpperCase()
-  }).format(cents / 100);
+  return formatCurrencyAmount(cents, currency);
 }
 function getPassesHeading(passes, explicitHeading) {
   if (explicitHeading) return explicitHeading;
@@ -20700,6 +20891,7 @@ function formatValidity(days) {
 }
 var init_display = __esm({
   "../blocks/src/system/runtime/nodes/commerce/shared/display.ts"() {
+    init_src();
     init_creditProducts();
     init_shop_commerce_shared();
   }
@@ -21162,6 +21354,65 @@ var init_gifting_interactive = __esm({
   }
 });
 
+// ../blocks/src/system/blocks/newsletter-signup-destination.ts
+function parseNewsletterSignupBlockId(value) {
+  const trimmed = parseTrimmedString(value);
+  return trimmed && BLOCK_ID_PATTERN.test(trimmed) ? trimmed : null;
+}
+function parseSignedNewsletterDestinationRef(value) {
+  const trimmed = parseTrimmedString(value);
+  return trimmed && SIGNED_DESTINATION_REF_PATTERN.test(trimmed) ? trimmed : null;
+}
+function parseNewsletterSignupDestinationProvider(value) {
+  return value === "riverbank" || value === "mailchimp" ? value : null;
+}
+function buildNewsletterSignupBlockRef(blockId) {
+  const parsed = parseNewsletterSignupBlockId(blockId);
+  return parsed ? { tag: "block_ref", blockId: parsed } : null;
+}
+function normalizeNewsletterSignupEditorValuesForDestination(values) {
+  const destinationProvider = parseNewsletterSignupDestinationProvider(values.destinationProvider) ?? "riverbank";
+  if (destinationProvider === "mailchimp") {
+    return {
+      destinationProvider,
+      mailchimpAudienceId: values.mailchimpAudienceId,
+      mailchimpTags: values.mailchimpTags
+    };
+  }
+  return {
+    destinationProvider,
+    listId: values.listId,
+    tags: values.tags
+  };
+}
+function deriveNewsletterSignupRuntimeSource(values) {
+  const normalized = normalizeNewsletterSignupEditorValuesForDestination(values);
+  if (normalized.destinationProvider === "mailchimp") {
+    return {
+      destinationProvider: "mailchimp",
+      listId: null,
+      tags: null
+    };
+  }
+  return {
+    destinationProvider: "riverbank",
+    listId: parseTrimmedString(normalized.listId),
+    tags: parseTrimmedString(normalized.tags)
+  };
+}
+function parseTrimmedString(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+var BLOCK_ID_PATTERN, SIGNED_DESTINATION_REF_PATTERN;
+var init_newsletter_signup_destination = __esm({
+  "../blocks/src/system/blocks/newsletter-signup-destination.ts"() {
+    BLOCK_ID_PATTERN = /^[A-Za-z0-9._:-]{1,200}$/;
+    SIGNED_DESTINATION_REF_PATTERN = /^[A-Za-z0-9._~-]{16,1000}$/;
+  }
+});
+
 // ../blocks/src/system/runtime/nodes/newsletter-form.types.ts
 function getPresetFields(preset2, options) {
   const includePhone = Boolean(options?.includePhone);
@@ -21227,13 +21478,29 @@ function buildNewsletterDisplay(source) {
     fields: getPresetFields(preset2, { includePhone })
   };
 }
-var newsletterPresetSchema, newsletterFieldSchema, newsletterSourceSchema, newsletterDisplaySchema, newsletterHydrationSchema, newsletterRenderSchema, newsletterFormBlockRuntime;
+function parseRequiredNewsletterSignupBlockId(value) {
+  const parsed = parseNewsletterSignupBlockId(value);
+  if (!parsed) {
+    throw new Error("Newsletter signup block destination ref requires blockId");
+  }
+  return parsed;
+}
+function parseRequiredSignedNewsletterDestinationRef(value) {
+  const parsed = parseSignedNewsletterDestinationRef(value);
+  if (!parsed) {
+    throw new Error("Newsletter signup signed destination ref requires token");
+  }
+  return parsed;
+}
+var newsletterPresetSchema, newsletterDestinationProviderSchema, newsletterFieldSchema, newsletterSignupBlockIdSchema, signedNewsletterDestinationRefSchema, newsletterPublicDestinationRefSchema, newsletterSourceSchema, newsletterDisplaySchema, newsletterHydrationSchema, newsletterRenderSchema, newsletterFormBlockRuntime;
 var init_newsletter_form_interactive = __esm({
   "../blocks/src/system/runtime/nodes/newsletter-form.interactive.ts"() {
     init_islands();
     init_runtime();
+    init_newsletter_signup_destination();
     init_newsletter_form_types();
     newsletterPresetSchema = z.enum(["emailOnly", "emailName", "emailFirstLast", "emailNameCompany"]);
+    newsletterDestinationProviderSchema = z.enum(["riverbank", "mailchimp"]);
     newsletterFieldSchema = z.object({
       id: z.string(),
       type: z.enum(["email", "text"]),
@@ -21241,10 +21508,24 @@ var init_newsletter_form_interactive = __esm({
       required: z.boolean(),
       placeholder: z.string().optional()
     });
+    newsletterSignupBlockIdSchema = z.string().trim().min(1).transform(parseRequiredNewsletterSignupBlockId);
+    signedNewsletterDestinationRefSchema = z.string().trim().min(1).transform(parseRequiredSignedNewsletterDestinationRef);
+    newsletterPublicDestinationRefSchema = z.discriminatedUnion("tag", [
+      z.object({
+        tag: z.literal("block_ref"),
+        blockId: newsletterSignupBlockIdSchema
+      }),
+      z.object({
+        tag: z.literal("signed_destination_ref"),
+        token: signedNewsletterDestinationRefSchema
+      })
+    ]);
     newsletterSourceSchema = z.object({
+      blockId: z.string().nullable().optional(),
       siteId: z.string().optional(),
       apiBaseUrl: z.string().optional(),
       listId: z.string().nullable().optional(),
+      destinationProvider: newsletterDestinationProviderSchema.nullable().optional(),
       preset: newsletterPresetSchema.optional(),
       includePhone: z.boolean().optional(),
       buttonLabel: z.string().nullable().optional(),
@@ -21263,6 +21544,7 @@ var init_newsletter_form_interactive = __esm({
       fields: z.array(newsletterFieldSchema)
     });
     newsletterHydrationSchema = z.object({
+      destinationRef: newsletterPublicDestinationRefSchema.nullable().optional(),
       listId: z.string().nullable().optional(),
       preset: newsletterPresetSchema,
       includePhone: z.boolean(),
@@ -21283,16 +21565,20 @@ var init_newsletter_form_interactive = __esm({
         source: createZodCodec(newsletterSourceSchema),
         render: createZodCodec(newsletterRenderSchema)
       },
-      buildRender: (source) => ({
-        display: buildNewsletterDisplay(source),
-        hydration: {
-          listId: source.listId,
-          preset: source.preset ?? "emailOnly",
-          includePhone: source.includePhone ?? false,
-          tags: source.tags ?? null,
-          spamProtectionEnabled: source.spamProtectionEnabled
-        }
-      })
+      buildRender: (source) => {
+        const runtimeSource = deriveNewsletterSignupRuntimeSource(source);
+        return {
+          display: buildNewsletterDisplay(source),
+          hydration: {
+            destinationRef: buildNewsletterSignupBlockRef(source.blockId),
+            listId: runtimeSource.listId,
+            preset: source.preset ?? "emailOnly",
+            includePhone: source.includePhone ?? false,
+            tags: runtimeSource.tags,
+            spamProtectionEnabled: source.spamProtectionEnabled
+          }
+        };
+      }
     });
   }
 });
@@ -22309,6 +22595,64 @@ var ENDPOINT_DEFINITIONS = {
     auth: "user",
     responseKind: "json"
   },
+  listMailchimpAudiences: {
+    path: "/sites/{siteId}/integrations/mailchimp/audiences",
+    method: "GET",
+    tags: [TAG_TEMPLATES.site],
+    auth: "user",
+    responseKind: "json",
+    errors: ["auth:forbidden", "server:internal_error"]
+  },
+  getMailchimpSignupSyncHealth: {
+    path: "/sites/{siteId}/integrations/mailchimp/signup-sync-health",
+    method: "GET",
+    tags: [TAG_TEMPLATES.site],
+    auth: "user",
+    responseKind: "json",
+    errors: ["auth:forbidden", "server:internal_error"]
+  },
+  getMailchimpConnection: {
+    path: "/sites/{siteId}/integrations/mailchimp/connection",
+    method: "GET",
+    tags: [TAG_TEMPLATES.site],
+    auth: "user",
+    responseKind: "json",
+    errors: ["auth:forbidden", "server:internal_error"]
+  },
+  startMailchimpOAuth: {
+    path: "/sites/{siteId}/integrations/mailchimp/oauth/start",
+    method: "POST",
+    tags: [TAG_TEMPLATES.site],
+    auth: "user",
+    responseKind: "json",
+    demoMutation: DEMO_MUTATION_BLOCKED_DISABLED,
+    errors: ["auth:forbidden", "validation:invalid_input", "server:internal_error"]
+  },
+  refreshMailchimpAudiences: {
+    path: "/sites/{siteId}/integrations/mailchimp/audiences/refresh",
+    method: "POST",
+    tags: [TAG_TEMPLATES.site],
+    auth: "user",
+    responseKind: "json",
+    demoMutation: DEMO_MUTATION_BLOCKED_DISABLED,
+    errors: ["auth:forbidden", "server:internal_error"]
+  },
+  disconnectMailchimp: {
+    path: "/sites/{siteId}/integrations/mailchimp/disconnect",
+    method: "POST",
+    tags: [TAG_TEMPLATES.site],
+    auth: "user",
+    responseKind: "json",
+    demoMutation: DEMO_MUTATION_BLOCKED_DISABLED,
+    errors: ["auth:forbidden", "server:internal_error"]
+  },
+  mailchimpOAuthCallback: {
+    path: "/auth/mailchimp/callback",
+    method: "GET",
+    auth: "public",
+    responseKind: "void",
+    errors: []
+  },
   createNewsletterList: {
     path: "/sites/{siteId}/newsletter/lists",
     method: "POST",
@@ -23310,6 +23654,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",
@@ -24533,20 +24895,6 @@ var ENDPOINT_DEFINITIONS = {
     auth: "user",
     responseKind: "json"
   },
-  instagramUploadZip: {
-    path: "/instagram/upload-zip",
-    method: "POST",
-    tags: ["instagram-import"],
-    auth: "user",
-    responseKind: "json"
-  },
-  createInstagramZipUploadUrl: {
-    path: "/instagram/upload-zip-url",
-    method: "POST",
-    tags: ["instagram-import"],
-    auth: "user",
-    responseKind: "json"
-  },
   getAnalyticsReport: {
     path: "/sites/{siteId}/analytics/report",
     method: "GET",
@@ -35102,6 +35450,12 @@ var eventRegistrationManifest = createBlockManifest({
               buttonVariant: {
                 $bind: { from: "content.buttonVariant", fallback: "primary" }
               },
+              overlayEnabled: {
+                $bind: {
+                  from: "$root.eventRegistrationOverlayEnabled",
+                  fallback: false
+                }
+              },
               // Event data from loader
               events: { $bind: { from: "data.events" } },
               // Stage for preview mode (allows registering for draft events)
@@ -41872,6 +42226,7 @@ var SUPPORTED_LOADER_ENDPOINTS = [
 ];
 
 // ../blocks/src/index.ts
+init_richTextSchema();
 init_booking_form_reserved_fields();
 init_colorStyles();
 
@@ -44125,21 +44480,6 @@ var titleSourceValueSchema = z.union([
   z.array(z.string().min(1)).min(1)
 ]);
 
-// src/data/prefetchBlockData.ts
-var SUPPORTED_LOADER_ENDPOINTS2 = [
-  "listPublishedEntries",
-  "getPublishedEntryPreview",
-  "listPublicEvents",
-  "listPublicCourses",
-  "listPublicTeamMembers",
-  "listPublicProducts",
-  "listPublicPasses",
-  "listPublicMemberships",
-  "getPublicFormById",
-  "getPublicBookingServices",
-  "getPublicEventDetails"
-];
-
 // src/config/validation.ts
 var sdkThemePaletteSchema2 = z.record(z.string(), z.string());
 var sdkThemeConfigSchema2 = z.object({
@@ -44188,7 +44528,7 @@ var siteStyleConfigSchema = z.object({
   sectionOptions: sectionOptionsSchema,
   containerOptions: containerOptionsSchema
 }).optional();
-var sdkLoaderEndpointSchema2 = z.enum(SUPPORTED_LOADER_ENDPOINTS2);
+var sdkLoaderEndpointSchema2 = z.enum(SUPPORTED_LOADER_ENDPOINTS);
 var allowedTransformIds = new Set(builtinTransformDefinitions.map((transform) => transform.id));
 var loaderTransformStepSchema = z.object({
   id: z.string().refine((id) => allowedTransformIds.has(id), {
@@ -64856,7 +65196,7 @@ var SimpleCache = class {
 };
 
 // src/version.ts
-var SDK_VERSION = "0.85.0";
+var SDK_VERSION = "0.89.1";
 
 // src/client/error.ts
 var RiverbankApiError = class _RiverbankApiError extends Error {
@@ -65013,6 +65353,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 assertNever5(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 assertNever5(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_CONFIG2 = {
   maxAttempts: 3,
@@ -65322,12 +66132,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) {
@@ -65561,6 +66416,8 @@ function createRiverbankClient(config2) {
       source,
       isPreview: details.isPreview,
       cacheKey: details.cacheKey,
+      cacheTier: details.cacheTier,
+      durableCache: details.durableCache,
       error: details.error,
       staleAgeSec: details.staleAgeSec,
       prebuildAgeSec: details.prebuildAgeSec,
@@ -65570,7 +66427,7 @@ function createRiverbankClient(config2) {
     };
     lastStatus = status;
     config2.resilience?.onStatusChange?.(status);
-    const nowDegraded = source === "stale" || source === "error";
+    const nowDegraded = isDegradedResilienceStatus(source, details);
     if (nowDegraded !== isDegraded) {
       isDegraded = nowDegraded;
       config2.resilience?.onDegradedMode?.(nowDegraded, status);
@@ -65580,6 +66437,80 @@ function createRiverbankClient(config2) {
       resilience: status
     };
   }
+  async function tryPublishedRuntimeCacheFallback(plan, statusDetails, errorInfo) {
+    const reader = config2.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 = config2.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();
@@ -65595,7 +66526,11 @@ function createRiverbankClient(config2) {
     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()) {
@@ -65607,6 +66542,7 @@ function createRiverbankClient(config2) {
             stale.value,
             statusDetails({
               staleAgeSec: stale.staleAgeSec,
+              cacheTier: "memory-stale",
               error: {
                 code: "circuit_open",
                 message: "Circuit breaker is open"
@@ -65615,6 +66551,15 @@ function createRiverbankClient(config2) {
           );
         }
       }
+      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) {
@@ -65623,6 +66568,8 @@ function createRiverbankClient(config2) {
             prebuildResult.data,
             statusDetails({
               prebuildAgeSec: prebuildResult.prebuildAgeSec,
+              cacheTier: "prebuild",
+              durableCache,
               error: {
                 code: "circuit_open",
                 message: "Circuit breaker is open"
@@ -65636,6 +66583,7 @@ function createRiverbankClient(config2) {
         "error",
         null,
         statusDetails({
+          durableCache,
           error: { code: "circuit_open", message: "Circuit breaker is open" }
         })
       );
@@ -65676,6 +66624,9 @@ function createRiverbankClient(config2) {
       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) {
@@ -65684,44 +66635,47 @@ function createRiverbankClient(config2) {
       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);
     }
@@ -65771,8 +66725,12 @@ function createRiverbankClient(config2) {
       );
     }
     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) => {
@@ -65795,13 +66753,19 @@ function createRiverbankClient(config2) {
       {
         signal,
         force,
+        publishedRuntimeCache,
         prebuildFallback: prebuildLoader && siteId ? () => prebuildLoader.loadSite(siteId) : void 0
       }
     );
   }
   async function getPageWithResilienceInternal(params) {
     const { siteId, path: path27, preview = false, signal } = params;
-    const cacheKey = `page:${siteId}:${path27}:${preview}`;
+    const publishedRuntimeCache = planPublishedRuntimeCache({
+      endpoint: "getContentByPath",
+      params: { siteId, path: path27, preview },
+      siteId
+    });
+    const cacheKey = publishedRuntimeCache?.cacheKey ?? `page:${siteId}:${path27}:${preview}`;
     return resilientFetch(
       cacheKey,
       async (sig) => {
@@ -65814,6 +66778,7 @@ function createRiverbankClient(config2) {
       {
         preview,
         signal,
+        publishedRuntimeCache,
         // Prebuild fallback only for published pages (not preview)
         prebuildFallback: prebuildLoader && !preview ? () => prebuildLoader.loadPage(siteId, path27) : void 0
       }
@@ -66010,10 +66975,16 @@ function createRiverbankClient(config2) {
         limit,
         from,
         to,
+        afterStartsAt,
+        afterId,
         stage,
         categoryIds,
         venueId,
+        staffMemberId,
         kind,
+        eventSurface,
+        eventPresets,
+        scheduleScope,
         entryId,
         seriesId,
         includeOccurrenceId,
@@ -66022,7 +66993,7 @@ function createRiverbankClient(config2) {
       if (!siteId) {
         throw new Error("listPublicEvents() requires siteId");
       }
-      const cacheKey = `public-events:${siteId}:${limit ?? ""}:${from ?? ""}:${to ?? ""}:${stage ?? ""}:${categoryIds ?? ""}:${venueId ?? ""}:${kind ?? ""}:${entryId ?? ""}:${seriesId ?? ""}:${includeOccurrenceId ?? ""}`;
+      const cacheKey = `public-events:${siteId}:${limit ?? ""}:${from ?? ""}:${to ?? ""}:${afterStartsAt ?? ""}:${afterId ?? ""}:${stage ?? ""}:${categoryIds ?? ""}:${venueId ?? ""}:${staffMemberId ?? ""}:${kind ?? ""}:${eventSurface ?? ""}:${eventPresets ?? ""}:${scheduleScope ?? ""}:${entryId ?? ""}:${seriesId ?? ""}:${includeOccurrenceId ?? ""}`;
       return resilientFetchData(
         cacheKey,
         async (sig) => {
@@ -66031,10 +67002,16 @@ function createRiverbankClient(config2) {
             ...typeof limit === "number" && { limit: String(limit) },
             ...from && { from },
             ...to && { to },
+            ...afterStartsAt && { afterStartsAt },
+            ...afterId && { afterId },
             ...stage && { stage },
             ...categoryIds && { categoryIds },
             ...venueId && { venueId },
+            ...staffMemberId && { staffMemberId },
             ...kind && { kind },
+            ...eventSurface && { eventSurface },
+            ...eventPresets && { eventPresets },
+            ...scheduleScope && { scheduleScope },
             ...entryId && { entryId },
             ...seriesId && { seriesId },
             ...includeOccurrenceId && { includeOccurrenceId }
@@ -66061,6 +67038,9 @@ function createRiverbankClient(config2) {
         venueId,
         staffMemberId,
         kind,
+        eventSurface,
+        eventPresets,
+        scheduleScope,
         entryId,
         seriesId,
         includeOccurrenceId,
@@ -66069,7 +67049,7 @@ function createRiverbankClient(config2) {
       if (!siteId) {
         throw new Error("getPublicEventDetails() requires siteId");
       }
-      const cacheKey = `public-event-details:${siteId}:${limit ?? ""}:${from ?? ""}:${to ?? ""}:${afterStartsAt ?? ""}:${afterId ?? ""}:${stage ?? ""}:${categoryIds ?? ""}:${venueId ?? ""}:${staffMemberId ?? ""}:${kind ?? ""}:${entryId ?? ""}:${seriesId ?? ""}:${includeOccurrenceId ?? ""}`;
+      const cacheKey = `public-event-details:${siteId}:${limit ?? ""}:${from ?? ""}:${to ?? ""}:${afterStartsAt ?? ""}:${afterId ?? ""}:${stage ?? ""}:${categoryIds ?? ""}:${venueId ?? ""}:${staffMemberId ?? ""}:${kind ?? ""}:${eventSurface ?? ""}:${eventPresets ?? ""}:${scheduleScope ?? ""}:${entryId ?? ""}:${seriesId ?? ""}:${includeOccurrenceId ?? ""}`;
       return resilientFetchData(
         cacheKey,
         async (sig) => {
@@ -66092,6 +67072,9 @@ function createRiverbankClient(config2) {
                     ...venueId && { venueId },
                     ...staffMemberId && { staffMemberId },
                     ...kind && { kind },
+                    ...eventSurface && { eventSurface },
+                    ...eventPresets && { eventPresets },
+                    ...scheduleScope && { scheduleScope },
                     ...entryId && { entryId },
                     ...seriesId && { seriesId },
                     ...includeOccurrenceId && { includeOccurrenceId }
@@ -69582,11 +70565,12 @@ Your task: Analyze the HTML/JSX markup and identify ALL pieces of content that s
 
 1. **Use richText for formatted lists and multi-line content:**
    - Opening hours \u2192 single richText with formatted list (not 6 separate text fields)
-   - Address with line breaks \u2192 single richText (not address1, address2, city, postcode)
+   - Address with line breaks \u2192 single richText with hard line breaks / Shift+Enter between lines (not address1, address2, city, postcode)
    - Feature lists, specs, ingredients \u2192 richText with bullet list
 
-   RichText supports: paragraphs, bold, italic, bullet lists, numbered lists, links.
+   RichText supports: paragraphs, hard line breaks, bold, italic, bullet lists, numbered lists, links.
    The CMS editor can format content naturally without rigid field structure.
+   For line-oriented content like addresses, opening hours, and contact details, keep one logical paragraph and use hard line breaks between lines. In the CMS editor, authors create those line breaks with Shift+Enter; Enter creates a new paragraph.
 
 2. **Use repeaters only when items need individual editing/reordering:**
    - Testimonials with avatar + name + quote \u2192 repeater (each item is distinct)
@@ -69598,8 +70582,8 @@ Your task: Analyze the HTML/JSX markup and identify ALL pieces of content that s
    \u274C socialInstagram, socialFacebook, socialTwitter (proliferating similar fields)
    \u274C address1, address2, city, state, zip (5 fields for one address)
 
-   \u2705 openingHours: single richText field with formatted content
-   \u2705 address: single richText field with line breaks
+   \u2705 openingHours: single richText field with formatted content / hard line breaks
+   \u2705 address: single richText field with hard line breaks (Shift+Enter in the editor)
    \u2705 socialLinks: repeater with { platform, url } IF user needs to add/remove links
 
 ## Field Type Rules
@@ -69629,7 +70613,7 @@ Your task: Analyze the HTML/JSX markup and identify ALL pieces of content that s
 
 ### When to use each type:
 - Single value \u2192 simple field (text, richText, media, link)
-- Formatted list where structure is static \u2192 richText (opening hours, address)
+- Formatted list where structure is static \u2192 richText (opening hours, address; use hard line breaks / Shift+Enter for line-oriented text)
 - List where items can be added/removed/reordered \u2192 repeater
 - Related fields that belong together \u2192 group
 
@@ -70041,43 +71025,8 @@ Do NOT include [data-block=...] in selectors - we add that automatically.
 var DEFAULT_MANIFEST_MODEL = process.env.RIVERBANK_MANIFEST_MODEL || "gpt-5-mini";
 
 // src/manifest/three-pass-converter.ts
-function parseInlineMarkdown(text2) {
-  const out = [];
-  const pushText = (value, marks) => {
-    if (!value) return;
-    out.push(
-      marks && marks.length > 0 ? { type: "text", text: value, marks } : { type: "text", text: value }
-    );
-  };
-  let rest = text2;
-  while (rest.length > 0) {
-    const start = rest.indexOf("**");
-    if (start === -1) {
-      pushText(rest);
-      break;
-    }
-    const end = rest.indexOf("**", start + 2);
-    if (end === -1) {
-      pushText(rest);
-      break;
-    }
-    pushText(rest.slice(0, start));
-    pushText(rest.slice(start + 2, end), [{ type: "bold" }]);
-    rest = rest.slice(end + 2);
-  }
-  return out;
-}
 function stringToTipTapDoc(text2) {
-  const normalized = text2.replace(/\r\n/g, "\n").trim();
-  if (!normalized) return { type: "doc", content: [] };
-  const paragraphs = normalized.split(/\n{2,}/).map((p) => p.trim()).filter(Boolean);
-  return {
-    type: "doc",
-    content: paragraphs.map((p) => {
-      const inline2 = parseInlineMarkdown(p);
-      return inline2.length > 0 ? { type: "paragraph", content: inline2 } : { type: "paragraph" };
-    })
-  };
+  return createRichTextDocFromMarkdown(text2);
 }
 function coerceRichTextDefaultValue(value) {
   if (value === null || value === void 0) {