@riverbankcms/sdk 0.107.0 → 0.109.0

package/dist/server/date-time.mjs

@@ -0,0 +1,386 @@
+//#region ../core/src/result.ts
+function ok(value) {
+	return {
+		ok: true,
+		value
+	};
+}
+function err(error) {
+	return {
+		ok: false,
+		error
+	};
+}
+//#endregion
+//#region ../core/src/booking-date-time.ts
+const DEFAULT_LOCALE$1 = "en-US";
+const DATE_TIME_FORMATTER_CACHE_LIMIT = 100;
+const dateTimeFormatterCache$1 = /* @__PURE__ */ new Map();
+const timeZoneValidityCache = /* @__PURE__ */ new Map();
+function isValidTimeZone(timeZone) {
+	const cached = timeZoneValidityCache.get(timeZone);
+	if (cached !== void 0) return cached;
+	let isValid;
+	try {
+		new Intl.DateTimeFormat(DEFAULT_LOCALE$1, { timeZone }).format(/* @__PURE__ */ new Date());
+		isValid = true;
+	} catch {
+		isValid = false;
+	}
+	if (timeZoneValidityCache.size >= DATE_TIME_FORMATTER_CACHE_LIMIT) timeZoneValidityCache.clear();
+	timeZoneValidityCache.set(timeZone, isValid);
+	return isValid;
+}
+function parseStrictBookingTimeZone(timeZone) {
+	if (typeof timeZone !== "string") return null;
+	const normalized = timeZone.trim();
+	if (normalized.length === 0 || !isValidTimeZone(normalized)) return null;
+	return normalized;
+}
+function formatToPartsLookup(date, locale, timeZone, format) {
+	return new Map(getCachedDateTimeFormatter(locale, timeZone, format).formatToParts(date).map((part) => [part.type, part.value]));
+}
+function getCachedDateTimeFormatter(locale, timeZone, format) {
+	const key = `${locale}\u0000${timeZone}\u0000${JSON.stringify(Object.entries(format).sort(([left], [right]) => left.localeCompare(right)))}`;
+	const cached = dateTimeFormatterCache$1.get(key);
+	if (cached !== void 0) return cached;
+	const formatter = new Intl.DateTimeFormat(locale, {
+		...format,
+		timeZone
+	});
+	if (dateTimeFormatterCache$1.size >= DATE_TIME_FORMATTER_CACHE_LIMIT) dateTimeFormatterCache$1.clear();
+	dateTimeFormatterCache$1.set(key, formatter);
+	return formatter;
+}
+function parseUtcIsoDateTimeString(value) {
+	const normalized = value.trim();
+	const hasUtcSuffix = normalized.endsWith("Z");
+	const hasExplicitOffset = /[+-]\d{2}:\d{2}$/u.test(normalized);
+	if (!hasUtcSuffix && !hasExplicitOffset) return err("missing-timezone-offset");
+	const date = new Date(normalized);
+	if (Number.isNaN(date.getTime())) return err("invalid-date-time");
+	return ok(date.toISOString());
+}
+function toUtcIsoDateTimeString(value) {
+	const parsed = parseUtcIsoDateTimeString(value);
+	if (!parsed.ok) {
+		const message = parsed.error === "missing-timezone-offset" ? `Expected an offset-aware ISO datetime, received "${value}"` : `Expected a valid ISO datetime, received "${value}"`;
+		throw new Error(message);
+	}
+	return parsed.value;
+}
+function parseScheduledBookingDateTime(input) {
+	let startsAt;
+	try {
+		startsAt = toUtcIsoDateTimeString(input.startsAt);
+	} catch {
+		return {
+			ok: false,
+			field: "startsAt",
+			reason: "invalid_starts_at",
+			value: input.startsAt
+		};
+	}
+	const timeZone = parseStrictBookingTimeZone(input.timeZone);
+	if (timeZone === null) return {
+		ok: false,
+		field: "timeZone",
+		reason: "invalid_time_zone",
+		value: typeof input.timeZone === "string" ? input.timeZone : ""
+	};
+	return {
+		ok: true,
+		value: {
+			startsAt,
+			timeZone,
+			locale: input.locale
+		}
+	};
+}
+function parseScheduledBookingDateRange(input) {
+	const start = parseScheduledBookingDateTime(input);
+	if (!start.ok) return start;
+	if (input.endsAt == null) return {
+		ok: true,
+		value: start.value
+	};
+	try {
+		return {
+			ok: true,
+			value: {
+				...start.value,
+				endsAt: toUtcIsoDateTimeString(input.endsAt)
+			}
+		};
+	} catch {
+		return {
+			ok: false,
+			field: "endsAt",
+			reason: "invalid_ends_at",
+			value: input.endsAt
+		};
+	}
+}
+/**
+* Formats the compact English event-time presentation used by public surfaces.
+*
+* This intentionally owns the lowercase day-period token and zero-minute
+* omission instead of depending on locale-specific spacing or punctuation.
+* Callers must only use it for an English presentation contract.
+*/
+function formatBookingCompactEnglishTime(input) {
+	const date = new Date(input.startsAt);
+	if (Number.isNaN(date.getTime())) return input.startsAt;
+	const parts = formatToPartsLookup(date, input.locale ?? "en-GB", input.timeZone, {
+		hour: "numeric",
+		minute: "2-digit",
+		hour12: true
+	});
+	const hour = parts.get("hour");
+	const minute = parts.get("minute");
+	const dayPeriod = parts.get("dayPeriod");
+	if (hour === void 0 || minute === void 0 || dayPeriod === void 0) return input.startsAt;
+	return `${minute === "00" ? hour : `${hour}:${minute}`}${dayPeriod.toLowerCase()}`;
+}
+//#endregion
+//#region src/date-time/index.ts
+const DEFAULT_LOCALE = "en-GB";
+const COMPACT_ENGLISH_RANGE_SEPARATOR = "–";
+const FORMATTER_CACHE_LIMIT = 100;
+const DEFAULT_DATE_FORMAT = {
+	weekday: "long",
+	year: "numeric",
+	month: "long",
+	day: "numeric"
+};
+const DEFAULT_RANGE_DATE_FORMAT = {
+	weekday: "short",
+	year: "numeric",
+	month: "short",
+	day: "numeric"
+};
+const DEFAULT_STANDARD_TIME_FORMAT = {
+	hour: "numeric",
+	minute: "2-digit"
+};
+const dateTimeFormatterCache = /* @__PURE__ */ new Map();
+const parsedLocaleCache = /* @__PURE__ */ new Map();
+var RiverbankDateTimeFormatError = class extends Error {
+	constructor(details) {
+		super(formatErrorMessage(details));
+		this.name = "RiverbankDateTimeFormatError";
+		this.code = details.code;
+		this.field = details.field;
+		this.value = details.value;
+	}
+};
+function formatScheduledDate(input, options = {}) {
+	return formatInstant(parseDateTime(input), options.format ?? DEFAULT_DATE_FORMAT);
+}
+function formatScheduledTime(input, options = {}) {
+	return formatTime(parseDateTime(input), options);
+}
+function formatScheduledDateTime(input, options = {}) {
+	return formatDateTime(parseDateTime(input), options, DEFAULT_DATE_FORMAT);
+}
+function formatScheduledDateRange(input, options = {}) {
+	const range = parseDateRange(input);
+	return formatRange(rangeStart(range), rangeEnd(range), options.format ?? DEFAULT_RANGE_DATE_FORMAT);
+}
+function formatScheduledTimeRange(input, options = {}) {
+	const range = parseDateRange(input);
+	const start = rangeStart(range);
+	const end = rangeEnd(range);
+	if (!usesCompactEnglishTime(start, options)) return formatRange(start, end, resolveStandardTimeFormat(options));
+	const startTime = formatTime(start, options);
+	const endTime = formatTime(end, options);
+	return startTime === endTime ? startTime : `${startTime}${COMPACT_ENGLISH_RANGE_SEPARATOR}${endTime}`;
+}
+function formatScheduledDateTimeRange(input, options = {}) {
+	const range = parseDateRange(input);
+	const start = rangeStart(range);
+	const end = rangeEnd(range);
+	if (!usesCompactEnglishTime(start, options.time ?? {})) return formatRange(start, end, resolveCombinedFormat(options, DEFAULT_RANGE_DATE_FORMAT));
+	const startDate = formatInstant(start, options.dateFormat ?? DEFAULT_RANGE_DATE_FORMAT);
+	const startTime = formatTime(start, options.time ?? {});
+	const endTime = formatTime(end, options.time ?? {});
+	const startDateTime = `${startDate}, ${startTime}`;
+	if (sameLocalDate(start, end)) return startTime === endTime ? startDateTime : `${startDate}, ${startTime}${COMPACT_ENGLISH_RANGE_SEPARATOR}${endTime}`;
+	const endDateTime = `${formatInstant(end, options.dateFormat ?? DEFAULT_RANGE_DATE_FORMAT)}, ${endTime}`;
+	return startDateTime === endDateTime ? startDateTime : `${startDateTime}${COMPACT_ENGLISH_RANGE_SEPARATOR}${endDateTime}`;
+}
+function parseDateTime(input) {
+	const locale = parseLocale(input.locale);
+	assertStringTimeZone(input.timeZone);
+	const result = parseScheduledBookingDateTime({
+		...input,
+		locale: locale.locale
+	});
+	if (result.ok) return {
+		...result.value,
+		locale: locale.locale
+	};
+	throw fromCoreParseError(result);
+}
+function parseDateRange(input) {
+	const locale = parseLocale(input.locale);
+	assertStringTimeZone(input.timeZone);
+	if (input.endsAt === null || input.endsAt === void 0) throw new RiverbankDateTimeFormatError({
+		code: "missing_ends_at",
+		field: "endsAt",
+		value: ""
+	});
+	const result = parseScheduledBookingDateRange({
+		...input,
+		locale: locale.locale
+	});
+	if (!result.ok) throw fromCoreParseError(result);
+	if (result.value.endsAt === null || result.value.endsAt === void 0) throw new RiverbankDateTimeFormatError({
+		code: "missing_ends_at",
+		field: "endsAt",
+		value: ""
+	});
+	if (new Date(result.value.endsAt).getTime() < new Date(result.value.startsAt).getTime()) throw new RiverbankDateTimeFormatError({
+		code: "end_before_start",
+		field: "endsAt",
+		value: input.endsAt
+	});
+	return {
+		...result.value,
+		endsAt: result.value.endsAt,
+		locale: locale.locale
+	};
+}
+function parseLocale(value) {
+	const locale = value === void 0 ? DEFAULT_LOCALE : value;
+	if (typeof locale !== "string") throw new RiverbankDateTimeFormatError({
+		code: "invalid_locale",
+		field: "locale",
+		value: ""
+	});
+	const cached = parsedLocaleCache.get(locale);
+	if (cached !== void 0) return cached;
+	try {
+		const parsed = new Intl.Locale(locale);
+		const canonical = parsed.toString();
+		if (Intl.DateTimeFormat.supportedLocalesOf([canonical]).length === 0) throw new RangeError("Unsupported locale");
+		const result = {
+			locale: canonical,
+			language: parsed.language
+		};
+		if (parsedLocaleCache.size >= FORMATTER_CACHE_LIMIT) parsedLocaleCache.clear();
+		parsedLocaleCache.set(locale, result);
+		return result;
+	} catch {
+		throw new RiverbankDateTimeFormatError({
+			code: "invalid_locale",
+			field: "locale",
+			value: typeof value === "string" ? value : ""
+		});
+	}
+}
+function assertStringTimeZone(value) {
+	if (typeof value !== "string") throw new RiverbankDateTimeFormatError({
+		code: "invalid_time_zone",
+		field: "timeZone",
+		value: ""
+	});
+}
+function fromCoreParseError(error) {
+	switch (error.reason) {
+		case "invalid_starts_at": return new RiverbankDateTimeFormatError({
+			code: error.reason,
+			field: error.field,
+			value: typeof error.value === "string" ? error.value : ""
+		});
+		case "invalid_ends_at": return new RiverbankDateTimeFormatError({
+			code: error.reason,
+			field: error.field,
+			value: typeof error.value === "string" ? error.value : ""
+		});
+		case "invalid_time_zone": return new RiverbankDateTimeFormatError({
+			code: error.reason,
+			field: error.field,
+			value: error.value
+		});
+		default: return assertNever(error);
+	}
+}
+function formatErrorMessage(details) {
+	switch (details.code) {
+		case "invalid_starts_at": return `Expected startsAt to be a valid offset-aware ISO datetime, received "${details.value}"`;
+		case "invalid_ends_at": return `Expected endsAt to be a valid offset-aware ISO datetime, received "${details.value}"`;
+		case "missing_ends_at": return "Expected endsAt to be provided for a scheduled range";
+		case "invalid_time_zone": return `Expected timeZone to be a valid IANA timezone, received "${details.value}"`;
+		case "invalid_locale": return `Expected locale to be a supported BCP 47 locale, received "${details.value}"`;
+		case "end_before_start": return `Expected endsAt to be on or after startsAt, received "${details.value}"`;
+		default: return assertNever(details);
+	}
+}
+function formatDateTime(input, options, defaultDateFormat) {
+	if (!usesCompactEnglishTime(input, options.time ?? {})) return formatInstant(input, resolveCombinedFormat(options, defaultDateFormat));
+	return `${formatInstant(input, options.dateFormat ?? defaultDateFormat)}, ${formatTime(input, options.time ?? {})}`;
+}
+function formatTime(input, options) {
+	if (usesCompactEnglishTime(input, options)) return formatBookingCompactEnglishTime(input);
+	return formatInstant(input, resolveStandardTimeFormat(options));
+}
+function usesCompactEnglishTime(input, options) {
+	return options.timePresentation !== "standard" && parseLocale(input.locale).language === "en";
+}
+function resolveStandardTimeFormat(options) {
+	return options.timePresentation === "standard" ? options.format ?? DEFAULT_STANDARD_TIME_FORMAT : DEFAULT_STANDARD_TIME_FORMAT;
+}
+function resolveCombinedFormat(options, defaultDateFormat) {
+	return {
+		...options.dateFormat ?? defaultDateFormat,
+		...resolveStandardTimeFormat(options.time ?? {})
+	};
+}
+function formatInstant(input, format) {
+	return getFormatter(input, format).format(new Date(input.startsAt));
+}
+function formatRange(start, end, format) {
+	const formatter = getFormatter(start, format);
+	const nativeFormatRange = Reflect.get(formatter, "formatRange");
+	if (typeof nativeFormatRange !== "function") throw new Error("Intl.DateTimeFormat.formatRange is required");
+	const output = Reflect.apply(nativeFormatRange, formatter, [new Date(start.startsAt), new Date(end.startsAt)]);
+	if (typeof output !== "string") throw new Error("Intl.DateTimeFormat.formatRange returned a non-string value");
+	return output;
+}
+function getFormatter(input, format) {
+	const formatKey = JSON.stringify(Object.entries(format).sort(([left], [right]) => left.localeCompare(right)));
+	const key = `${input.locale}\u0000${input.timeZone}\u0000${formatKey}`;
+	const cached = dateTimeFormatterCache.get(key);
+	if (cached !== void 0) return cached;
+	const formatter = new Intl.DateTimeFormat(input.locale, {
+		...format,
+		timeZone: input.timeZone
+	});
+	if (dateTimeFormatterCache.size >= FORMATTER_CACHE_LIMIT) dateTimeFormatterCache.clear();
+	dateTimeFormatterCache.set(key, formatter);
+	return formatter;
+}
+function rangeStart(range) {
+	return range;
+}
+function rangeEnd(range) {
+	return {
+		startsAt: range.endsAt,
+		timeZone: range.timeZone,
+		locale: range.locale
+	};
+}
+function sameLocalDate(start, end) {
+	const format = {
+		year: "numeric",
+		month: "2-digit",
+		day: "2-digit"
+	};
+	return formatInstant(start, format) === formatInstant(end, format);
+}
+function assertNever(value) {
+	throw new Error(`Unhandled date-time variant: ${String(value)}`);
+}
+//#endregion
+export { RiverbankDateTimeFormatError, formatScheduledDate, formatScheduledDateRange, formatScheduledDateTime, formatScheduledDateTimeRange, formatScheduledTime, formatScheduledTimeRange };

package/dist/server/index.mjs

@@ -19,6 +19,12 @@ function encodePublicProductCategorySelector(selector) {
 }
 //#endregion
 //#region ../api/src/apiEndpointTypes.ts
+function allowedDemoMutationPolicy() {
+	return {
+		classification: "allowed",
+		publicMessage: ""
+	};
+}
 function blockedDemoMutationPolicy(classification, publicMessage) {
 	if (publicMessage.trim() === "") throw new Error(`Demo mutation policy ${classification} requires publicMessage.`);
 	return {
@@ -46,6 +52,7 @@ const TAG_TEMPLATES = {
 	siteRouteOutcomes: "riverbank:site:{siteId}:route-outcomes",
 	routeById: "riverbank:route:{routeId}",
 	pageById: "riverbank:page:{pageId}",
+	pageSurfaceById: "riverbank:page-surface:{pageSurfaceId}",
 	workflowRunById: "riverbank:workflow-run:{runId}",
 	siteForms: "riverbank:site:{siteId}:forms",
 	formById: "riverbank:form:{formId}",
@@ -71,6 +78,7 @@ const TAG_TEMPLATES = {
 const DEMO_MUTATION_BLOCKED_HIDDEN = blockedDemoMutationPolicy("blocked-hidden", "This action is not available in demo sites.");
 const DEMO_MUTATION_BLOCKED_DISABLED = blockedDemoMutationPolicy("blocked-disabled", "This setting is disabled in demo sites.");
 const DEMO_MUTATION_INTERNAL_ONLY = blockedDemoMutationPolicy("internal-only", "This internal operation is not available in demo sites.");
+const DEMO_MUTATION_ALLOWED = allowedDemoMutationPolicy();
 const API_ENDPOINTS$1 = {
 	aiContentUpdateChat: {
 		path: "/ai/content-update-chat",
@@ -2209,6 +2217,49 @@ const API_ENDPOINTS$1 = {
 		auth: "user",
 		responseKind: "json"
 	},
+	updatePageSurfaceDraftContent: {
+		path: "/sites/{siteId}/page-surfaces/{pageSurfaceId}/content",
+		method: "PUT",
+		errors: [
+			"validation:invalid_input",
+			"resource:not_found",
+			"resource:conflict",
+			"server:internal_error"
+		],
+		tags: [TAG_TEMPLATES.siteCollection, TAG_TEMPLATES.pageSurfaceById],
+		auth: "user",
+		responseKind: "json"
+	},
+	discardPageSurfaceDraftContent: {
+		path: "/sites/{siteId}/page-surfaces/{pageSurfaceId}/content/draft",
+		method: "DELETE",
+		errors: [
+			"validation:invalid_input",
+			"resource:not_found",
+			"resource:conflict",
+			"server:internal_error"
+		],
+		tags: [TAG_TEMPLATES.siteCollection, TAG_TEMPLATES.pageSurfaceById],
+		auth: "user",
+		responseKind: "json"
+	},
+	updatePageSurfaceRouteMetadata: {
+		path: "/sites/{siteId}/page-surfaces/{pageSurfaceId}/metadata",
+		method: "PATCH",
+		errors: [
+			"validation:invalid_input",
+			"resource:not_found",
+			"resource:conflict",
+			"server:internal_error"
+		],
+		tags: [
+			TAG_TEMPLATES.siteCollection,
+			TAG_TEMPLATES.siteRoutableContent,
+			TAG_TEMPLATES.pageSurfaceById
+		],
+		auth: "user",
+		responseKind: "json"
+	},
 	runSdkWorkflow: {
 		path: "/sites/{siteId}/content/{type}/{entryId}/workflows/{workflowId}/run",
 		method: "POST",
@@ -2589,6 +2640,50 @@ const API_ENDPOINTS$1 = {
 		errors: [],
 		responseKind: "json"
 	},
+	getFooterComposition: {
+		path: "/sites/{siteId}/settings/footer-composition",
+		method: "GET",
+		revalidate: 120,
+		tags: [TAG_TEMPLATES.site, TAG_TEMPLATES.siteSettings],
+		auth: "user",
+		errors: ["resource:not_found", "server:internal_error"],
+		responseKind: "json"
+	},
+	updateFooterComposition: {
+		path: "/sites/{siteId}/settings/footer-composition",
+		method: "POST",
+		tags: [TAG_TEMPLATES.site, TAG_TEMPLATES.siteSettings],
+		auth: "user",
+		demoMutation: DEMO_MUTATION_ALLOWED,
+		errors: [
+			"validation:invalid_input",
+			"resource:not_found",
+			"server:internal_error"
+		],
+		responseKind: "json"
+	},
+	getPublicProfile: {
+		path: "/sites/{siteId}/settings/public-profile",
+		method: "GET",
+		revalidate: 120,
+		tags: [TAG_TEMPLATES.site, TAG_TEMPLATES.siteSettings],
+		auth: "user",
+		errors: ["resource:not_found", "server:internal_error"],
+		responseKind: "json"
+	},
+	updatePublicProfile: {
+		path: "/sites/{siteId}/settings/public-profile",
+		method: "POST",
+		tags: [TAG_TEMPLATES.site, TAG_TEMPLATES.siteSettings],
+		auth: "user",
+		demoMutation: DEMO_MUTATION_ALLOWED,
+		errors: [
+			"validation:invalid_input",
+			"resource:not_found",
+			"server:internal_error"
+		],
+		responseKind: "json"
+	},
 	updateSiteLayoutSettings: {
 		path: "/sites/{siteId}/settings/layout",
 		method: "POST",
@@ -3661,6 +3756,76 @@ const API_ENDPOINTS$1 = {
 		responseKind: "json",
 		errors: ["resource:not_found"]
 	},
+	listPageSurfaceContentSlots: {
+		path: "/sites/{siteId}/page-surfaces/{pageSurfaceId}/slots",
+		method: "GET",
+		tags: [
+			TAG_TEMPLATES.siteCollection,
+			TAG_TEMPLATES.pageSurfaceById,
+			"surface-slots",
+			"blocks"
+		],
+		auth: "user",
+		responseKind: "json",
+		errors: [
+			"resource:not_found",
+			"resource:conflict",
+			"server:internal_error"
+		]
+	},
+	createPageSurfaceSlotBlock: {
+		path: "/sites/{siteId}/page-surfaces/{pageSurfaceId}/slots/{slotKey}/blocks",
+		method: "POST",
+		tags: [
+			TAG_TEMPLATES.siteCollection,
+			TAG_TEMPLATES.pageSurfaceById,
+			"surface-slot-{slotKey}",
+			"blocks"
+		],
+		auth: "user",
+		responseKind: "json",
+		errors: [
+			"validation:invalid_input",
+			"resource:not_found",
+			"resource:conflict",
+			"server:internal_error"
+		]
+	},
+	reorderPageSurfaceSlotBlocks: {
+		path: "/sites/{siteId}/page-surfaces/{pageSurfaceId}/slots/{slotKey}/blocks/reorder",
+		method: "POST",
+		tags: [
+			TAG_TEMPLATES.siteCollection,
+			TAG_TEMPLATES.pageSurfaceById,
+			"surface-slot-{slotKey}",
+			"blocks"
+		],
+		auth: "user",
+		responseKind: "json",
+		errors: [
+			"validation:invalid_input",
+			"resource:not_found",
+			"resource:conflict",
+			"server:internal_error"
+		]
+	},
+	deletePageSurfaceSlotBlock: {
+		path: "/sites/{siteId}/page-surfaces/{pageSurfaceId}/slots/{slotKey}/blocks/{blockId}",
+		method: "DELETE",
+		tags: [
+			TAG_TEMPLATES.siteCollection,
+			TAG_TEMPLATES.pageSurfaceById,
+			"surface-slot-{slotKey}",
+			"blocks"
+		],
+		auth: "user",
+		responseKind: "json",
+		errors: [
+			"resource:not_found",
+			"resource:conflict",
+			"server:internal_error"
+		]
+	},
 	createBlock: {
 		path: "/sites/{siteId}/pages/{pageId}/blocks",
 		method: "POST",
@@ -6144,6 +6309,41 @@ const API_ENDPOINTS$1 = {
 		auth: "service",
 		responseKind: "json"
 	},
+	sdkCatalogTheme: {
+		path: "/sdk/{siteId}/catalog/theme",
+		method: "GET",
+		errors: ["server:internal_error"],
+		auth: "service",
+		responseKind: "json"
+	},
+	sdkCatalogBlocks: {
+		path: "/sdk/{siteId}/catalog/blocks",
+		method: "GET",
+		errors: ["server:internal_error"],
+		auth: "service",
+		responseKind: "json"
+	},
+	sdkCatalogContentTypes: {
+		path: "/sdk/{siteId}/catalog/content-types",
+		method: "GET",
+		errors: ["server:internal_error"],
+		auth: "service",
+		responseKind: "json"
+	},
+	sdkCapabilities: {
+		path: "/sdk/{siteId}/capabilities",
+		method: "GET",
+		errors: ["server:internal_error"],
+		auth: "service",
+		responseKind: "json"
+	},
+	sdkListDemoContent: {
+		path: "/sdk/{siteId}/demo-content",
+		method: "GET",
+		errors: ["server:internal_error"],
+		auth: "service",
+		responseKind: "json"
+	},
 	sdkPullPages: {
 		path: "/sdk/{siteId}/pull/pages",
 		method: "GET",
@@ -6273,6 +6473,19 @@ const API_ENDPOINTS$1 = {
 		auth: "service",
 		responseKind: "json"
 	},
+	sdkPatchPageBlock: {
+		path: "/sdk/{siteId}/pages/{identifier}/blocks/{blockIdentifier}",
+		method: "PATCH",
+		errors: [
+			"validation:invalid_input",
+			"resource:not_found",
+			"resource:conflict",
+			"billing:plan_limit_exceeded",
+			"server:internal_error"
+		],
+		auth: "service",
+		responseKind: "json"
+	},
 	sdkReorderPageBlocks: {
 		path: "/sdk/{siteId}/pages/{identifier}/blocks/reorder",
 		method: "POST",
@@ -7548,7 +7761,7 @@ var SimpleCache = class {
 * 1. This constant
 * 2. The "version" field in package.json
 */
-const SDK_VERSION = "0.107.0";
+const SDK_VERSION = "0.109.0";
 //#endregion
 //#region src/client/error.ts
 let _Symbol$for;

package/dist/server/navigation.mjs

@@ -111,8 +111,11 @@ function getPrimaryNavigation(navigation) {
 * ```
 */
 function getFooterNavigation(navigation) {
+	return getFooterNavigationByRole(navigation, "main");
+}
+function getFooterNavigationByRole(navigation, role) {
 	if (!navigation || navigation.length === 0) return null;
-	const footerMenus = navigation.filter((menu) => menu.isFooter);
+	const footerMenus = navigation.filter((menu) => menu.footerRole === role || role === "main" && menu.footerRole == null && menu.isFooter);
 	if (footerMenus.length > 1) console.warn(`[riverbank/sdk] Multiple footer navigation menus detected (${footerMenus.length}); using first flagged menu by input order.`);
 	return footerMenus[0] ?? null;
 }
@@ -552,7 +555,10 @@ function buildMenu(navigation, routes, options) {
 * ```
 */
 function buildFooterMenu(navigation, routes, options) {
-	const menu = getFooterNavigation(navigation);
+	return buildFooterMenuForRole(navigation, routes, "main", options);
+}
+function buildFooterMenuForRole(navigation, routes, role, options) {
+	const menu = getFooterNavigationByRole(navigation, role);
 	if (!menu) return {
 		items: [],
 		ctaItem: null,
@@ -656,4 +662,4 @@ function buildLogo(logo, fallbackAlt) {
 	return result;
 }
 //#endregion
-export { buildFooterMenu, buildLogo, buildLogoViewModel, buildMenu, buildMenuViewModel, getFooterNavigation, getNavItemsBySlug, getNavigationBySlug, getPrimaryNavItems, getPrimaryNavigation, isNavDropdown, isNavLink, resolveNavigationLinkHref, transformToNavItems };
+export { buildFooterMenu, buildFooterMenuForRole, buildLogo, buildLogoViewModel, buildMenu, buildMenuViewModel, getFooterNavigation, getFooterNavigationByRole, getNavItemsBySlug, getNavigationBySlug, getPrimaryNavItems, getPrimaryNavigation, isNavDropdown, isNavLink, resolveNavigationLinkHref, transformToNavItems };