riverbankcms 0.18.0 → 0.20.0

package/dist/local-sync-B3naCvSc.mjs

@@ -1,4634 +0,0 @@
-#!/usr/bin/env node
-import { Hr as asPageFlowPresetId, Jn as getDirectImageUrlForSiteScopedPath, T as eventBookingOfferIntentSchema, Ur as asSiteStyleId, _r as normalizeAmbiguousStoragePathForSite, bn as pageDesignBoundaryTreatmentSchema, br as MAX_MANAGEMENT_MEDIA_UPLOAD_BYTES, d as stableStringify, dr as slugifyMediaIdentifier, ft as themeSchema, hn as buttonStyleSelectionSchema, hr as getMimeType, mr as getExtensionForMimeType, n as sdkCourseBookingSettingsSchema, r as sdkEventOccurrenceInputSchema, s as eventVisibilitySchema, sr as buildMediaIdentifierFromFilename, ur as resolveMediaIdentifier, xn as pageDesignIntentSchemaVersion, yr as FILE_SIZE_LIMITS, zr as asAppearancePresetId } from "./sdk-event-upsert-BamyD2d6.mjs";
-import { En as ok, Lt as assertNever, Tn as err, a as canonicalizeConfiguredBookingVerticalConfig, an as unsafeAsEventOfferingId, c as resolveSiteVerticalBookingConfig, j as parseFooterCompositionV1, l as DEFAULT_EVENT_TYPE_PRESETS, ln as unsafeAsOccurrenceId, o as parseVerticalId, on as unsafeAsEventSeriesId, s as parseVerticalPresetId, t as resolveEventCatalogue, u as EVENT_PRESET_VALUES, y as exposeSecret } from "./src-BhrSG8A4.mjs";
-import * as fs$1 from "fs/promises";
-import * as path$1 from "path";
-import { z } from "zod";
-import { constants } from "node:fs";
-import { basename, dirname as dirname$1, join } from "node:path";
-import { createHash, randomUUID } from "node:crypto";
-import { access, chmod, link, lstat, mkdir, open, rename, unlink as unlink$1 } from "node:fs/promises";
-
-//#region ../api/src/bookingVerticals.ts
-/**
-* Transport adapters for the booking-vertical domain.
-*
-* The domain catalog and all pure resolution/selection rules live in core;
-* this module owns only the Zod boundary used by API payloads.
-*/
-function formatRawDiagnosticValue(value) {
-	const serialized = JSON.stringify(value);
-	return serialized === undefined ? String(value) : serialized;
-}
-function describeSiteVerticalConfigIssue(issue) {
-	switch (issue.code) {
-		case "unknown_vertical": return `${issue.code}: ${formatRawDiagnosticValue(issue.rawValue)}`;
-		case "unknown_preset": return `${issue.code}: ${formatRawDiagnosticValue(issue.rawValue)}`;
-		case "missing_vertical":
-		case "empty_selected_presets":
-		case "preset_vertical_mismatch":
-		case "duplicate_preset_id":
-		case "duplicate_canonical_behaviour":
-		case "future_preset_selected": return issue.code;
-		default: return assertNever(issue);
-	}
-}
-const VerticalIdSchema = z.string().trim().transform((value, ctx) => {
-	const parsed = parseVerticalId(value);
-	if (!parsed) {
-		ctx.addIssue({
-			code: z.ZodIssueCode.custom,
-			message: "Unknown booking vertical"
-		});
-		return z.NEVER;
-	}
-	return parsed;
-});
-const VerticalPresetIdSchema = z.string().trim().transform((value, ctx) => {
-	const parsed = parseVerticalPresetId(value);
-	if (!parsed) {
-		ctx.addIssue({
-			code: z.ZodIssueCode.custom,
-			message: "Unknown booking preset"
-		});
-		return z.NEVER;
-	}
-	return parsed;
-});
-const BookingVerticalConfigSchema = z.object({
-	verticalId: VerticalIdSchema.nullable(),
-	selectedPresetIds: z.array(VerticalPresetIdSchema).max(20)
-}).transform((value, ctx) => {
-	const resolved = resolveSiteVerticalBookingConfig(value);
-	if (resolved.kind === "invalid") {
-		ctx.addIssue({
-			code: z.ZodIssueCode.custom,
-			message: `Invalid booking vertical config: ${resolved.issues.map(describeSiteVerticalConfigIssue).join(", ")}`
-		});
-		return z.NEVER;
-	}
-	return resolved.config;
-});
-
-//#endregion
-//#region ../api/src/sdkBookingVerticalSchemas.ts
-const sdkConfiguredBookingVerticalConfigSchema = z.object({
-	verticalId: VerticalIdSchema,
-	selectedPresetIds: z.tuple([VerticalPresetIdSchema]).rest(VerticalPresetIdSchema)
-}).transform((config, context) => {
-	const canonical = canonicalizeConfiguredBookingVerticalConfig(config);
-	if (canonical.ok) return canonical.config;
-	for (const issue of canonical.issues) {
-		context.addIssue({
-			code: z.ZodIssueCode.custom,
-			path: ["selectedPresetIds"],
-			message: issue.code
-		});
-	}
-	return z.NEVER;
-});
-const sdkConfigureBookingVerticalRequestSchema = z.discriminatedUnion("mode", [z.object({
-	mode: z.literal("preview"),
-	verticalConfig: sdkConfiguredBookingVerticalConfigSchema,
-	expectedRevision: z.string().min(1).nullable().optional()
-}).strict(), z.object({
-	mode: z.literal("apply"),
-	verticalConfig: sdkConfiguredBookingVerticalConfigSchema,
-	expectedRevision: z.string().min(1).nullable()
-}).strict()]);
-const sdkVerticalConfigIssueSchema = z.discriminatedUnion("code", [
-	z.object({
-		code: z.literal("unknown_vertical"),
-		rawValue: z.unknown()
-	}),
-	z.object({
-		code: z.literal("unknown_preset"),
-		rawValue: z.unknown()
-	}),
-	z.object({ code: z.literal("missing_vertical") }),
-	z.object({ code: z.literal("empty_selected_presets") }),
-	z.object({ code: z.literal("preset_vertical_mismatch") }),
-	z.object({ code: z.literal("duplicate_preset_id") }),
-	z.object({ code: z.literal("duplicate_canonical_behaviour") }),
-	z.object({ code: z.literal("future_preset_selected") })
-]);
-const sdkBookingSettingsWarningSchema = z.discriminatedUnion("code", [z.object({
-	code: z.literal("booking_module_disabled"),
-	module: z.enum(["appointments", "events"])
-}), z.object({
-	code: z.literal("replaced_invalid_current_config"),
-	issues: z.array(sdkVerticalConfigIssueSchema)
-})]);
-const sdkPullSettingsWarningSchema = z.object({
-	code: z.literal("invalid_booking_vertical_config"),
-	issues: z.array(sdkVerticalConfigIssueSchema)
-});
-
-//#endregion
-//#region ../api/src/sdkCommandResponseSchemas.ts
-const sdkCommandEffectSchema = z.discriminatedUnion("kind", [
-	z.object({ kind: z.literal("created") }),
-	z.object({ kind: z.literal("updated") }),
-	z.object({ kind: z.literal("unchanged") }),
-	z.object({ kind: z.literal("deleted") }),
-	z.object({
-		kind: z.literal("transitioned"),
-		transition: z.enum(["published", "unpublished"])
-	})
-]);
-function sdkCommandApplicationResultSchema(value) {
-	return z.object({
-		value,
-		effect: sdkCommandEffectSchema
-	}).passthrough();
-}
-
-//#endregion
-//#region ../api/src/sdkBlockUpsertContracts.ts
-const sdkBlockAppearanceChoiceSchema = z.discriminatedUnion("kind", [z.object({
-	kind: z.literal("pinned"),
-	appearancePresetId: z.string().min(1).transform(asAppearancePresetId)
-}), z.object({ kind: z.literal("automatic") })]);
-const sdkBlockAppearanceOutcomeSchema = z.discriminatedUnion("kind", [z.object({
-	kind: z.literal("applied"),
-	choice: sdkBlockAppearanceChoiceSchema,
-	effect: z.enum(["updated", "unchanged"])
-}), z.object({
-	kind: z.literal("not-applied"),
-	code: z.enum(["STALE_PAGE_DESIGN_STATE", "SAVE_PAGE_DESIGN_STATE_FAILED"]),
-	message: z.string(),
-	retryable: z.literal(true)
-})]);
-const pageBlockDesignSyncWarningSchema = z.object({
-	kind: z.enum([
-		"blocked",
-		"failed",
-		"skipped-invalid"
-	]),
-	operation: z.enum([
-		"create",
-		"update",
-		"delete",
-		"reorder"
-	]),
-	message: z.string(),
-	blocker: z.string().optional(),
-	source: z.enum(["draft", "published-fallback"]).optional(),
-	reason: z.string().optional()
-});
-
-//#endregion
-//#region ../api/src/sdkOccurrenceResponseSchemas.ts
-const identifierSchema$1 = z.string().min(1);
-const timestampSchema = z.string().min(1);
-const sdkManagementEventOccurrenceSchema = z.object({
-	id: identifierSchema$1.transform(unsafeAsOccurrenceId),
-	seriesId: identifierSchema$1.transform(unsafeAsEventSeriesId),
-	startsAt: timestampSchema,
-	endsAt: timestampSchema,
-	timeZone: z.string().min(1),
-	status: z.enum([
-		"scheduled",
-		"cancelled",
-		"completed"
-	]),
-	provenance: z.enum([
-		"manual",
-		"recurrence_generated",
-		"recurrence_exception"
-	]),
-	capacityOverride: z.number().int().nonnegative().nullable(),
-	capacity: z.number().int().nonnegative().nullable(),
-	confirmedPlaces: z.number().int().nonnegative().optional(),
-	registrations: z.number().int().nonnegative(),
-	deletionEligibility: z.discriminatedUnion("kind", [
-		z.object({ kind: z.literal("allowed") }),
-		z.object({
-			kind: z.literal("blocked_by_registrations"),
-			registrations: z.number().int().positive()
-		}),
-		z.object({ kind: z.literal("blocked_generated_occurrence") }),
-		z.object({ kind: z.literal("blocked_completed_occurrence") })
-	])
-});
-const sdkListEventOccurrencesResponseSchema = z.object({
-	occurrences: z.array(sdkManagementEventOccurrenceSchema),
-	nextCursor: z.string().nullable()
-});
-const businessCancellationResultSchema = z.object({
-	kind: z.enum([
-		"finished",
-		"unfinished",
-		"partial_application"
-	]),
-	paymentTerms: z.enum([
-		"complete",
-		"unfinished",
-		"unavailable"
-	]),
-	refunds: z.enum([
-		"complete",
-		"processing",
-		"needs_attention",
-		"unavailable"
-	]),
-	emails: z.enum([
-		"complete",
-		"queued",
-		"needs_attention",
-		"unavailable"
-	]),
-	operationId: identifierSchema$1,
-	directContactAttendeeIds: z.array(identifierSchema$1),
-	cancelledBookings: z.number().int().nonnegative(),
-	refundedBookings: z.number().int().nonnegative(),
-	restoredPassCredits: z.number().int().nonnegative(),
-	pending: z.object({
-		refundAttendeeIds: z.array(identifierSchema$1),
-		creditAttendeeIds: z.array(identifierSchema$1),
-		emailAttendeeIds: z.array(identifierSchema$1)
-	}),
-	structural: z.object({
-		created: z.number().int().nonnegative(),
-		deleted: z.number().int().nonnegative(),
-		cancelled: z.number().int().nonnegative(),
-		unfinishedOccurrenceIds: z.array(identifierSchema$1),
-		unfinishedCreateCount: z.number().int().nonnegative().optional(),
-		reason: z.enum([
-			"superseded",
-			"not_found",
-			"restore_blocked",
-			"failed",
-			"result_unavailable"
-		]).optional()
-	})
-});
-const sdkEventOccurrenceResponseSchema = z.object({
-	occurrence: sdkManagementEventOccurrenceSchema,
-	cancellationResult: businessCancellationResultSchema.optional(),
-	cancellationResults: z.array(businessCancellationResultSchema).optional()
-});
-const sdkDeleteEventOccurrenceResponseSchema = z.object({ deleted: z.literal(true) });
-const sdkReorderResponseSchema = z.object({
-	reordered: z.literal(true),
-	effect: sdkCommandEffectSchema,
-	designSyncWarning: pageBlockDesignSyncWarningSchema.optional()
-});
-
-//#endregion
-//#region ../api/src/sdkPageDesign.ts
-/**
-* The portable page design document (issue 1497).
-*
-* A stored `PageDesignIntent` names blocks by their database ids, so it only
-* makes sense on the page it came from. The portable document is the same
-* intent with every block reference expressed as the block's management
-* identifier (`hero-0`, `body-text-1`), which is what lets a design travel from
-* one page to another page built from the same blocks.
-*
-* A boundary is carried as its identifier pair only. Its stored `boundaryId`
-* is derived from the pair after mapping, so the two can never disagree.
-*
-* The document is parsed once, here, at the JSON boundary. Whether it fits a
-* particular destination page is a separate, semantic decision made by the
-* dashboard against that page's blocks and site style.
-*/
-const unsafeAsBlockIdentifier = (value) => value;
-const blockIdentifierSchema = z.string().min(1).transform(unsafeAsBlockIdentifier);
-const portableBlockLookPinSchema = z.object({
-	blockIdentifier: blockIdentifierSchema,
-	blockKind: z.string().min(1),
-	choice: z.object({
-		kind: z.literal("user-pinned"),
-		value: z.string().min(1).transform(asAppearancePresetId)
-	}).strict()
-}).strict();
-const portableBoundaryPinSchema = z.object({
-	previousBlockIdentifier: blockIdentifierSchema,
-	nextBlockIdentifier: blockIdentifierSchema,
-	choice: z.object({
-		kind: z.literal("user-pinned"),
-		value: pageDesignBoundaryTreatmentSchema
-	}).strict()
-}).strict();
-function isRepeated(items, same) {
-	return (item, index) => items.findIndex((other) => same(item, other)) !== index;
-}
-function refineUniquePins(design, ctx) {
-	design.blockLookPins.filter(isRepeated(design.blockLookPins, (a, b) => a.blockIdentifier === b.blockIdentifier)).forEach((pin) => ctx.addIssue({
-		code: "custom",
-		path: ["blockLookPins"],
-		message: `The design pins block "${pin.blockIdentifier}" more than once.`
-	}));
-	design.boundaryPins.filter(isRepeated(design.boundaryPins, (a, b) => a.previousBlockIdentifier === b.previousBlockIdentifier && a.nextBlockIdentifier === b.nextBlockIdentifier)).forEach((pin) => ctx.addIssue({
-		code: "custom",
-		path: ["boundaryPins"],
-		message: `The design pins the break between "${pin.previousBlockIdentifier}" and "${pin.nextBlockIdentifier}" more than once.`
-	}));
-}
-const portablePageDesignSchema = z.object({
-	schemaVersion: z.literal(pageDesignIntentSchemaVersion),
-	siteStyleId: z.string().min(1).transform(asSiteStyleId),
-	pageFlowPresetId: z.string().min(1).transform(asPageFlowPresetId),
-	blockLookPins: z.array(portableBlockLookPinSchema),
-	boundaryPins: z.array(portableBoundaryPinSchema)
-}).strict().superRefine(refineUniquePins);
-const pageDesignRevisionTokenSchema = z.discriminatedUnion("kind", [
-	z.object({ kind: z.literal("absent") }).strict(),
-	z.object({
-		kind: z.literal("draft"),
-		contentVersionId: z.string().min(1),
-		updatedAt: z.string().min(1)
-	}).strict(),
-	z.object({
-		kind: z.literal("published"),
-		contentVersionId: z.string().min(1),
-		updatedAt: z.string().min(1)
-	}).strict()
-]);
-const sdkSavePageDesignBodySchema = z.object({
-	design: portablePageDesignSchema,
-	expectedRevision: pageDesignRevisionTokenSchema
-}).strict();
-const omittedPagePinSchema = z.discriminatedUnion("kind", [z.object({
-	kind: z.literal("look-on-missing-block"),
-	blockId: z.string().min(1)
-}), z.object({
-	kind: z.literal("boundary-on-missing-block"),
-	previousBlockId: z.string().min(1),
-	nextBlockId: z.string().min(1)
-})]);
-const sdkGetPageDesignResponseSchema = z.discriminatedUnion("kind", [z.object({ kind: z.literal("absent") }), z.object({
-	kind: z.literal("stored"),
-	source: z.enum(["draft", "published"]),
-	design: portablePageDesignSchema,
-	revision: pageDesignRevisionTokenSchema,
-	omitted: z.array(omittedPagePinSchema)
-})]);
-const sdkSavePageDesignResponseSchema = z.object({
-	outcome: z.enum(["created", "updated"]),
-	revision: pageDesignRevisionTokenSchema
-});
-
-//#endregion
-//#region ../api/src/sdkMediaResponseSchemas.ts
-const identifierSchema = z.string().min(1);
-const nullablePathSchema = z.string().nullable();
-const managementMediaAssetSchema = z.object({
-	id: identifierSchema,
-	siteId: identifierSchema,
-	identifier: identifierSchema,
-	storageBucket: identifierSchema,
-	storagePath: identifierSchema,
-	filename: identifierSchema,
-	mimeType: identifierSchema,
-	width: z.number().int().nonnegative().nullable(),
-	height: z.number().int().nonnegative().nullable(),
-	bytes: z.number().int().nonnegative().nullable(),
-	checksumSha256: z.string().nullable(),
-	createdAt: identifierSchema,
-	updatedAt: identifierSchema
-});
-const blockLocationFields = {
-	siteId: identifierSchema,
-	blockId: identifierSchema,
-	blockKind: identifierSchema,
-	blockIdentifier: z.string().nullable(),
-	stage: z.enum(["draft", "published"])
-};
-const newsletterUsageLocationSchemas = [z.object({
-	kind: z.literal("newsletterTemplate"),
-	siteId: identifierSchema,
-	templateId: identifierSchema,
-	templateName: z.string()
-}), z.object({
-	kind: z.literal("newsletterCampaign"),
-	siteId: identifierSchema,
-	campaignId: identifierSchema,
-	campaignName: z.string()
-})];
-const mediaUsageLocationSchema = z.discriminatedUnion("kind", [
-	...newsletterUsageLocationSchemas,
-	z.object({
-		kind: z.literal("pageBlock"),
-		...blockLocationFields,
-		pageId: identifierSchema,
-		pageTitle: z.string().nullable(),
-		pageDraftPath: nullablePathSchema,
-		pagePublishedPath: nullablePathSchema
-	}),
-	z.object({
-		kind: z.literal("entrySlotBlock"),
-		...blockLocationFields,
-		entryId: identifierSchema,
-		entryTitle: z.string(),
-		typeKey: identifierSchema,
-		routeDraftPath: nullablePathSchema,
-		routePublishedPath: nullablePathSchema,
-		slotKey: identifierSchema
-	}),
-	z.object({
-		kind: z.literal("surfaceSlotBlock"),
-		...blockLocationFields,
-		pageSurfaceId: identifierSchema,
-		surfaceSlotId: identifierSchema,
-		slotKey: identifierSchema
-	}),
-	z.object({
-		kind: z.literal("contentEntry"),
-		siteId: identifierSchema,
-		entryId: identifierSchema,
-		entryTitle: z.string(),
-		typeKey: identifierSchema,
-		routeDraftPath: nullablePathSchema,
-		routePublishedPath: nullablePathSchema,
-		stage: z.enum(["draft", "published"])
-	}),
-	z.object({
-		kind: z.literal("productFileDownload"),
-		siteId: identifierSchema,
-		productId: identifierSchema,
-		productTitle: z.string()
-	})
-]);
-const mediaUsageItemSchema = z.object({
-	assetId: identifierSchema,
-	filename: z.string().nullable(),
-	usedCount: z.number().int().nonnegative(),
-	locations: z.array(mediaUsageLocationSchema)
-});
-const mediaDeleteWarningSchema = z.discriminatedUnion("kind", [z.object({
-	kind: z.literal("ORPHAN_CLEANUP_FAILED"),
-	message: z.string(),
-	storageBucket: identifierSchema,
-	storagePath: identifierSchema
-}), z.object({
-	kind: z.literal("LABEL_CLEANUP_FAILED"),
-	message: z.string()
-})]);
-const sdkMediaListResponseSchema = z.object({
-	items: z.array(managementMediaAssetSchema),
-	total: z.number().int().nonnegative(),
-	limit: z.number().int().positive(),
-	offset: z.number().int().nonnegative(),
-	nextOffset: z.number().int().nonnegative().optional()
-});
-const sdkMediaDownloadResponseSchema = z.object({
-	transferUrl: z.string().url(),
-	asset: managementMediaAssetSchema
-});
-const sdkMediaDeletePreviewResponseSchema = z.discriminatedUnion("kind", [
-	z.object({ kind: z.literal("missing") }),
-	z.object({
-		kind: z.literal("in_use"),
-		usage: mediaUsageItemSchema
-	}),
-	z.object({
-		kind: z.literal("deletable"),
-		assetId: identifierSchema
-	})
-]);
-const sdkMediaDeleteApplyResponseSchema = z.discriminatedUnion("kind", [
-	z.object({ kind: z.literal("missing") }),
-	z.object({
-		kind: z.literal("in_use"),
-		usage: mediaUsageItemSchema
-	}),
-	z.object({ kind: z.literal("deleted") }),
-	z.object({
-		kind: z.literal("deleted_with_warnings"),
-		warnings: z.tuple([mediaDeleteWarningSchema], mediaDeleteWarningSchema)
-	})
-]);
-
-//#endregion
-//#region ../blocks/src/system/types/link.ts
-const nullableString = z.union([z.string().min(1), z.null()]);
-const RESOLVED_INTERNAL_LINK_ENTITY_TYPES = [
-	"page",
-	"content",
-	"pageSurface"
-];
-function isResolvedInternalLinkEntityType(value) {
-	return typeof value === "string" && RESOLVED_INTERNAL_LINK_ENTITY_TYPES.includes(value);
-}
-const resolvedInternalLinkKeys = [
-	"entityId",
-	"entityType",
-	"href",
-	"title",
-	"typeLabel"
-];
-const internalRouteOnlyLinkSchema = z.object({
-	kind: z.literal("internal"),
-	routeId: z.string().min(1)
-}).passthrough().superRefine((value, ctx) => {
-	const hasResolvedMetadata = resolvedInternalLinkKeys.some((key) => value[key] != null);
-	if (!hasResolvedMetadata) return;
-	ctx.addIssue({
-		code: "custom",
-		message: "Internal links with resolved metadata must include entityId, entityType, href, title, and typeLabel"
-	});
-});
-const internalResolvedLinkSchema = z.object({
-	kind: z.literal("internal"),
-	routeId: z.string().min(1),
-	entityId: z.string().min(1),
-	entityType: z.enum(RESOLVED_INTERNAL_LINK_ENTITY_TYPES),
-	href: z.string().min(1),
-	title: z.string().min(1),
-	typeLabel: z.string().min(1),
-	contentTypeKey: nullableString.optional(),
-	contentTypeName: nullableString.optional(),
-	updatedAt: nullableString.optional()
-}).passthrough();
-const internalLinkSchema = z.union([internalResolvedLinkSchema, internalRouteOnlyLinkSchema]);
-const externalLinkSchema$1 = z.object({
-	kind: z.literal("external"),
-	href: z.string().min(1)
-}).passthrough();
-const customLinkSchema$1 = z.object({
-	kind: z.literal("url"),
-	href: z.string().min(1)
-}).passthrough();
-const pageLinkSchema$1 = z.object({
-	kind: z.literal("page"),
-	identifier: z.string().min(1)
-}).passthrough();
-const entryLinkSchema$1 = z.object({
-	kind: z.literal("entry"),
-	contentType: z.string().min(1),
-	identifier: z.string().min(1)
-}).passthrough();
-const linkSchema = z.union([
-	internalLinkSchema,
-	externalLinkSchema$1,
-	customLinkSchema$1,
-	pageLinkSchema$1,
-	entryLinkSchema$1
-]);
-function visitLinkValueReferences(value, visitor) {
-	const parsed = linkSchema.safeParse(value);
-	if (!parsed.success) {
-		return;
-	}
-	const link$1 = parsed.data;
-	switch (link$1.kind) {
-		case "internal":
-			visitor.routeIds.add(link$1.routeId);
-			return;
-		case "page":
-			visitor.pageIdentifiers.add(link$1.identifier);
-			return;
-		case "entry":
-			visitor.entryIdentifiers.add(link$1.contentType, link$1.identifier);
-			return;
-		case "external":
-		case "url": return;
-	}
-}
-function isInternalResolvedLinkValue(value) {
-	return value?.kind === "internal" && "entityId" in value && "entityType" in value && "href" in value && "title" in value && "typeLabel" in value && typeof value.entityId === "string" && isResolvedInternalLinkEntityType(value.entityType) && typeof value.href === "string" && typeof value.title === "string" && typeof value.typeLabel === "string";
-}
-
-//#endregion
-//#region ../api/src/navigation/contracts.ts
-/**
-* Canonical navigation/link Zod contracts.
-*
-* Goal: a single source-of-truth for link shapes used across dashboard + SDK.
-* - Types live in `packages/api/src/navigation/types.ts`
-* - Schemas live here and are tied to types via `satisfies z.ZodType<...>`
-*/
-const portalLinkPayloadSchema = z.object({
-	kind: z.literal("portal"),
-	path: z.string().trim().startsWith("/").optional(),
-	labels: z.object({
-		loggedOut: z.string().trim().min(1).optional(),
-		loggedIn: z.string().trim().min(1).optional()
-	}).optional()
-});
-const cartLinkLabelConfigSchema = z.discriminatedUnion("kind", [z.object({ kind: z.literal("icon-only") }), z.object({
-	kind: z.literal("icon-with-label"),
-	label: z.string().trim().min(1)
-})]);
-const cartLinkPayloadSchema = z.object({
-	kind: z.literal("cart"),
-	badge: z.enum(["show-count", "hidden"]),
-	label: cartLinkLabelConfigSchema
-});
-const internalLinkPayloadSchema = z.object({
-	kind: z.literal("internal"),
-	routeId: z.string().uuid(),
-	entityId: z.string().uuid(),
-	entityType: z.enum(RESOLVED_INTERNAL_LINK_ENTITY_TYPES),
-	href: z.string().min(1),
-	title: z.string().min(1),
-	typeLabel: z.string().min(1),
-	contentTypeKey: z.string().nullable().optional(),
-	contentTypeName: z.string().nullable().optional(),
-	updatedAt: z.string().nullable().optional()
-}).passthrough();
-const externalLinkSchema = z.object({
-	kind: z.literal("external"),
-	href: z.string().url()
-});
-const customLinkSchema = z.object({
-	kind: z.literal("url"),
-	href: z.string().min(1)
-});
-const pageLinkSchema = z.object({
-	kind: z.literal("page"),
-	identifier: z.string().min(1)
-});
-const entryLinkSchema = z.object({
-	kind: z.literal("entry"),
-	contentType: z.string().min(1),
-	identifier: z.string().min(1)
-});
-const linkPayloadSchema = z.discriminatedUnion("kind", [
-	internalLinkPayloadSchema,
-	pageLinkSchema,
-	entryLinkSchema,
-	externalLinkSchema,
-	customLinkSchema,
-	portalLinkPayloadSchema,
-	cartLinkPayloadSchema
-]);
-const navigationLinkInputSchemaOptions = [
-	pageLinkSchema,
-	entryLinkSchema,
-	externalLinkSchema,
-	customLinkSchema,
-	portalLinkPayloadSchema,
-	cartLinkPayloadSchema
-];
-const navigationLinkInputSchema = z.discriminatedUnion("kind", navigationLinkInputSchemaOptions);
-const dashboardNavigationLinkSchema = linkPayloadSchema;
-const sdkNavigationLinkInputSchema = navigationLinkInputSchema;
-
-//#endregion
-//#region ../api/src/sdkThemeWire.ts
-/**
-* Validate a wire value without replacing it with the schema's parsed output.
-* The returned type is deliberately the schema input, not its canonical output.
-*/
-function losslessValidatedSchema(schema) {
-	return z.unknown().superRefine((value, ctx) => {
-		const parsed = schema.safeParse(value);
-		if (parsed.success) return;
-		for (const issue of parsed.error.issues) {
-			ctx.addIssue({
-				code: "custom",
-				path: issue.path,
-				message: issue.message,
-				params: { validationCode: issue.code }
-			});
-		}
-	}).transform((value) => value);
-}
-const sdkThemeWireSchema = losslessValidatedSchema(themeSchema);
-/** Explicitly cross from the lossless wire model into Riverbank's canonical theme. */
-function normalizeSdkThemeWire(theme) {
-	return themeSchema.parse(theme);
-}
-
-//#endregion
-//#region ../api/src/sdkPullResponseSchemas.ts
-const sdkIdentifierSchema$1 = z.string().min(1);
-const sdkTimestampSchema$2 = z.string().min(1);
-const sdkJsonObjectSchema$1 = z.record(z.string(), z.unknown());
-const sdkEntrySlotBlocksSchema = z.record(z.string(), z.array(z.object({
-	identifier: z.string().nullable(),
-	kind: sdkIdentifierSchema$1,
-	content: sdkJsonObjectSchema$1
-})));
-const sdkPulledEntrySchema = z.object({
-	identifier: sdkIdentifierSchema$1,
-	title: z.string(),
-	data: sdkJsonObjectSchema$1,
-	status: z.enum(["draft", "published"]),
-	hasUnpublishedChanges: z.boolean(),
-	slug: z.string().optional(),
-	blocks: sdkEntrySlotBlocksSchema.optional()
-});
-const sdkPullMetaSchema = z.object({ pulledAt: sdkTimestampSchema$2 });
-const sdkPullEntryTimestampsSchema = z.object({
-	createdAt: sdkTimestampSchema$2,
-	updatedAt: sdkTimestampSchema$2,
-	publishedAt: sdkTimestampSchema$2.nullable()
-});
-const sdkPullPaginationSchema = z.object({
-	page: z.number().int().nonnegative(),
-	limit: z.number().int().positive(),
-	total: z.number().int().nonnegative(),
-	hasMore: z.boolean()
-});
-const sdkPullTruncationSchema = z.union([
-	z.object({
-		truncated: z.literal(false),
-		returned: z.number().int().nonnegative()
-	}).strict(),
-	z.object({
-		truncated: z.literal(true),
-		returned: z.number().int().nonnegative(),
-		droppedTypes: z.tuple([sdkIdentifierSchema$1], sdkIdentifierSchema$1),
-		capPerType: z.number().int().positive(),
-		capTotal: z.number().int().positive().optional()
-	}),
-	z.object({
-		truncated: z.literal(true),
-		returned: z.number().int().nonnegative(),
-		droppedTypes: z.tuple([sdkIdentifierSchema$1], sdkIdentifierSchema$1),
-		capPerType: z.number().int().positive().optional(),
-		capTotal: z.number().int().positive()
-	})
-]);
-const sdkPullPageSchema = z.object({
-	id: sdkIdentifierSchema$1,
-	identifier: sdkIdentifierSchema$1,
-	title: z.string(),
-	path: z.string(),
-	status: z.enum(["draft", "published"]),
-	hasUnpublishedChanges: z.boolean(),
-	updatedAt: sdkTimestampSchema$2,
-	createdAt: sdkTimestampSchema$2,
-	publishedAt: sdkTimestampSchema$2.nullable(),
-	blocks: z.array(z.object({
-		id: sdkIdentifierSchema$1,
-		identifier: sdkIdentifierSchema$1,
-		kind: sdkIdentifierSchema$1,
-		position: z.number().int().nonnegative(),
-		data: sdkJsonObjectSchema$1,
-		createdAt: sdkTimestampSchema$2,
-		updatedAt: sdkTimestampSchema$2
-	}))
-});
-const sdkPullNavigationItemSchema = z.lazy(() => z.object({
-	id: sdkIdentifierSchema$1,
-	menuId: sdkIdentifierSchema$1,
-	label: z.string(),
-	link: linkPayloadSchema.nullable(),
-	isCta: z.boolean().optional(),
-	position: z.number().int().nonnegative(),
-	parentId: sdkIdentifierSchema$1.nullable(),
-	children: z.array(sdkPullNavigationItemSchema).optional(),
-	resolvedIdentifier: z.string().nullable().optional(),
-	resolvedContentType: z.string().nullable().optional()
-}));
-const sdkPullNavigationMenuSchema = z.object({
-	id: sdkIdentifierSchema$1,
-	siteId: sdkIdentifierSchema$1,
-	location: z.enum([
-		"main",
-		"footer",
-		"legal"
-	]),
-	items: z.array(sdkPullNavigationItemSchema),
-	createdAt: sdkTimestampSchema$2,
-	updatedAt: sdkTimestampSchema$2
-});
-const siteTitleSchema = z.string().min(1, "Site title is required");
-const sdkSeoDefaultsSchema = z.object({
-	title: z.string().optional(),
-	description: z.string().optional(),
-	ogImage: z.string().optional(),
-	allowIndexingInProduction: z.boolean().optional()
-});
-const sdkSettingsUpdateSchema = z.object({
-	siteTitle: siteTitleSchema.optional(),
-	homepageId: z.string().nullable().optional(),
-	seoDefaults: sdkSeoDefaultsSchema.nullable().optional(),
-	logoIdentifier: z.string().min(1).nullable().optional(),
-	logoDarkBackgroundIdentifier: z.string().min(1).nullable().optional(),
-	faviconIdentifier: z.string().min(1).nullable().optional()
-}).strict();
-const sdkPullSettingsSchema = sdkSettingsUpdateSchema.extend({
-	homepageId: z.string().nullable(),
-	seoDefaults: sdkSeoDefaultsSchema.nullable(),
-	verticalConfig: sdkConfiguredBookingVerticalConfigSchema.optional()
-});
-/** A form's schema as the SDK pulls it; the push route extends it. */
-const sdkPullFormSchema = z.object({
-	version: z.string().optional(),
-	fields: z.array(z.object({
-		id: sdkIdentifierSchema$1,
-		label: z.string(),
-		type: z.string(),
-		required: z.boolean().optional(),
-		placeholder: z.string().optional(),
-		helpText: z.string().optional(),
-		layout: z.object({ width: z.enum(["full", "half"]).optional() }).optional(),
-		options: z.array(z.object({
-			value: z.string(),
-			label: z.string()
-		})).optional(),
-		multiple: z.boolean().optional(),
-		minLength: z.number().optional(),
-		maxLength: z.number().optional(),
-		pattern: z.string().optional(),
-		min: z.number().optional(),
-		max: z.number().optional()
-	}))
-});
-const sdkPullFormSchemaWithId = z.object({
-	id: sdkIdentifierSchema$1,
-	slug: sdkIdentifierSchema$1,
-	name: z.string(),
-	schema: sdkPullFormSchema,
-	settings: sdkJsonObjectSchema$1,
-	updatedAt: sdkTimestampSchema$2,
-	createdAt: sdkTimestampSchema$2
-});
-const sdkPulledFormSchema = sdkPullFormSchemaWithId.omit({ id: true });
-const sdkPullVenueSchema = z.object({
-	slug: sdkIdentifierSchema$1,
-	title: z.string(),
-	description: z.string().nullable(),
-	timezone: z.string().nullable(),
-	capacity: z.number().int().nonnegative().nullable(),
-	address: z.object({
-		line1: z.string().optional(),
-		line2: z.string().optional(),
-		city: z.string().optional(),
-		region: z.string().optional(),
-		postcode: z.string().optional(),
-		country: z.string().optional()
-	}),
-	location: z.object({
-		lat: z.number(),
-		lng: z.number()
-	}).partial().nullable(),
-	mapEmbed: z.string().nullable(),
-	updatedAt: sdkTimestampSchema$2,
-	createdAt: sdkTimestampSchema$2
-});
-const sdkPullEventCategorySchema = z.object({
-	identifier: sdkIdentifierSchema$1,
-	name: z.string(),
-	description: z.string().nullable(),
-	color: z.string().nullable(),
-	sortOrder: z.number().int(),
-	updatedAt: sdkTimestampSchema$2,
-	createdAt: sdkTimestampSchema$2
-});
-const sdkEventScheduleSchema = z.object({
-	recurrenceRule: z.string().nullable(),
-	startDate: z.string().nullable().optional(),
-	timezone: z.string().nullable().optional(),
-	defaultStartTime: z.string(),
-	durationMinutes: z.number().int().nonnegative()
-});
-const sdkPullEventSchema = z.object({
-	identifier: sdkIdentifierSchema$1,
-	courseBooking: sdkCourseBookingSettingsSchema.optional(),
-	administrativeStatus: z.enum(["active", "archived"]),
-	title: z.string(),
-	slug: sdkIdentifierSchema$1,
-	path: z.string().nullable(),
-	preset: z.enum(EVENT_PRESET_VALUES),
-	categoryRef: z.string().nullable(),
-	runRefs: z.tuple([sdkIdentifierSchema$1], sdkIdentifierSchema$1),
-	content: sdkJsonObjectSchema$1,
-	updatedAt: sdkTimestampSchema$2,
-	createdAt: sdkTimestampSchema$2,
-	contentUpdatedAt: sdkTimestampSchema$2.nullable(),
-	blocks: sdkEntrySlotBlocksSchema.optional()
-});
-const sdkPullEventRunSchema = z.object({
-	identifier: sdkIdentifierSchema$1,
-	eventRef: sdkIdentifierSchema$1,
-	name: z.string().nullable(),
-	status: z.enum([
-		"draft",
-		"active",
-		"archived",
-		"cancelled",
-		"completed"
-	]),
-	visibility: eventVisibilitySchema.optional(),
-	bookingScope: z.enum(["single_occurrence", "whole_series"]),
-	occurrences: z.array(sdkEventOccurrenceInputSchema),
-	capacity: z.number().int().nonnegative().nullable(),
-	bookingOffer: eventBookingOfferIntentSchema,
-	venueRef: z.string().nullable(),
-	formRef: z.string().nullable(),
-	settings: sdkJsonObjectSchema$1,
-	presentation: z.unknown().optional(),
-	tags: z.array(z.string()),
-	updatedAt: sdkTimestampSchema$2,
-	createdAt: sdkTimestampSchema$2
-});
-const sdkPullEntriesResponseSchema = z.object({
-	entries: z.array(sdkPulledEntrySchema.extend({ contentType: sdkIdentifierSchema$1 })),
-	meta: sdkPullMetaSchema.extend({
-		entries: z.record(z.string(), sdkPullEntryTimestampsSchema),
-		truncation: sdkPullTruncationSchema
-	}),
-	pagination: sdkPullPaginationSchema
-});
-const sdkPullEntriesByTypeResponseSchema = z.object({
-	contentType: sdkIdentifierSchema$1,
-	entries: z.array(sdkPulledEntrySchema),
-	meta: sdkPullMetaSchema.extend({ entries: z.record(z.string(), sdkPullEntryTimestampsSchema) }),
-	pagination: sdkPullPaginationSchema
-});
-const sdkPullEntriesAllResponseSchema = z.object({
-	entries: z.record(z.string(), z.array(sdkPulledEntrySchema)),
-	meta: sdkPullMetaSchema.extend({
-		totalEntries: z.number().int().nonnegative(),
-		contentTypes: z.array(sdkIdentifierSchema$1),
-		entries: z.record(z.string(), sdkPullEntryTimestampsSchema),
-		truncation: sdkPullTruncationSchema
-	})
-});
-const sdkPullPagesResponseSchema = z.object({
-	pages: z.array(sdkPullPageSchema),
-	meta: sdkPullMetaSchema
-});
-const sdkPullNavigationResponseSchema = z.object({
-	menus: z.array(sdkPullNavigationMenuSchema),
-	meta: sdkPullMetaSchema
-});
-const sdkPullSettingsResponseSchema = z.object({
-	settings: sdkPullSettingsSchema,
-	warnings: z.array(z.union([z.string(), sdkPullSettingsWarningSchema])).optional(),
-	meta: sdkPullMetaSchema.extend({ updatedAt: sdkTimestampSchema$2.nullable() })
-});
-const sdkPullFormsResponseSchema = z.object({
-	forms: z.array(sdkPulledFormSchema),
-	meta: sdkPullMetaSchema
-});
-const sdkPullThemeResponseSchema = z.object({
-	theme: sdkThemeWireSchema.nullable(),
-	themeId: sdkIdentifierSchema$1.nullable(),
-	selectionId: sdkIdentifierSchema$1.nullable(),
-	selectionVersion: z.number().int().nonnegative(),
-	meta: sdkPullMetaSchema.extend({ updatedAt: sdkTimestampSchema$2.nullable() })
-}).passthrough();
-const sdkFooterContentSchema = z.object({
-	composition: z.unknown().transform((value, ctx) => {
-		const parsed = parseFooterCompositionV1(value);
-		if (parsed.ok) return parsed.value;
-		ctx.addIssue({
-			code: "custom",
-			message: "Expected a canonical footer composition"
-		});
-		return z.NEVER;
-	}),
-	revision: z.number().int().nonnegative()
-}).passthrough();
-const sdkPullFooterResponseSchema = z.object({
-	footer: sdkFooterContentSchema.nullable(),
-	meta: sdkPullMetaSchema.extend({ updatedAt: sdkTimestampSchema$2.nullable() })
-});
-const sdkPullVenuesResponseSchema = z.object({
-	venues: z.array(sdkPullVenueSchema),
-	meta: sdkPullMetaSchema
-});
-const sdkPullEventCategoriesResponseSchema = z.object({
-	eventCategories: z.array(sdkPullEventCategorySchema),
-	meta: sdkPullMetaSchema
-});
-const sdkPullEventsResponseSchema = z.object({
-	events: z.array(sdkPullEventSchema),
-	eventRuns: z.array(sdkPullEventRunSchema),
-	meta: sdkPullMetaSchema
-});
-
-//#endregion
-//#region ../api/src/bookingSettingsSections.ts
-const BOOKING_SETTINGS_SECTION_LABELS = {
-	basics: "Booking basics",
-	payments: "Payments",
-	events: "Events",
-	appointments: "Appointments",
-	messages: "Messages"
-};
-const BOOKING_SETTINGS_SECTION_KEYS = {
-	basics: [
-		"modules",
-		"verticalConfig",
-		"eventTypePresets",
-		"personRecordMode",
-		"defaultTimezone",
-		"calendarDisplay",
-		"icsFeedsEnabled",
-		"waitlists",
-		"teamMemberProfilePages"
-	],
-	payments: [
-		"paymentDefaults",
-		"currency",
-		"refundsIssueCredit"
-	],
-	events: [
-		"defaultVenueId",
-		"eventReminderHours",
-		"eventReminderOverrides",
-		"eventScheduleWindowMonths",
-		"eventOrganizerNotifications",
-		"eventOrganizerEmail",
-		"eventTicketingDefaultEnabled",
-		"collectAllAttendeeDetails",
-		"eventTypeBookingDefaults",
-		"eventBookingPolicies",
-		"defaultEventImage",
-		"eventDestinationPolicy"
-	],
-	appointments: [
-		"appointmentReminderHours",
-		"appointmentReminderOverrides",
-		"appointmentRescheduleHours",
-		"appointmentDefaultMinLeadMinutes",
-		"appointmentDefaultMaxBookingNoticeMinutes",
-		"appointmentBookingPolicies"
-	],
-	messages: [
-		"remindersEnabled",
-		"notificationSettings",
-		"appointmentStaffReminder",
-		"appointmentStaffChangeNotifications",
-		"eventFeedback",
-		"appointmentFollowUp"
-	]
-};
-
-//#endregion
-//#region ../api/src/event-destination-policy.ts
-const eventDestinationModeValues = ["cms-managed", "system-managed"];
-const eventDestinationPresetValues = EVENT_PRESET_VALUES;
-const DEFAULT_EVENT_DESTINATION_POLICY = {
-	defaultMode: "cms-managed",
-	presetOverrides: {}
-};
-function isEventDestinationMode(value) {
-	return eventDestinationModeValues.some((mode) => mode === value);
-}
-function resolveEventDestinationMode(input) {
-	const policy = input.policy ?? DEFAULT_EVENT_DESTINATION_POLICY;
-	if (input.preset) {
-		const presetOverride = policy.presetOverrides[input.preset];
-		if (presetOverride) return presetOverride;
-	}
-	if (input.publicExperience === "hosted_booking") return "system-managed";
-	return policy.defaultMode;
-}
-function macadamiaDefaultEventDestinationPolicy(selectedPresets) {
-	const presetOverrides = {};
-	for (const preset of selectedPresets) {
-		presetOverrides[preset] = preset === "class" ? "system-managed" : "cms-managed";
-	}
-	return {
-		defaultMode: "cms-managed",
-		presetOverrides
-	};
-}
-
-//#endregion
-//#region ../api/src/bookingConfig.ts
-/** Every option kind; the checkout routes validate the requested kind against it. */
-const DIRECT_CHECKOUT_COLLECTION_OPTION_KINDS = [
-	"upfront",
-	"deferred_manual",
-	"instalment_plan",
-	"flexible_balance"
-];
-const eventOccurrenceRestorationSummarySchema = z.object({
-	restoredOccurrenceIds: z.array(z.string().uuid()),
-	excludedBookings: z.array(z.object({
-		attendeeId: z.string().uuid(),
-		occurrenceId: z.string().uuid(),
-		customerId: z.string().uuid(),
-		customerName: z.string().nullable(),
-		customerEmail: z.string().nullable()
-	}))
-});
-const DEFAULT_BOOKING_NOTIFICATION_SEND_RULE = {
-	kind: "send",
-	sendToAssignedStaff: true,
-	extraEmail: null,
-	sendToSiteOwnerIfNoStaff: true
-};
-const DEFAULT_BOOKING_NOTIFICATION_SETTINGS = {
-	state: "configured",
-	defaultRule: DEFAULT_BOOKING_NOTIFICATION_SEND_RULE,
-	overrides: {}
-};
-const DEFAULT_APPOINTMENT_STAFF_DIGEST_LOCAL_SEND_TIME = "07:00";
-const BOOKING_SETTINGS_SECTIONS = [
-	"basics",
-	"payments",
-	"events",
-	"appointments",
-	"messages"
-];
-const unownedBookingSettingsKeys = {};
-void unownedBookingSettingsKeys;
-function pickBookingSettingsSection(settings, section) {
-	const entries = BOOKING_SETTINGS_SECTION_KEYS[section].map((key) => [key, settings[key]]);
-	return Object.fromEntries(entries);
-}
-function completeBookingSettingsForSectionUpdate(settings) {
-	return {
-		...settings,
-		eventTypePresets: settings.eventTypePresets ?? DEFAULT_EVENT_TYPE_PRESETS,
-		verticalConfig: settings.verticalConfig ?? {
-			verticalId: null,
-			selectedPresetIds: []
-		},
-		teamMemberProfilePages: settings.teamMemberProfilePages ?? { policy: "selected" },
-		eventDestinationPolicy: settings.eventDestinationPolicy ?? {
-			defaultMode: "cms-managed",
-			presetOverrides: {}
-		},
-		eventTypeBookingDefaults: settings.eventTypeBookingDefaults ?? {}
-	};
-}
-function createBookingSettingsSectionUpdate(settings, section) {
-	const completeSettings = completeBookingSettingsForSectionUpdate(settings);
-	switch (section) {
-		case "basics": return {
-			section,
-			settings: pickBookingSettingsSection(completeSettings, section)
-		};
-		case "payments": return {
-			section,
-			settings: pickBookingSettingsSection(completeSettings, section)
-		};
-		case "events": return {
-			section,
-			settings: pickBookingSettingsSection(completeSettings, section)
-		};
-		case "appointments": return {
-			section,
-			settings: pickBookingSettingsSection(completeSettings, section)
-		};
-		case "messages": return {
-			section,
-			settings: pickBookingSettingsSection(completeSettings, section)
-		};
-	}
-}
-function createBookingSettingsUpdateRequest(settings, sections = BOOKING_SETTINGS_SECTIONS) {
-	return { updates: sections.map((section) => createBookingSettingsSectionUpdate(settings, section)) };
-}
-function applyBookingSettingsSectionUpdate(settings, update) {
-	return {
-		...settings,
-		...update.settings
-	};
-}
-function applyBookingSettingsSectionUpdates(settings, updates) {
-	return updates.reduce(applyBookingSettingsSectionUpdate, settings);
-}
-/** Normalize optional wire defaults once before projecting operational Event policy. */
-function resolveBookingSettingsEventCatalogue(settings) {
-	return resolveEventCatalogue({
-		verticalConfig: settings.verticalConfig,
-		eventTypePresets: settings.eventTypePresets ?? DEFAULT_EVENT_TYPE_PRESETS
-	});
-}
-
-//#endregion
-//#region ../api/src/sdkManagementResponseSchemas.ts
-const sdkIdentifierSchema = z.string().min(1);
-const sdkTimestampSchema$1 = z.string().min(1);
-const sdkJsonObjectSchema = z.record(z.string(), z.unknown());
-const sdkManagementEntrySchema = z.object({
-	id: sdkIdentifierSchema,
-	identifier: sdkIdentifierSchema,
-	contentType: sdkIdentifierSchema,
-	slug: z.string().optional(),
-	title: z.string(),
-	data: sdkJsonObjectSchema,
-	publishedData: sdkJsonObjectSchema.nullable().optional(),
-	status: z.enum(["draft", "published"]),
-	hasUnpublishedChanges: z.boolean(),
-	createdAt: sdkTimestampSchema$1,
-	updatedAt: sdkTimestampSchema$1,
-	publishedAt: sdkTimestampSchema$1.nullable(),
-	manualOrder: z.number(),
-	blocks: sdkEntrySlotBlocksSchema.optional()
-});
-const sdkManagementEntryWithoutPublishedDataSchema = sdkManagementEntrySchema.omit({ publishedData: true });
-const sdkManagementPageSchema = z.object({
-	id: sdkIdentifierSchema,
-	identifier: sdkIdentifierSchema,
-	title: z.string(),
-	path: z.string(),
-	status: z.enum(["draft", "published"]),
-	hasUnpublishedChanges: z.boolean(),
-	createdAt: sdkTimestampSchema$1,
-	updatedAt: sdkTimestampSchema$1,
-	publishedAt: sdkTimestampSchema$1.nullable()
-});
-const sdkManagementBlockSchema = z.object({
-	id: sdkIdentifierSchema,
-	identifier: sdkIdentifierSchema,
-	kind: sdkIdentifierSchema,
-	position: z.number().int().nonnegative(),
-	data: sdkJsonObjectSchema,
-	createdAt: sdkTimestampSchema$1,
-	updatedAt: sdkTimestampSchema$1
-});
-const sdkManagementNavigationMenuSchema = sdkPullNavigationMenuSchema.omit({ siteId: true });
-const sdkPublicationOutcomeSchema = (code) => z.union([z.object({ published: z.literal(true) }), z.object({
-	published: z.literal(false),
-	publishError: z.object({
-		code: z.literal(code),
-		message: z.string().min(1)
-	})
-})]);
-const sdkUpsertEntryDraftResponseSchema = sdkCommandApplicationResultSchema(sdkManagementEntryWithoutPublishedDataSchema).extend({
-	saved: z.never().optional(),
-	publication: z.never().optional()
-});
-const sdkUpsertEntryPublishResponseSchema = sdkCommandApplicationResultSchema(sdkManagementEntryWithoutPublishedDataSchema).extend({
-	saved: z.literal(true),
-	publication: sdkPublicationOutcomeSchema("PUBLISH_ENTRY_FAILED")
-});
-const sdkUpsertPageDraftResponseSchema = sdkCommandApplicationResultSchema(sdkManagementPageSchema).extend({
-	saved: z.never().optional(),
-	publication: z.never().optional()
-});
-const sdkUpsertPagePublishResponseSchema = sdkCommandApplicationResultSchema(sdkManagementPageSchema).extend({
-	saved: z.literal(true),
-	publication: sdkPublicationOutcomeSchema("PUBLISH_PAGE_FAILED")
-});
-const sdkUpsertPageResponseSchema = z.union([sdkUpsertPageDraftResponseSchema, sdkUpsertPagePublishResponseSchema]);
-const sdkUpsertEntryResponseSchema = z.union([sdkUpsertEntryDraftResponseSchema, sdkUpsertEntryPublishResponseSchema]);
-const sdkDeleteResponseSchema = sdkCommandApplicationResultSchema(z.object({ deleted: z.literal(true) }));
-const sdkDeleteBlockResponseSchema = sdkDeleteResponseSchema.extend({ designSyncWarning: pageBlockDesignSyncWarningSchema.optional() });
-const sdkBlockContentWarningSchema = z.object({
-	field: z.string(),
-	code: z.literal("theme-unavailable-variant"),
-	message: z.string(),
-	value: z.string()
-});
-const sdkUpsertBlockResponseSchema = sdkCommandApplicationResultSchema(sdkManagementBlockSchema).extend({
-	warnings: z.array(sdkBlockContentWarningSchema).optional(),
-	appearance: sdkBlockAppearanceOutcomeSchema.optional(),
-	designSyncWarning: pageBlockDesignSyncWarningSchema.optional()
-});
-const sdkPatchPageBlockResponseSchema = z.object({
-	block: z.object({
-		id: sdkIdentifierSchema,
-		identifier: sdkIdentifierSchema,
-		kind: sdkIdentifierSchema,
-		position: z.number().int().nonnegative(),
-		data: sdkJsonObjectSchema,
-		contentHash: sdkIdentifierSchema
-	}),
-	warnings: z.array(sdkBlockContentWarningSchema).optional()
-});
-const sdkUpsertNavigationMenuResponseSchema = sdkCommandApplicationResultSchema(sdkManagementNavigationMenuSchema);
-const sdkUpsertSettingsResponseSchema = sdkCommandApplicationResultSchema(sdkPullSettingsSchema);
-const sdkUpsertFormResponseSchema = sdkCommandApplicationResultSchema(sdkPullFormSchemaWithId);
-const sdkUpsertVenueResponseSchema = sdkCommandApplicationResultSchema(sdkPullVenueSchema.extend({ id: sdkIdentifierSchema }));
-const sdkUpsertEventCategoryResponseSchema = sdkCommandApplicationResultSchema(sdkPullEventCategorySchema.extend({ id: sdkIdentifierSchema }));
-const sdkManagementEventSchema = sdkPullEventSchema.extend({
-	id: sdkIdentifierSchema.transform(unsafeAsEventOfferingId),
-	pageState: z.enum(["online", "offline"]).optional()
-});
-const sdkManagementEventRunSchema = sdkPullEventRunSchema.extend({
-	id: sdkIdentifierSchema.transform(unsafeAsEventSeriesId),
-	eventId: sdkIdentifierSchema.transform(unsafeAsEventOfferingId),
-	schedule: sdkEventScheduleSchema
-});
-const sdkManagementEventGraphSchema = z.object({
-	event: sdkManagementEventSchema,
-	runs: z.tuple([sdkManagementEventRunSchema], sdkManagementEventRunSchema)
-});
-const sdkListEventsResponseSchema = z.object({
-	events: z.array(sdkManagementEventSchema),
-	eventRuns: z.array(sdkManagementEventRunSchema)
-});
-const sdkGetEventResponseSchema = sdkManagementEventGraphSchema;
-const sdkEventSeriesIdSchema = sdkIdentifierSchema.transform(unsafeAsEventSeriesId);
-/**
-* The lifecycle outcome for `POST /sdk/{siteId}/events/{identifier}/lifecycle`.
-* `applied` always changed something: at least one run, or the Event page.
-*/
-const sdkTakeEventOfflineResponseSchema = z.union([
-	z.object({
-		kind: z.literal("applied"),
-		changedRunIds: z.tuple([sdkEventSeriesIdSchema], sdkEventSeriesIdSchema),
-		pageTakenOffline: z.boolean()
-	}),
-	z.object({
-		kind: z.literal("applied"),
-		changedRunIds: z.tuple([]),
-		pageTakenOffline: z.literal(true)
-	}),
-	z.object({ kind: z.literal("already-offline") })
-]);
-const sdkUpsertEventResponseSchema = z.union([sdkCommandApplicationResultSchema(sdkManagementEventGraphSchema).extend({
-	cancellationResult: businessCancellationResultSchema.optional(),
-	restoration: eventOccurrenceRestorationSummarySchema.optional()
-}), z.object({
-	kind: z.literal("accepted_unavailable"),
-	id: sdkEventSeriesIdSchema,
-	effect: z.object({ kind: z.literal("updated") }),
-	cancellationResult: businessCancellationResultSchema
-})]);
-const sdkUpsertThemeResponseSchema = sdkCommandApplicationResultSchema(z.object({
-	themeId: sdkIdentifierSchema,
-	selectionId: sdkIdentifierSchema,
-	savedAt: sdkTimestampSchema$1
-}));
-const sdkApplySiteStyleSelectionResponseSchema = sdkCommandApplicationResultSchema(z.object({
-	success: z.boolean(),
-	themeId: sdkIdentifierSchema,
-	selectionId: sdkIdentifierSchema,
-	selectionVersion: z.number().int().nonnegative(),
-	selectionUpdatedAt: sdkTimestampSchema$1.nullable(),
-	savedAt: sdkTimestampSchema$1,
-	theme: themeSchema,
-	siteStyleId: sdkIdentifierSchema,
-	buttonStyleSelection: buttonStyleSelectionSchema,
-	headerLayoutId: sdkIdentifierSchema,
-	headerStyleId: sdkIdentifierSchema,
-	footerLookId: sdkIdentifierSchema.nullable()
-}));
-const sdkUpsertFooterResponseSchema = sdkCommandApplicationResultSchema(sdkFooterContentSchema.nullable());
-
-//#endregion
-//#region ../api/src/sdkResponseSchemas.ts
-const sdkTimestampSchema = z.string().min(1);
-const sdkConfigureBookingVerticalResponseSchema = sdkCommandApplicationResultSchema(z.object({
-	verticalConfig: sdkConfiguredBookingVerticalConfigSchema,
-	revision: sdkTimestampSchema.nullable()
-})).extend({ warnings: z.array(sdkBookingSettingsWarningSchema).optional() });
-
-//#endregion
-//#region ../management-client/src/responseValidation.ts
-function isRecord$3(value) {
-	return Boolean(value && typeof value === "object" && !Array.isArray(value));
-}
-function pullSchemaForRequest(path$2) {
-	switch (path$2) {
-		case "/pull/entries/all": return sdkPullEntriesAllResponseSchema;
-		case "/pull/entries": return sdkPullEntriesResponseSchema;
-		case "/pull/pages": return sdkPullPagesResponseSchema;
-		case "/pull/navigation": return sdkPullNavigationResponseSchema;
-		case "/pull/settings": return sdkPullSettingsResponseSchema;
-		case "/pull/forms": return sdkPullFormsResponseSchema;
-		case "/pull/footer": return sdkPullFooterResponseSchema;
-		case "/pull/venues": return sdkPullVenuesResponseSchema;
-		case "/pull/event-categories": return sdkPullEventCategoriesResponseSchema;
-		case "/pull/events": return sdkPullEventsResponseSchema;
-		default: return /^\/pull\/entries\/[^/]+$/.test(path$2) ? sdkPullEntriesByTypeResponseSchema : undefined;
-	}
-}
-function rootMutationSchema(method, path$2, body) {
-	if (method === "POST") {
-		switch (path$2) {
-			case "/entries": return isRecord$3(body) && body.publication === "publish" ? sdkUpsertEntryPublishResponseSchema : sdkUpsertEntryDraftResponseSchema;
-			case "/pages": return isRecord$3(body) && body.publication === "publish" ? sdkUpsertPagePublishResponseSchema : sdkUpsertPageDraftResponseSchema;
-			case "/navigation": return sdkUpsertNavigationMenuResponseSchema;
-			case "/forms": return sdkUpsertFormResponseSchema;
-			case "/venues": return sdkUpsertVenueResponseSchema;
-			case "/event-categories": return sdkUpsertEventCategoryResponseSchema;
-			case "/events": return sdkUpsertEventResponseSchema;
-			case "/footer": return sdkUpsertFooterResponseSchema;
-		}
-	}
-	if (method === "PATCH" && path$2 === "/settings") return sdkUpsertSettingsResponseSchema;
-	if (method === "POST" && path$2 === "/settings/booking/vertical") return sdkConfigureBookingVerticalResponseSchema;
-	return undefined;
-}
-function isDeleteMutationPath(path$2) {
-	return [
-		/^\/entries\/[^/]+\/[^/]+$/,
-		/^\/pages\/[^/]+$/,
-		/^\/pages\/[^/]+\/blocks\/[^/]+$/,
-		/^\/navigation\/[^/]+$/,
-		/^\/forms\/[^/]+$/,
-		/^\/venues\/[^/]+$/,
-		/^\/event-categories\/[^/]+$/,
-		/^\/events\/[^/]+$/
-	].some((pattern) => pattern.test(path$2));
-}
-function blockMutationSchema(method, path$2) {
-	if (method === "POST" && /^\/pages\/[^/]+\/blocks$/.test(path$2)) return sdkUpsertBlockResponseSchema;
-	if (method === "POST" && /^\/pages\/[^/]+\/blocks\/reorder$/.test(path$2)) return sdkReorderResponseSchema;
-	if (method === "PATCH" && /^\/pages\/[^/]+\/blocks\/[^/]+$/.test(path$2)) return sdkPatchPageBlockResponseSchema;
-	if (method === "DELETE" && /^\/pages\/[^/]+\/blocks\/[^/]+$/.test(path$2)) return sdkDeleteBlockResponseSchema;
-	return undefined;
-}
-function nestedMutationSchema(method, path$2) {
-	const blockSchema = blockMutationSchema(method, path$2);
-	if (blockSchema) return blockSchema;
-	if (method === "POST" && /^\/entries\/[^/]+\/[^/]+\/(publish|unpublish)$/.test(path$2)) {
-		return sdkCommandApplicationResultSchema(sdkUpsertEntryDraftResponseSchema.shape.value);
-	}
-	if (method === "POST" && /^\/pages\/[^/]+\/(publish|unpublish)$/.test(path$2)) {
-		return sdkCommandApplicationResultSchema(sdkUpsertPageDraftResponseSchema.shape.value);
-	}
-	if (method === "DELETE" && isDeleteMutationPath(path$2)) return sdkDeleteResponseSchema;
-	return undefined;
-}
-function occurrenceResponseSchema(method, path$2) {
-	const collection = /^\/events\/[^/]+\/runs\/[^/]+\/occurrences$/;
-	const member = /^\/events\/[^/]+\/runs\/[^/]+\/occurrences\/[^/]+$/;
-	if (method === "GET" && collection.test(path$2)) return sdkListEventOccurrencesResponseSchema;
-	if (method === "POST" && collection.test(path$2)) return sdkEventOccurrenceResponseSchema;
-	if (method === "PATCH" && member.test(path$2)) return sdkEventOccurrenceResponseSchema;
-	if (method === "DELETE" && member.test(path$2)) return sdkDeleteEventOccurrenceResponseSchema;
-	return method === "POST" && /^\/events\/[^/]+\/runs\/[^/]+\/occurrences\/[^/]+\/cancel$/.test(path$2) ? sdkEventOccurrenceResponseSchema : undefined;
-}
-function mediaResponseSchema(method, path$2) {
-	if (method === "GET" && path$2 === "/media") return sdkMediaListResponseSchema;
-	if (method === "GET" && /^\/media\/[^/]+\/download$/.test(path$2)) return sdkMediaDownloadResponseSchema;
-	if (method === "POST" && /^\/media\/[^/]+\/delete-preview$/.test(path$2)) return sdkMediaDeletePreviewResponseSchema;
-	if (method === "DELETE" && /^\/media\/[^/]+$/.test(path$2)) return sdkMediaDeleteApplyResponseSchema;
-	return undefined;
-}
-function schemaForManagementRequest(method, path$2, body) {
-	if (method === "GET") {
-		return pullSchemaForRequest(path$2) ?? occurrenceResponseSchema(method, path$2) ?? mediaResponseSchema(method, path$2);
-	}
-	return rootMutationSchema(method, path$2, body) ?? occurrenceResponseSchema(method, path$2) ?? mediaResponseSchema(method, path$2) ?? nestedMutationSchema(method, path$2);
-}
-function validateManagementResponse(value, schema) {
-	const parsed = schema.safeParse(value);
-	if (parsed.success) return { valid: true };
-	return {
-		valid: false,
-		details: { issues: parsed.error.issues.slice(0, 8).map((issue) => ({
-			path: issue.path.map(String),
-			message: issue.message,
-			...issue.code ? { code: issue.code } : {}
-		})) }
-	};
-}
-
-//#endregion
-//#region ../management-client/src/transportFailure.ts
-/**
-* Sanitised transport failures (issue 1496).
-*
-* When `fetch` rejects, the caught value can carry anything the platform put
-* there: a message naming the host and port, a cause chain, a stack, and in
-* some runtimes echoes of the request. None of that may leave the client. The
-* caught value is inspected here, and only here, for one thing: whether its
-* platform code (`cause.code`, else `code`) is one of an allow-listed set of
-* Node and undici codes. The result is a closed union whose `code` is always
-* one of those literals, and a fixed message per kind. Nothing else from the caught value is kept.
-*
-* Code lists were checked against Node 24.18 (undici bundled with it) by
-* provoking each failure: DNS lookups fail with `ENOTFOUND`/`EAI_AGAIN`, a
-* closed port with `ECONNREFUSED` (an `AggregateError` carrying the same code
-* when happy-eyeballs tries several addresses), an unroutable host with
-* undici's `UND_ERR_CONNECT_TIMEOUT`, a peer reset with `ECONNRESET`, a peer
-* closing mid-response with `UND_ERR_SOCKET`, and TLS failures with the
-* OpenSSL verification codes and `ERR_TLS_CERT_ALTNAME_INVALID`.
-*
-* Bun puts its code on the error itself rather than on `cause`, so that is read
-* as a fallback. Bun 1.3 reports resets and TLS failures with the same codes
-* as Node; it reports refused connections *and* failed DNS lookups alike as
-* `ConnectionRefused`, which is deliberately not listed and stays `unknown`.
-*/
-const DNS_CODES = ["ENOTFOUND", "EAI_AGAIN"];
-const CONNECT_CODES = [
-	"ECONNREFUSED",
-	"UND_ERR_CONNECT_TIMEOUT",
-	"ECONNABORTED",
-	"EHOSTUNREACH",
-	"ENETUNREACH"
-];
-const RESET_CODES = [
-	"ECONNRESET",
-	"EPIPE",
-	"UND_ERR_SOCKET"
-];
-const TLS_CODES = [
-	"CERT_HAS_EXPIRED",
-	"DEPTH_ZERO_SELF_SIGNED_CERT",
-	"SELF_SIGNED_CERT_IN_CHAIN",
-	"UNABLE_TO_VERIFY_LEAF_SIGNATURE",
-	"UNABLE_TO_GET_ISSUER_CERT_LOCALLY",
-	"ERR_TLS_CERT_ALTNAME_INVALID",
-	"ERR_SSL_WRONG_VERSION_NUMBER"
-];
-const TIMEOUT_CODES = [
-	"UND_ERR_HEADERS_TIMEOUT",
-	"UND_ERR_BODY_TIMEOUT",
-	"ETIMEDOUT"
-];
-function isOneOf(values, value) {
-	return values.includes(value);
-}
-/**
-* Read one property of an arbitrary value. A throwing getter or a hostile
-* proxy yields `undefined`, so inspection can never throw past the boundary.
-*/
-function readProperty(value, key) {
-	if (typeof value !== "object" || value === null) return undefined;
-	try {
-		return Reflect.get(value, key);
-	} catch {
-		return undefined;
-	}
-}
-function stringCode(value) {
-	const code = readProperty(value, "code");
-	return typeof code === "string" ? code : undefined;
-}
-/**
-* The platform code for a rejected `fetch`: Node/undici put it on `cause`;
-* Bun puts its own on the error itself. Nothing else is read.
-*/
-function platformCode(caught) {
-	return stringCode(readProperty(caught, "cause")) ?? stringCode(caught);
-}
-/** Map a raw code onto the closed union; anything unlisted is `unknown`. */
-function transportFailureFromCode(code) {
-	if (code === undefined) return { kind: "unknown" };
-	if (isOneOf(DNS_CODES, code)) return {
-		kind: "dns",
-		code
-	};
-	if (isOneOf(CONNECT_CODES, code)) return {
-		kind: "connect",
-		code
-	};
-	if (isOneOf(RESET_CODES, code)) return {
-		kind: "reset",
-		code
-	};
-	if (isOneOf(TLS_CODES, code)) return {
-		kind: "tls",
-		code
-	};
-	if (isOneOf(TIMEOUT_CODES, code)) return {
-		kind: "timeout",
-		code
-	};
-	return { kind: "unknown" };
-}
-/** True when the client's own `AbortSignal.timeout` ended the request. */
-function isClientTimeout(caught) {
-	return readProperty(caught, "name") === "TimeoutError";
-}
-/**
-* Classify a rejected `fetch` or body read. The caught value is read only for
-* its `name` and platform code (guarded, see `readProperty`). `timeoutMs` is
-* the limit the client itself applied, so the timeout message can name it.
-*/
-function classifyTransportFailure(caught, timeoutMs) {
-	return isClientTimeout(caught) ? {
-		code: "sdk:timeout",
-		transport: { kind: "timeout" },
-		timeoutMs
-	} : {
-		code: "sdk:network-error",
-		transport: transportFailureFromCode(platformCode(caught))
-	};
-}
-/** The fixed message for a classified failure. */
-function transportErrorMessage(failure) {
-	return failure.code === "sdk:timeout" ? `Request timed out after ${failure.timeoutMs}ms` : transportFailureMessage(failure.transport);
-}
-/** The fixed, safe message for each kind of network failure. */
-function transportFailureMessage(failure) {
-	switch (failure.kind) {
-		case "dns": return "Could not resolve the dashboard hostname";
-		case "connect": return "Could not open a connection to the dashboard";
-		case "reset": return "The connection to the dashboard closed before a response arrived";
-		case "tls": return "The TLS handshake with the dashboard failed";
-		case "timeout": return "The connection to the dashboard timed out";
-		case "unknown": return "Network request failed";
-	}
-}
-
-//#endregion
-//#region ../management-client/src/http.ts
-/**
-* Error thrown when management API request fails
-*/
-var ManagementApiError = class extends Error {
-	constructor(message, code, details, statusCode, request, tag) {
-		super(message);
-		this.name = "ManagementApiError";
-		this.code = code;
-		this.details = details;
-		this.statusCode = statusCode;
-		this.request = request;
-		this.tag = tag;
-	}
-};
-/** A successful HTTP response whose payload violated its runtime contract. */
-var ManagementInvalidResponseError = class extends ManagementApiError {
-	constructor(details, statusCode, request) {
-		super("Management API returned an invalid response", "invalid_response", details, statusCode, request);
-		this.code = "invalid_response";
-		this.name = "ManagementInvalidResponseError";
-		this.details = details;
-		this.request = request;
-	}
-};
-/**
-* The request never produced a dashboard answer. The message is fixed per
-* failure kind and nothing from the platform error (its message, cause, stack
-* or anything echoing the request) is kept: `transport` is the only diagnostic.
-*/
-var ManagementTransportError = class extends ManagementApiError {
-	/** The message is derived from the classification; no free text is accepted. */
-	constructor(classified, request) {
-		super(transportErrorMessage(classified), classified.code, undefined, undefined, request);
-		this.details = undefined;
-		this.name = "ManagementTransportError";
-		this.code = classified.code;
-		this.transport = classified.transport;
-	}
-};
-/**
-* Turn a rejected `fetch` or body read into a {@link ManagementTransportError}.
-* Every catch site around a management `fetch` or response-body read goes
-* through here so none of them can leak the platform error.
-*/
-function managementTransportError(caught, timeoutMs, request) {
-	return new ManagementTransportError(classifyTransportFailure(caught, timeoutMs), request);
-}
-/**
-* Type guard to check if an error is a 404 Not Found response.
-* Use this to handle "resource not found" scenarios gracefully.
-*
-* @example
-* ```ts
-* try {
-*   return await http.get<Entry>(`/entries/${type}/${id}`);
-* } catch (error) {
-*   if (is404Error(error)) {
-*     return null;
-*   }
-*   throw error;
-* }
-* ```
-*/
-function is404Error(error) {
-	return error instanceof ManagementApiError && error.statusCode === 404;
-}
-function parseRuntimeResponse(value, schema, requestInfo, statusCode) {
-	const parsed = schema.safeParse(value);
-	if (parsed.success) return parsed.data;
-	const validation = validateManagementResponse(value, schema);
-	if (validation.valid) throw new Error("Response schema parsing was inconsistent");
-	throw new ManagementInvalidResponseError(validation.details, statusCode, requestInfo);
-}
-function isRecord$2(value) {
-	return Boolean(value && typeof value === "object" && !Array.isArray(value));
-}
-function isFieldError(value) {
-	return isRecord$2(value) && typeof value.field === "string" && typeof value.code === "string" && typeof value.message === "string";
-}
-function parseApiResponse(value) {
-	if (!isRecord$2(value)) return null;
-	if (value.success === true) {
-		return {
-			success: true,
-			data: value.data
-		};
-	}
-	if (value.success === false) {
-		const error = value.error;
-		if (!isRecord$2(error) || typeof error.code !== "string" || typeof error.message !== "string") {
-			return {
-				success: false,
-				error: {
-					code: "sdk:http-error",
-					message: "Request failed",
-					details: error
-				}
-			};
-		}
-		const fieldErrorsRaw = error.fieldErrors;
-		const fieldErrors = Array.isArray(fieldErrorsRaw) ? fieldErrorsRaw.filter(isFieldError) : undefined;
-		return {
-			success: false,
-			error: {
-				code: error.code,
-				message: error.message,
-				details: error.details,
-				...fieldErrors ? { fieldErrors } : {},
-				...typeof error.tag === "string" ? { tag: error.tag } : {}
-			}
-		};
-	}
-	return null;
-}
-function buildRequestInfo(options) {
-	return {
-		method: options.method,
-		intent: options.intent,
-		path: options.path,
-		url: options.url,
-		baseUrl: options.baseUrl,
-		dashboardUrl: options.dashboardUrl,
-		siteId: options.siteId
-	};
-}
-/**
-* Read a response body as text. A body that fails mid-read (a reset, undici's
-* body timeout, the client's own abort) is a transport failure like any other.
-*/
-async function readResponseText(response, timeoutMs, requestInfo) {
-	try {
-		return await response.text();
-	} catch (error) {
-		throw managementTransportError(error, timeoutMs, requestInfo);
-	}
-}
-async function readApiResponse(response, requestInfo, options) {
-	const contentType = response.headers.get("content-type");
-	const text = await readResponseText(response, options.timeoutMs, requestInfo);
-	if (!contentType?.includes("application/json")) {
-		if (response.ok && options.allowNonJsonOk) return undefined;
-		if (response.ok && options.invalidOkResponse) {
-			throw new ManagementInvalidResponseError({ issues: [{
-				path: [],
-				message: "Expected a JSON response"
-			}] }, response.status, requestInfo);
-		}
-		throw new ManagementApiError(`Request failed with status ${response.status}`, "sdk:http-error", { statusCode: response.status }, response.status, requestInfo);
-	}
-	let parsed;
-	try {
-		parsed = text ? JSON.parse(text) : null;
-	} catch {
-		if (response.ok && options.invalidOkResponse) {
-			throw new ManagementInvalidResponseError({ issues: [{
-				path: [],
-				message: "Response was not valid JSON"
-			}] }, response.status, requestInfo);
-		}
-		throw new ManagementApiError(`Invalid JSON response (status ${response.status})`, "sdk:http-error", { statusCode: response.status }, response.status, requestInfo);
-	}
-	const envelope = parseApiResponse(parsed);
-	if (!envelope) {
-		if (response.ok && options.invalidOkResponse) {
-			throw new ManagementInvalidResponseError({ issues: [{
-				path: [],
-				message: "Response did not match the API envelope"
-			}] }, response.status, requestInfo);
-		}
-		throw new ManagementApiError(`Invalid API response (status ${response.status})`, "sdk:http-error", { statusCode: response.status }, response.status, requestInfo);
-	}
-	return envelope;
-}
-function requestUrl(baseUrl, path$2, params) {
-	if (!params || Object.keys(params).length === 0) return `${baseUrl}${path$2}`;
-	const query = new URLSearchParams(params).toString();
-	return `${baseUrl}${path$2}?${query}`;
-}
-const DEFAULT_REQUEST_TIMEOUT_MS = 3e4;
-function requestTimeoutMs(config) {
-	return config.timeout ?? DEFAULT_REQUEST_TIMEOUT_MS;
-}
-function requestFetchOptions(config, method, body) {
-	const options = {
-		method,
-		headers: {
-			Authorization: `Bearer ${exposeSecret(config.managementApiKey)}`,
-			"Content-Type": "application/json"
-		},
-		signal: AbortSignal.timeout(requestTimeoutMs(config))
-	};
-	if (body !== undefined && method !== "GET") options.body = JSON.stringify(body);
-	return options;
-}
-async function fetchManagementResponse(config, method, intent, path$2, url, baseUrl, options) {
-	const requestInfo = buildRequestInfo({
-		method,
-		intent,
-		path: path$2,
-		url,
-		baseUrl,
-		dashboardUrl: config.dashboardUrl,
-		siteId: config.siteId
-	});
-	try {
-		return {
-			response: await fetch(url, options),
-			requestInfo
-		};
-	} catch (error) {
-		throw managementTransportError(error, requestTimeoutMs(config), requestInfo);
-	}
-}
-function throwApiError(response, json, requestInfo) {
-	if (response.ok && json.success) return;
-	if ("error" in json && json.error) {
-		const details = json.error.fieldErrors ? { fieldErrors: json.error.fieldErrors } : json.error.details;
-		throw new ManagementApiError(json.error.message, json.error.code, details, response.status, requestInfo, json.error.tag);
-	}
-	throw new ManagementApiError(`Request failed with status ${response.status}`, "sdk:http-error", undefined, response.status, requestInfo);
-}
-async function requestWithConfig(config, method, path$2, options) {
-	const baseUrl = `${config.dashboardUrl}/api/sdk/${config.siteId}`;
-	const url = requestUrl(baseUrl, path$2, options.params);
-	const fetchOptions = requestFetchOptions(config, method, options.body);
-	const { response, requestInfo } = await fetchManagementResponse(config, method, options.intent, path$2, url, baseUrl, fetchOptions);
-	const responseSchema = options.responseSchema ?? schemaForManagementRequest(method, path$2, options.body);
-	const timeoutMs = requestTimeoutMs(config);
-	const json = responseSchema ? await readApiResponse(response, requestInfo, {
-		timeoutMs,
-		invalidOkResponse: true
-	}) : await readApiResponse(response, requestInfo, {
-		timeoutMs,
-		allowNonJsonOk: true
-	});
-	if (!json) return undefined;
-	throwApiError(response, json, requestInfo);
-	return responseSchema ? parseRuntimeResponse(json.data, responseSchema, requestInfo, response.status) : json.data;
-}
-function createHttpClient(config) {
-	const send = (method, path$2, options) => requestWithConfig(config, method, path$2, options);
-	return {
-		get: (path$2, params) => send("GET", path$2, {
-			intent: "read",
-			params
-		}),
-		post: (path$2, body, intent) => send("POST", path$2, {
-			intent,
-			body
-		}),
-		patch: (path$2, body) => send("PATCH", path$2, {
-			intent: "write",
-			body
-		}),
-		delete: (path$2, body) => send("DELETE", path$2, {
-			intent: "write",
-			body
-		}),
-		getValidated: (path$2, responseSchema, params) => send("GET", path$2, {
-			intent: "read",
-			params,
-			responseSchema
-		}),
-		postValidated: (path$2, responseSchema, body, intent) => send("POST", path$2, {
-			intent,
-			body,
-			responseSchema
-		}),
-		patchValidated: (path$2, responseSchema, body) => send("PATCH", path$2, {
-			intent: "write",
-			body,
-			responseSchema
-		}),
-		deleteValidated: (path$2, responseSchema, body) => send("DELETE", path$2, {
-			intent: "write",
-			body,
-			responseSchema
-		})
-	};
-}
-
-//#endregion
-//#region src/media/walk.ts
-const isRecordValue = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-const walkValueTree = (value, location, visitor) => {
-	visitor(value, location);
-	if (Array.isArray(value)) {
-		value.forEach((entry, index) => {
-			walkValueTree(entry, `${location}[${index}]`, visitor);
-		});
-		return;
-	}
-	if (isRecordValue(value)) {
-		Object.entries(value).forEach(([key, entry]) => {
-			walkValueTree(entry, location ? `${location}.${key}` : key, visitor);
-		});
-	}
-};
-
-//#endregion
-//#region src/media/value.ts
-const MEDIA_VALUE_TYPES = [
-	"image",
-	"video",
-	"audio",
-	"document",
-	"spreadsheet",
-	"archive"
-];
-const MEDIA_VALUE_TYPE_SET = new Set(MEDIA_VALUE_TYPES);
-const isOptionalString = (value) => value === undefined || typeof value === "string";
-const isOptionalNumber = (value) => value === undefined || typeof value === "number";
-const hasValidKnownMediaFields = (value) => (value.identifier === null || isOptionalString(value.identifier)) && isOptionalString(value.assetId) && isOptionalString(value.storagePath) && isOptionalString(value.storageBucket) && isOptionalString(value.src) && isOptionalString(value.mimeType) && isOptionalNumber(value.width) && isOptionalNumber(value.height);
-const hasMediaReference = (value) => typeof value.identifier === "string" || typeof value.assetId === "string" || typeof value.storagePath === "string" || typeof value.src === "string" || typeof value.mimeType === "string";
-const isMediaValue = (value) => isRecordValue(value) && !("attrs" in value) && typeof value.type === "string" && MEDIA_VALUE_TYPE_SET.has(value.type) && hasValidKnownMediaFields(value) && hasMediaReference(value);
-
-//#endregion
-//#region src/content/media-manifest.ts
-const MANIFEST_VERSION = 2;
-const getManifestPath = (contentDir) => path$1.join(contentDir, "media", ".manifest.json");
-const ensureDir = async (dirPath) => {
-	try {
-		await fs$1.mkdir(dirPath, { recursive: true });
-	} catch (error) {
-		if (error.code !== "EEXIST") {
-			throw error;
-		}
-	}
-};
-const writeJsonFile = async (filePath, data) => {
-	const content = JSON.stringify(data, null, 2) + "\n";
-	await fs$1.writeFile(filePath, content, "utf-8");
-};
-const isRecord$1 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-const hasManifestShape = (value) => {
-	if (!isRecord$1(value) || !("version" in value) || !("assets" in value)) {
-		return false;
-	}
-	return isRecord$1(value.assets);
-};
-const toManifestEntry = (value) => {
-	if (!isRecord$1(value)) return null;
-	const filename = typeof value.filename === "string" ? value.filename : "";
-	if (!filename) return null;
-	return {
-		filename,
-		checksum: typeof value.checksum === "string" ? value.checksum : undefined,
-		mimeType: typeof value.mimeType === "string" ? value.mimeType : undefined
-	};
-};
-const toV2ManifestEntry = (value) => {
-	if (!isRecord$1(value)) return null;
-	if (value.checksum !== undefined && typeof value.checksum !== "string" || value.mimeType !== undefined && typeof value.mimeType !== "string") {
-		return null;
-	}
-	return toManifestEntry(value);
-};
-const parseV2Manifest = (parsed, assets) => {
-	if (typeof parsed.updatedAt !== "string") return null;
-	const parsedAssets = {};
-	for (const [identifier, value] of Object.entries(assets)) {
-		const entry = toV2ManifestEntry(value);
-		if (!entry) return null;
-		parsedAssets[identifier] = entry;
-	}
-	return {
-		version: MANIFEST_VERSION,
-		updatedAt: parsed.updatedAt,
-		assets: parsedAssets
-	};
-};
-const migrateV1Assets = (assets) => Object.fromEntries(Object.entries(assets).flatMap(([identifier, value]) => {
-	const entry = toManifestEntry(value);
-	return entry ? [[identifier, entry]] : [];
-}));
-const migrateV1Manifest = (parsed, assets) => {
-	return {
-		version: MANIFEST_VERSION,
-		updatedAt: typeof parsed.updatedAt === "string" ? parsed.updatedAt : new Date().toISOString(),
-		assets: migrateV1Assets(assets)
-	};
-};
-const parseManifest = (content) => {
-	const parsed = JSON.parse(content);
-	if (!hasManifestShape(parsed)) return null;
-	const assets = parsed.assets;
-	if (parsed.version === 1) return migrateV1Manifest(parsed, assets);
-	if (parsed.version === MANIFEST_VERSION) {
-		return parseV2Manifest(parsed, assets);
-	}
-	return null;
-};
-const createEmptyMediaManifest = () => ({
-	version: MANIFEST_VERSION,
-	updatedAt: new Date().toISOString(),
-	assets: {}
-});
-async function readMediaManifest(contentDir) {
-	const manifestPath = getManifestPath(contentDir);
-	try {
-		const content = await fs$1.readFile(manifestPath, "utf-8");
-		return parseManifest(content) ?? createEmptyMediaManifest();
-	} catch (error) {
-		const nodeError = error;
-		if (nodeError.code !== "ENOENT") {
-			console.warn(`Warning: failed to read media manifest: ${nodeError.message}`);
-		}
-	}
-	return createEmptyMediaManifest();
-}
-async function writeMediaManifest(contentDir, manifest) {
-	const mediaDir = path$1.join(contentDir, "media");
-	await ensureDir(mediaDir);
-	const updatedManifest = {
-		...manifest,
-		version: MANIFEST_VERSION,
-		updatedAt: new Date().toISOString()
-	};
-	const manifestPath = getManifestPath(contentDir);
-	await writeJsonFile(manifestPath, updatedManifest);
-	return manifestPath;
-}
-
-//#endregion
-//#region ../management-client/src/settings-branding.ts
-const SETTINGS_BASE_FIELDS = [
-	"siteTitle",
-	"homepageId",
-	"seoDefaults"
-];
-const SETTINGS_BRANDING_FIELDS = [
-	"logoIdentifier",
-	"logoDarkBackgroundIdentifier",
-	"faviconIdentifier"
-];
-const SETTINGS_FIELDS = [...SETTINGS_BASE_FIELDS, ...SETTINGS_BRANDING_FIELDS];
-/** Fields owned by content/settings.json. Booking configuration has its own
-* mutation operation and must never enter the generic settings update input. */
-const SETTINGS_FILE_FIELDS = [...SETTINGS_FIELDS, "verticalConfig"];
-const SETTINGS_BRANDING_LABELS = {
-	logoIdentifier: "logo",
-	logoDarkBackgroundIdentifier: "dark-background logo",
-	faviconIdentifier: "favicon"
-};
-function hasOwnSettingsField(settings, field) {
-	return hasOwnField(settings, field);
-}
-function hasOwnField(settings, field) {
-	return Object.prototype.hasOwnProperty.call(settings, field);
-}
-function buildSettingsUpdateInput(settings) {
-	const update = {};
-	for (const field of SETTINGS_FIELDS) {
-		if (!hasOwnSettingsField(settings, field)) {
-			continue;
-		}
-		switch (field) {
-			case "siteTitle":
-				update.siteTitle = settings.siteTitle;
-				break;
-			case "homepageId":
-				update.homepageId = settings.homepageId;
-				break;
-			case "seoDefaults":
-				update.seoDefaults = settings.seoDefaults;
-				break;
-			case "logoIdentifier":
-				update.logoIdentifier = settings.logoIdentifier;
-				break;
-			case "logoDarkBackgroundIdentifier":
-				update.logoDarkBackgroundIdentifier = settings.logoDarkBackgroundIdentifier;
-				break;
-			case "faviconIdentifier":
-				update.faviconIdentifier = settings.faviconIdentifier;
-				break;
-		}
-	}
-	return update;
-}
-function applySettingsBrandingPullResolutions(baseSettings, resolutions) {
-	const settings = {
-		homepageId: baseSettings.homepageId,
-		seoDefaults: baseSettings.seoDefaults
-	};
-	const warnings = [];
-	for (const resolution of resolutions) {
-		switch (resolution.kind) {
-			case "resolved":
-				settings[resolution.field] = resolution.identifier;
-				break;
-			case "missing":
-				settings[resolution.field] = null;
-				break;
-			case "unresolved":
-				warnings.push(`Remote ${SETTINGS_BRANDING_LABELS[resolution.field]} asset ` + `"${resolution.assetId}" has no media identifier, so ${resolution.field} was omitted from content/settings.json.`);
-				break;
-		}
-	}
-	return {
-		settings,
-		warnings
-	};
-}
-function getSettingsBrandingLabel(field) {
-	return SETTINGS_BRANDING_LABELS[field];
-}
-function collectSettingsBrandingIdentifiers(settings) {
-	if (!settings) {
-		return [];
-	}
-	const identifiers = [];
-	for (const field of SETTINGS_BRANDING_FIELDS) {
-		const identifier = settings[field];
-		if (typeof identifier === "string" && identifier) {
-			identifiers.push({
-				field,
-				identifier
-			});
-		}
-	}
-	return identifiers;
-}
-function isImageMimeType(mimeType) {
-	return typeof mimeType === "string" && mimeType.startsWith("image/");
-}
-
-//#endregion
-//#region src/sync/media.ts
-/**
-* Media Sync Helper
-*
-* Handles syncing media assets between environments during pull/push operations.
-*
-* With relative paths, storagePath values in content are like "originals/2024/12/abc.jpg"
-* (without site prefix). The actual files are stored at "sites/{siteId}/originals/...".
-*
-* When syncing:
-* 1. Extract all relative storagePath values from content
-* 2. Download files from source: sites/{sourceSiteId}/{relativePath}
-* 3. Upload files to target: sites/{targetSiteId}/{relativePath}
-*
-* No path rewriting in content data is needed since paths are relative!
-*/
-/**
-* Default retry configuration for network operations.
-*/
-const DEFAULT_RETRY_CONFIG = {
-	maxRetries: 3,
-	baseDelayMs: 1e3,
-	maxDelayMs: 1e4
-};
-/**
-* Sleep for a given number of milliseconds.
-*/
-function sleep(ms) {
-	return new Promise((resolve$2) => setTimeout(resolve$2, ms));
-}
-/**
-* Calculate exponential backoff delay with jitter.
-* @param attempt - Current attempt number (0-indexed)
-* @param baseDelayMs - Base delay in milliseconds
-* @param maxDelayMs - Maximum delay cap
-*/
-function getBackoffDelay(attempt, baseDelayMs, maxDelayMs) {
-	const exponentialDelay = baseDelayMs * Math.pow(2, attempt);
-	const jitter = exponentialDelay * (.75 + Math.random() * .5);
-	return Math.min(jitter, maxDelayMs);
-}
-/**
-* Execute a function with exponential backoff retry.
-* @param fn - Function to execute
-* @param options - Retry options
-*/
-async function withRetry(fn, options = {}) {
-	const { maxRetries, baseDelayMs, maxDelayMs } = {
-		...DEFAULT_RETRY_CONFIG,
-		...options
-	};
-	let lastError;
-	for (let attempt = 0; attempt <= maxRetries; attempt++) {
-		try {
-			return await fn();
-		} catch (error) {
-			lastError = error instanceof Error ? error : new Error(String(error));
-			if (attempt < maxRetries) {
-				const delay = getBackoffDelay(attempt, baseDelayMs, maxDelayMs);
-				options.onRetry?.(attempt + 1, lastError);
-				await sleep(delay);
-			}
-		}
-	}
-	throw lastError;
-}
-/**
-* Extract all unique storagePath values from content data.
-* Recursively walks through objects and arrays to find all media references.
-*/
-function extractMediaPaths(data) {
-	const paths = new Set();
-	walkValueTree(data, "", (value) => {
-		if (!isRecordValue(value)) return;
-		if (typeof value.storagePath === "string" && value.storagePath) {
-			paths.add(value.storagePath);
-		}
-	});
-	return paths;
-}
-/**
-* Extract all unique media identifiers from content data.
-* Recursively walks through objects and arrays to find media references.
-*/
-function extractMediaIdentifiers(data) {
-	const identifiers = new Set();
-	if (isRecordValue(data)) {
-		const rootSettings = isRecordValue(data.settings) ? data.settings : null;
-		for (const { identifier } of collectSettingsBrandingIdentifiers(rootSettings)) {
-			identifiers.add(identifier);
-		}
-	}
-	walkValueTree(data, "", (value) => {
-		if (!isRecordValue(value)) return;
-		if (isMediaValue(value) && value.identifier) {
-			identifiers.add(value.identifier);
-		}
-		if (value.type === "image" && isRecordValue(value.attrs)) {
-			if (typeof value.attrs.identifier === "string" && value.attrs.identifier) {
-				identifiers.add(value.attrs.identifier);
-			}
-		}
-	});
-	return identifiers;
-}
-function buildStorageUrl(supabaseUrl, storagePath, siteId, bucket = "media") {
-	const normalized = normalizeAmbiguousStoragePathForSite(siteId, storagePath);
-	if (!normalized.ok) {
-		return {
-			ok: false,
-			error: {
-				tag: "invalid_storage_path",
-				siteId,
-				storagePath,
-				cause: normalized.error
-			}
-		};
-	}
-	return {
-		ok: true,
-		value: getDirectImageUrlForSiteScopedPath(supabaseUrl, normalized.value.fullPath, bucket)
-	};
-}
-/**
-* File extensions that support Supabase image transforms.
-*/
-const TRANSFORMABLE_EXTENSIONS = [
-	"jpg",
-	"jpeg",
-	"png",
-	"webp",
-	"gif"
-];
-/**
-* Check if a file path is an image that can be transformed by Supabase.
-* @param path - The file path or storage path
-*/
-function isTransformableImage(path$2) {
-	const ext = path$2.split(".").pop()?.toLowerCase();
-	return TRANSFORMABLE_EXTENSIONS.includes(ext ?? "");
-}
-/**
-* Build a URL using Supabase's image transform endpoint.
-* Returns a resized version to avoid exceeding upload size limits.
-*
-* @param supabaseUrl - The Supabase project URL
-* @param storagePath - Relative or site-scoped path within the bucket
-* @param siteId - The site ID context for relative paths
-* @param options - Transform options (width, quality)
-*/
-function buildImageTransformUrl(supabaseUrl, storagePath, siteId, options = {}) {
-	const { width = 1920, quality = 85 } = options;
-	const normalized = normalizeAmbiguousStoragePathForSite(siteId, storagePath);
-	if (!normalized.ok) {
-		return {
-			ok: false,
-			error: {
-				tag: "invalid_storage_path",
-				siteId,
-				storagePath,
-				cause: normalized.error
-			}
-		};
-	}
-	return {
-		ok: true,
-		value: getDirectImageUrlForSiteScopedPath(supabaseUrl, normalized.value.fullPath, "media", {
-			width,
-			quality
-		})
-	};
-}
-/**
-* Download a file from a public Supabase storage URL.
-* Returns the file data as a Buffer, or null if download fails after retries.
-*
-* Uses exponential backoff retry for transient network failures.
-*/
-async function downloadMedia(url, options) {
-	try {
-		return await withRetry(async () => {
-			const response = await fetch(url);
-			if (!response.ok) {
-				if (response.status >= 400 && response.status < 500 && response.status !== 429) {
-					throw new DownloadError(`HTTP ${response.status}`, response.status, false);
-				}
-				throw new DownloadError(`HTTP ${response.status}`, response.status, true);
-			}
-			const contentType = response.headers.get("content-type") ?? "application/octet-stream";
-			const arrayBuffer = await response.arrayBuffer();
-			const data = Buffer.from(arrayBuffer);
-			return {
-				data,
-				contentType
-			};
-		}, {
-			maxRetries: options?.maxRetries ?? DEFAULT_RETRY_CONFIG.maxRetries,
-			onRetry: (attempt, error) => {
-				console.warn(`[media-sync] Retry ${attempt} for ${url}: ${error.message}`);
-			}
-		});
-	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error);
-		console.error(`[media-sync] Download failed after retries: ${url} - ${message}`);
-		return null;
-	}
-}
-/**
-* Custom error for download operations with retryability info.
-*/
-var DownloadError = class extends Error {
-	constructor(message, status, retryable) {
-		super(message);
-		this.status = status;
-		this.retryable = retryable;
-		this.name = "DownloadError";
-	}
-};
-/**
-* Sync media files from source to target environment.
-*
-* With relative paths, content data doesn't need to be modified.
-* We just copy files from source site folder to target site folder.
-*
-* @param content - The content data containing media references
-* @param client - Client for uploading to target environment
-* @param options - Sync options
-* @returns Summary of sync results (content unchanged since paths are relative)
-*/
-async function syncMedia(content, client, options) {
-	const { sourceSupabaseUrl, sourceSiteId, bucket = "media", onProgress } = options;
-	const mediaPaths = extractMediaPaths(content);
-	const total = mediaPaths.size;
-	const results = [];
-	let completed = 0;
-	for (const relativePath of mediaPaths) {
-		const filename = relativePath.split("/").pop() ?? "file";
-		onProgress?.(completed, total, filename);
-		try {
-			const exists = await client.mediaExists(relativePath);
-			if (exists) {
-				results.push({
-					relativePath,
-					success: true,
-					skipped: true
-				});
-				completed++;
-				continue;
-			}
-		} catch {}
-		const urlResult = buildStorageUrl(sourceSupabaseUrl, relativePath, sourceSiteId, bucket);
-		if (!urlResult.ok) {
-			results.push({
-				relativePath,
-				success: false,
-				error: `Invalid media storage path: ${urlResult.error.cause.tag}`
-			});
-			completed++;
-			continue;
-		}
-		const url = urlResult.value;
-		const downloaded = await downloadMedia(url);
-		if (!downloaded) {
-			results.push({
-				relativePath,
-				success: false,
-				error: `Failed to download from ${url}`
-			});
-			completed++;
-			continue;
-		}
-		const uploadResult = await client.uploadMedia({
-			data: downloaded.data,
-			filename,
-			contentType: downloaded.contentType,
-			storagePath: relativePath
-		});
-		if ("error" in uploadResult) {
-			results.push({
-				relativePath,
-				success: false,
-				error: uploadResult.error
-			});
-		} else {
-			results.push({
-				relativePath,
-				success: true
-			});
-		}
-		completed++;
-	}
-	onProgress?.(total, total, "complete");
-	const summary = {
-		total,
-		synced: results.filter((r) => r.success && !r.skipped).length,
-		skipped: results.filter((r) => r.skipped).length,
-		failed: results.filter((r) => !r.success).length,
-		results
-	};
-	return {
-		summary,
-		content
-	};
-}
-
-//#endregion
-//#region src/media/identifiers.ts
-const walkContentMedia = (content, handler) => {
-	const visit = (value, location) => {
-		if (isMediaValue(value)) {
-			handler(value, location);
-		}
-	};
-	for (const [contentType, entries] of content.entries) {
-		for (const entry of entries) {
-			walkValueTree(entry.data, `entries.${contentType}.${entry.identifier}.data`, visit);
-			for (const [slotKey, blocks] of Object.entries(entry.blocks ?? {})) {
-				for (const block of blocks) {
-					walkValueTree(block.content, `entries.${contentType}.${entry.identifier}.blocks.${slotKey}.${block.identifier ?? "unidentified"}.content`, visit);
-				}
-			}
-		}
-	}
-	for (const page of content.pages) {
-		for (const block of page.blocks ?? []) {
-			walkValueTree(block.data, `pages.${page.identifier}.blocks.${block.identifier}.data`, visit);
-		}
-	}
-	walkValueTree(content.navigation, "navigation", visit);
-	for (const { field, identifier } of collectSettingsBrandingIdentifiers(content.settings)) {
-		handler({
-			type: "image",
-			identifier
-		}, `settings.${field}`);
-	}
-	walkValueTree(content.settings, "settings", visit);
-	walkValueTree(content.forms, "forms", visit);
-	walkValueTree(content.footer, "footer", visit);
-	walkValueTree(content.venues, "venues", visit);
-	walkValueTree(content.eventCategories, "eventCategories", visit);
-	for (const event of content.events ?? []) {
-		walkValueTree(event, `events.${event.identifier}`, visit);
-	}
-};
-const localContentSections = (content) => ({
-	entries: content.entries?.entries() ?? [],
-	pages: content.pages ?? [],
-	navigation: content.navigation,
-	settings: content.settings,
-	forms: content.forms,
-	footer: content.footer,
-	venues: content.venues,
-	eventCategories: content.eventCategories,
-	events: content.events
-});
-const pulledContentSections = (content) => ({
-	entries: Object.entries(content.entries),
-	pages: content.pages,
-	navigation: content.navigation,
-	settings: content.settings,
-	forms: content.forms,
-	venues: content.venues,
-	eventCategories: content.eventCategories,
-	events: content.events
-});
-const walkLocalContentMedia = (content, handler) => {
-	walkContentMedia(localContentSections(content), handler);
-};
-const walkPulledContentMedia = (content, handler) => {
-	walkContentMedia(pulledContentSections(content), handler);
-};
-
-//#endregion
-//#region src/media/value-utils.ts
-/**
-* Normalize a media identifier to the canonical slug form.
-* Returns null when the raw value is empty or invalid.
-*/
-const normalizeMediaIdentifierInput = (raw) => {
-	if (!raw) return null;
-	const trimmed = raw.trim();
-	if (!trimmed) return null;
-	if (/[./\\]/.test(trimmed)) {
-		return null;
-	}
-	const normalized = slugifyMediaIdentifier(trimmed);
-	return normalized || null;
-};
-/**
-* Normalize a media value to the portable identifier-only representation.
-*
-* Returns a new media value by:
-* - setting `identifier` (required)
-* - removing env-specific fields (`assetId`, `storagePath`, `storageBucket`, `src`, `mimeType`)
-*/
-const normalizeMediaValueToIdentifierOnly = (value, identifier, asset) => {
-	const normalized = {
-		...value,
-		identifier
-	};
-	delete normalized.assetId;
-	delete normalized.storageBucket;
-	delete normalized.storagePath;
-	delete normalized.mimeType;
-	delete normalized.src;
-	if (asset) {
-		applyAuthoritativeDimension(normalized, "width", asset.width);
-		applyAuthoritativeDimension(normalized, "height", asset.height);
-	}
-	return normalized;
-};
-function applyAuthoritativeDimension(value, key, dimension) {
-	if (dimension === null || dimension === undefined) {
-		delete value[key];
-		return;
-	}
-	value[key] = dimension;
-}
-
-//#endregion
-//#region src/media/rich-text.ts
-const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-/**
-* Walk any JSON-like payload and collect TipTap rich text image node attrs.
-*
-* TipTap nodes look like: { type: 'image', attrs: { src?: string, identifier?: string, ... } }
-*/
-function collectRichTextImageAttrs(value, out = [], location = "") {
-	if (Array.isArray(value)) {
-		value.forEach((child, index) => collectRichTextImageAttrs(child, out, `${location}[${index}]`));
-		return out;
-	}
-	if (!isRecord(value)) return out;
-	if (value.type === "image" && isRecord(value.attrs)) {
-		out.push({
-			attrs: value.attrs,
-			location: location ? `${location}.attrs` : "attrs"
-		});
-	}
-	for (const [key, child] of Object.entries(value)) {
-		const next = location ? `${location}.${key}` : key;
-		collectRichTextImageAttrs(child, out, next);
-	}
-	return out;
-}
-
-//#endregion
-//#region src/media/pull-manifest.ts
-const buildLocalFilename = (identifier, asset) => {
-	const extensionFromFilename = path$1.extname(asset.filename ?? "");
-	const extension = extensionFromFilename || getExtensionForMimeType(asset.mimeType) || "";
-	return extension ? `${identifier}${extension}` : identifier;
-};
-const updateManifestEntry = (manifest, identifier, asset, localFile) => {
-	const previous = manifest.assets[identifier];
-	const filename = localFile?.filename ?? previous?.filename ?? buildLocalFilename(identifier, asset);
-	const checksum = localFile?.checksum ?? asset.checksumSha256 ?? previous?.checksum;
-	const mimeType = localFile?.mimeType ?? asset.mimeType ?? previous?.mimeType;
-	const entry = {
-		checksum,
-		filename,
-		mimeType
-	};
-	manifest.assets[identifier] = entry;
-};
-const normalizeStoragePath = (storagePath, siteId) => {
-	const prefix = `sites/${siteId}/`;
-	if (storagePath.startsWith(prefix)) {
-		return storagePath.slice(prefix.length);
-	}
-	return storagePath;
-};
-
-//#endregion
-//#region src/media/push-preparation-plan.ts
-const cloneLocalFile = (file) => ({
-	identifier: file.identifier,
-	filename: file.filename,
-	filePath: file.filePath,
-	mimeType: file.mimeType,
-	checksum: file.checksum,
-	dataBase64: Buffer.from(file.data).toString("base64"),
-	dataLength: file.data.length
-});
-const collectLocalMediaReferences = (content) => {
-	const mediaReferences = [];
-	const richTextReferences = [];
-	const warnings = [];
-	const errors = [];
-	const locationsByIdentifier = new Map();
-	walkLocalContentMedia(content, (value, location) => {
-		const rawIdentifier = typeof value.identifier === "string" ? value.identifier : "";
-		const hasLegacyRef = Boolean(value.assetId || value.storagePath || value.src);
-		if (!rawIdentifier) {
-			if (hasLegacyRef) {
-				errors.push(`Media reference at ${location} is missing identifier.`);
-			}
-			return;
-		}
-		if (/[./\\]/.test(rawIdentifier)) {
-			errors.push(`Media identifier "${rawIdentifier}" at ${location} must not include an extension.`);
-			return;
-		}
-		const normalized = normalizeMediaIdentifierInput(rawIdentifier);
-		if (!normalized) {
-			errors.push(`Media identifier "${rawIdentifier}" at ${location} is invalid.`);
-			return;
-		}
-		if (normalized !== rawIdentifier) {
-			warnings.push(`Normalized media identifier "${rawIdentifier}" to "${normalized}" at ${location}.`);
-			value.identifier = normalized;
-		}
-		mediaReferences.push({
-			identifier: normalized,
-			rawIdentifier,
-			value,
-			location
-		});
-		const locations = locationsByIdentifier.get(normalized) ?? [];
-		locations.push(location);
-		locationsByIdentifier.set(normalized, locations);
-	});
-	for (const node of collectRichTextImageAttrs(content)) {
-		const attrs = node.attrs;
-		const rawIdentifier = typeof attrs.identifier === "string" ? attrs.identifier : "";
-		const rawSrc = typeof attrs.src === "string" ? attrs.src : "";
-		if (!rawIdentifier) {
-			if (rawSrc) {
-				errors.push(`Rich text image at ${node.location} is missing identifier.`);
-			}
-			continue;
-		}
-		if (/[./\\]/.test(rawIdentifier)) {
-			errors.push(`Rich text image identifier "${rawIdentifier}" at ${node.location} must not include an extension.`);
-			continue;
-		}
-		const normalized = normalizeMediaIdentifierInput(rawIdentifier);
-		if (!normalized) {
-			errors.push(`Rich text image identifier "${rawIdentifier}" at ${node.location} is invalid.`);
-			continue;
-		}
-		if (normalized !== rawIdentifier) {
-			warnings.push(`Normalized rich text image identifier "${rawIdentifier}" to "${normalized}" at ${node.location}.`);
-			attrs.identifier = normalized;
-		}
-		delete attrs.src;
-		richTextReferences.push({
-			identifier: normalized,
-			rawIdentifier,
-			attrs,
-			location: node.location
-		});
-		const locations = locationsByIdentifier.get(normalized) ?? [];
-		locations.push(node.location);
-		locationsByIdentifier.set(normalized, locations);
-	}
-	return {
-		mediaReferences,
-		richTextReferences,
-		warnings,
-		errors,
-		locationsByIdentifier
-	};
-};
-const buildLocationNote = (locationsByIdentifier, identifier) => {
-	const locations = locationsByIdentifier.get(identifier);
-	return locations?.length ? ` Referenced at: ${locations.join(", ")}.` : "";
-};
-const locationsForIdentifier = (locationsByIdentifier, identifier) => locationsByIdentifier.get(identifier) ?? [];
-const operationPriority = (operation) => {
-	switch (operation.kind) {
-		case "upload": return 0;
-		case "conflict":
-		case "missing_local_file":
-		case "reused":
-		case "skipped":
-		case "unchanged": return 1;
-	}
-};
-const sortOperations = (operations) => operations.slice().sort((a, b) => {
-	const byIdentifier = a.identifier.localeCompare(b.identifier);
-	return byIdentifier || operationPriority(a) - operationPriority(b);
-});
-const emptyPushSummary = (totalReferences, identifiers) => ({
-	totalReferences,
-	identifiers,
-	resolved: 0,
-	reused: 0,
-	uploaded: 0,
-	skipped: 0,
-	pendingUploads: 0
-});
-const stableAssetList = (assets) => assets.slice().sort((a, b) => a.id.localeCompare(b.id)).map((asset) => ({ ...asset }));
-const stableMediaReadSet = (observations) => stableStringify(observations.slice().sort((a, b) => a.identifier.localeCompare(b.identifier)).map((observation) => ({
-	identifier: observation.identifier,
-	localChecksum: observation.localChecksum.kind === "present" && observation.localChecksum.lookup.kind === "read" ? {
-		...observation.localChecksum,
-		lookup: {
-			...observation.localChecksum.lookup,
-			assets: stableAssetList(observation.localChecksum.lookup.assets)
-		}
-	} : observation.localChecksum,
-	resolvedAsset: observation.resolvedAsset,
-	missing: observation.missing
-})));
-const buildMediaReadSet = (options) => options.identifiers.map((identifier) => {
-	const checksum = options.localChecksums.get(identifier);
-	const resolvedAsset = options.initialAssets.get(identifier);
-	const localChecksum = checksum === undefined ? { kind: "missing" } : {
-		kind: "present",
-		checksum,
-		lookup: options.checksumAssetsByChecksum.has(checksum) ? {
-			kind: "read",
-			assets: stableAssetList(options.checksumAssetsByChecksum.get(checksum) ?? [])
-		} : { kind: "not-read" }
-	};
-	return {
-		identifier,
-		localChecksum,
-		resolvedAsset: resolvedAsset ? { ...resolvedAsset } : null,
-		missing: options.initialMissing.has(identifier)
-	};
-});
-const localFileForOperation = (localFile) => ({
-	filename: localFile.filename,
-	checksum: localFile.checksum,
-	mimeType: localFile.mimeType
-});
-const classifyExistingAsset = (options, hasConflict) => {
-	const { identifier, asset, localFile, locations, locationNote } = options;
-	if (asset && !localFile) {
-		return {
-			operations: [{
-				kind: "skipped",
-				identifier,
-				locations,
-				message: "Using existing CMS asset because no local file was found."
-			}],
-			warnings: [`Missing local file for "${identifier}". Using CMS asset instead.${locationNote}`],
-			errors: []
-		};
-	}
-	if (hasConflict && asset) {
-		const message = `Identifier "${identifier}" points to a different file on the CMS. Delete the existing asset first or rename your local identifier.`;
-		return {
-			operations: [{
-				kind: "conflict",
-				identifier,
-				locations,
-				message
-			}],
-			errors: [`${message}${locationNote}`]
-		};
-	}
-	if (asset && localFile && !hasConflict) {
-		return {
-			operations: [{
-				kind: "unchanged",
-				identifier,
-				asset: { ...asset },
-				file: cloneLocalFile(localFile),
-				locations
-			}],
-			manifestAsset: asset,
-			manifestFile: localFileForOperation(localFile),
-			errors: []
-		};
-	}
-	return undefined;
-};
-const classifySingularChecksumMatch = (options) => {
-	const { identifier, localFile, locations, initialOperations } = options;
-	const exact = options.checksumMatches.find((candidate) => candidate.identifier === identifier);
-	if (exact) {
-		return {
-			operations: [...initialOperations, {
-				kind: "reused",
-				identifier,
-				asset: { ...exact },
-				file: cloneLocalFile(localFile),
-				locations
-			}],
-			manifestAsset: exact,
-			manifestFile: localFileForOperation(localFile),
-			errors: []
-		};
-	}
-	return undefined;
-};
-const classifyChecksumMatches = (options) => {
-	const { identifier, localFile, checksumMatches, locations, initialOperations, locationNote } = options;
-	const singular = classifySingularChecksumMatch(options);
-	if (singular) return singular;
-	if (checksumMatches.length > 0) {
-		const identifiers = checksumMatches.map((asset) => asset.identifier).join(", ");
-		const message = `The same media bytes already exist under ${identifiers}; use that identifier or delete the existing asset first.`;
-		return {
-			operations: [...initialOperations, {
-				kind: "conflict",
-				identifier,
-				locations,
-				message
-			}],
-			errors: [`${message}${locationNote}`]
-		};
-	}
-	return {
-		operations: [...initialOperations, {
-			kind: "upload",
-			identifier,
-			file: cloneLocalFile(localFile),
-			source: "local_file",
-			locations
-		}],
-		errors: []
-	};
-};
-const classifyMissingReference = (options) => {
-	const { identifier, localFile, locationNote, initialOperations, locations } = options;
-	if (!localFile) {
-		const message = `Add content/media/${identifier}.* or pull with --local-media first.`;
-		return {
-			operations: [...initialOperations, {
-				kind: "missing_local_file",
-				identifier,
-				locations,
-				message
-			}],
-			errors: [`Identifier "${identifier}" does not exist on the CMS and no local file was found. ${message}${locationNote}`]
-		};
-	}
-	return classifyChecksumMatches({
-		identifier,
-		localFile,
-		checksumMatches: options.checksumMatches,
-		locations,
-		initialOperations,
-		locationNote
-	});
-};
-const classifyLocalMediaReference = (options) => {
-	const { asset, localFile, missing, locations } = options;
-	const hasConflict = Boolean(asset && localFile && asset.checksumSha256 && asset.checksumSha256 !== localFile.checksum);
-	const existing = classifyExistingAsset(options, hasConflict);
-	if (existing) return existing;
-	const initialOperations = [];
-	if (!missing && !hasConflict) return {
-		operations: initialOperations,
-		errors: []
-	};
-	return classifyMissingReference({
-		identifier: options.identifier,
-		localFile,
-		checksumMatches: options.checksumMatches,
-		locations,
-		initialOperations,
-		locationNote: options.locationNote
-	});
-};
-const applyManifestClassification = (manifest, identifier, classification) => {
-	if (classification.manifestAsset) {
-		updateManifestEntry(manifest, identifier, classification.manifestAsset, classification.manifestFile);
-	}
-};
-
-//#endregion
-//#region src/utils/checksum.ts
-function sha256(buffer) {
-	return createHash("sha256").update(buffer).digest("hex");
-}
-
-//#endregion
-//#region src/files/stable-binary-file.ts
-function isNodeError(error) {
-	return error instanceof Error && "code" in error;
-}
-function observationsMatch(left, right) {
-	return left.dev === right.dev && left.ino === right.ino && left.size === right.size && left.mtimeMs === right.mtimeMs && left.ctimeMs === right.ctimeMs;
-}
-function admitStableBinaryRead(stats, maxBytes) {
-	if (!stats.isFile()) return err({ tag: "not_a_regular_file" });
-	return stats.size > maxBytes ? err({
-		tag: "file_too_large",
-		maxBytes,
-		actualBytes: stats.size
-	}) : ok(undefined);
-}
-function mapStableBinaryReadFailure(error) {
-	if (!isNodeError(error)) return { tag: "read_failed" };
-	if (error.code === "ENOENT") return { tag: "file_not_found" };
-	return error.code === "ELOOP" || error.code === "EISDIR" ? { tag: "not_a_regular_file" } : { tag: "read_failed" };
-}
-async function readObservedByteLength(handle, byteLength) {
-	const data = Buffer.allocUnsafe(byteLength);
-	let offset = 0;
-	while (offset < byteLength) {
-		const read = await handle.read(data, offset, byteLength - offset, offset);
-		if (read.bytesRead === 0) return null;
-		offset += read.bytesRead;
-	}
-	const growthProbe = Buffer.allocUnsafe(1);
-	const extra = await handle.read(growthProbe, 0, 1, byteLength);
-	return extra.bytesRead === 0 ? data : null;
-}
-async function readStableBinaryFile(filePath, maxBytes) {
-	let handle;
-	try {
-		const noFollow = constants.O_NOFOLLOW ?? 0;
-		handle = await open(filePath, constants.O_RDONLY | noFollow);
-		const before = await handle.stat();
-		const admission = admitStableBinaryRead(before, maxBytes);
-		if (!admission.ok) return admission;
-		const data = await readObservedByteLength(handle, before.size);
-		const after = await handle.stat();
-		if (data === null || !observationsMatch(before, after)) {
-			return err({ tag: "file_changed_during_read" });
-		}
-		return ok(data);
-	} catch (error) {
-		return err(mapStableBinaryReadFailure(error));
-	} finally {
-		await handle?.close().catch(() => undefined);
-	}
-}
-async function inspectDestination(filePath, overwrite) {
-	try {
-		const stats = await lstat(filePath);
-		if (overwrite === "refuse") return err({ tag: "destination_exists" });
-		return stats.isFile() ? ok(undefined) : err({ tag: "unsafe_destination" });
-	} catch (error) {
-		if (isNodeError(error) && error.code === "ENOENT") return ok(undefined);
-		return err({ tag: "write_failed" });
-	}
-}
-/**
-* Admit an output path before a remote operation while preserving the atomic
-* writer's second check at finalization time to close the race window.
-*/
-async function admitBinaryWriteDestination(filePath, overwrite) {
-	const destination = await inspectDestination(filePath, overwrite);
-	if (!destination.ok) return destination;
-	try {
-		const parent = dirname$1(filePath);
-		const parentStats = await lstat(parent);
-		if (!parentStats.isDirectory()) return err({ tag: "unsafe_destination" });
-		await access(parent, constants.W_OK);
-		return ok(undefined);
-	} catch {
-		return err({ tag: "write_failed" });
-	}
-}
-async function syncDirectory(directory) {
-	if (process.platform === "win32") return true;
-	let handle;
-	try {
-		handle = await open(directory, "r");
-		await handle.sync();
-		return true;
-	} catch {
-		return false;
-	} finally {
-		await handle?.close().catch(() => undefined);
-	}
-}
-function mapAtomicBinaryWriteFailure(error) {
-	return isNodeError(error) && (error.code === "ELOOP" || error.code === "EISDIR" || error.code === "ENOTDIR") ? { tag: "unsafe_destination" } : { tag: "write_failed" };
-}
-async function writeTemporaryBinaryFile(temporaryPath, data, mode) {
-	let handle;
-	try {
-		handle = await open(temporaryPath, "wx", mode);
-		await handle.writeFile(data);
-		await handle.sync();
-		await handle.close();
-		handle = undefined;
-		await chmod(temporaryPath, mode);
-	} finally {
-		await handle?.close().catch(() => undefined);
-	}
-}
-async function finalizeTemporaryBinaryFile(temporaryPath, filePath, overwrite) {
-	if (overwrite === "allow") {
-		await rename(temporaryPath, filePath);
-		return ok([]);
-	}
-	try {
-		await link(temporaryPath, filePath);
-	} catch (error) {
-		return isNodeError(error) && error.code === "EEXIST" ? err({ tag: "destination_exists" }) : err(mapAtomicBinaryWriteFailure(error));
-	}
-	try {
-		await unlink$1(temporaryPath);
-		return ok([]);
-	} catch {
-		return ok([{
-			tag: "temporary_cleanup_failed",
-			temporaryPath
-		}]);
-	}
-}
-function toAtomicBinaryWriteOutcome(warnings) {
-	const [first, ...rest] = warnings;
-	return first === undefined ? { tag: "written" } : {
-		tag: "written_with_warnings",
-		warnings: [first, ...rest]
-	};
-}
-async function writeBinaryFileAtomic(filePath, data, options) {
-	const parent = dirname$1(filePath);
-	const mode = options.mode ?? 384;
-	const suffix = options.randomSuffix ?? (() => `${process.pid}-${Date.now()}-${randomUUID()}`);
-	let temporaryPath;
-	try {
-		if (options.ensureParent === true) await mkdir(parent, { recursive: true });
-		const admitted = await inspectDestination(filePath, options.overwrite);
-		if (!admitted.ok) return admitted;
-		temporaryPath = join(parent, `.${basename(filePath)}.${suffix()}.tmp`);
-		await writeTemporaryBinaryFile(temporaryPath, data, mode);
-		const finalized = await finalizeTemporaryBinaryFile(temporaryPath, filePath, options.overwrite);
-		if (!finalized.ok) return finalized;
-		temporaryPath = undefined;
-		const warnings = await syncDirectory(parent) ? finalized.value : [...finalized.value, { tag: "directory_sync_failed" }];
-		return ok(toAtomicBinaryWriteOutcome(warnings));
-	} catch (error) {
-		return err(mapAtomicBinaryWriteFailure(error));
-	} finally {
-		if (temporaryPath) await unlink$1(temporaryPath).catch(() => undefined);
-	}
-}
-
-//#endregion
-//#region src/media/local-media.ts
-const MEDIA_DIR_NAME = "media";
-const fileExists = async (filePath) => {
-	try {
-		await fs$1.access(filePath);
-		return true;
-	} catch {
-		return false;
-	}
-};
-const listMediaDirFiles = async (mediaDir) => {
-	try {
-		return await fs$1.readdir(mediaDir);
-	} catch (error) {
-		const nodeError = error;
-		if (nodeError.code === "ENOENT") return [];
-		throw error;
-	}
-};
-const findMatchingFilename = async (contentDir, identifier, manifest) => {
-	const mediaDir = path$1.join(contentDir, MEDIA_DIR_NAME);
-	const manifestEntry = manifest.assets[identifier];
-	if (manifestEntry?.filename) {
-		const candidatePath = path$1.join(mediaDir, manifestEntry.filename);
-		if (await fileExists(candidatePath)) {
-			return manifestEntry.filename;
-		}
-	}
-	const files = await listMediaDirFiles(mediaDir);
-	const matches = files.filter((name) => {
-		if (name.startsWith(".")) return false;
-		const parsed = path$1.parse(name);
-		return parsed.name === identifier;
-	});
-	if (matches.length > 1) {
-		throw new Error(`Multiple media files match identifier "${identifier}": ${matches.join(", ")}`);
-	}
-	return matches[0] ?? null;
-};
-async function loadLocalMediaFile(contentDir, identifier, manifest) {
-	const filename = await findMatchingFilename(contentDir, identifier, manifest);
-	if (!filename) return null;
-	const mediaDir = path$1.join(contentDir, MEDIA_DIR_NAME);
-	const filePath = path$1.join(mediaDir, filename);
-	const read = await readStableBinaryFile(filePath, MAX_MANAGEMENT_MEDIA_UPLOAD_BYTES);
-	if (!read.ok) {
-		throw new Error(`Failed to read media file ${filePath}: ${read.error.tag}`);
-	}
-	const data = read.value;
-	const checksum = sha256(data);
-	const mimeType = getMimeType(filename);
-	manifest.assets[identifier] = {
-		...manifest.assets[identifier],
-		filename,
-		checksum,
-		mimeType
-	};
-	return {
-		identifier,
-		filename,
-		filePath,
-		mimeType,
-		checksum,
-		data
-	};
-}
-async function writeLocalMediaFile(contentDir, filename, data) {
-	const mediaDir = path$1.join(contentDir, MEDIA_DIR_NAME);
-	await fs$1.mkdir(mediaDir, { recursive: true });
-	const filePath = path$1.join(mediaDir, filename);
-	const written = await writeBinaryFileAtomic(filePath, data, {
-		overwrite: "allow",
-		mode: 420
-	});
-	if (!written.ok) {
-		throw new Error(`Failed to write media file ${filePath}: ${written.error.tag}`);
-	}
-	return written.value.tag === "written" ? {
-		kind: "written",
-		filePath
-	} : {
-		kind: "written_with_warnings",
-		filePath,
-		warnings: written.value.warnings
-	};
-}
-async function readLocalMediaChecksum(filePath, maxBytes) {
-	const read = await readStableBinaryFile(filePath, maxBytes);
-	if (!read.ok) {
-		throw new Error(`Failed to read media file ${filePath}: ${read.error.tag}`);
-	}
-	return sha256(read.value);
-}
-async function localMediaFileExists(filePath) {
-	return fileExists(filePath);
-}
-
-//#endregion
-//#region src/media/pull-naming.ts
-const GENERIC_MEDIA_NAMES = new Set([
-	"image",
-	"photo",
-	"picture",
-	"pic",
-	"img",
-	"media",
-	"file"
-]);
-const buildIdentifierBaseFromLocation = (location) => {
-	const parts = location.split(".");
-	if (parts.length < 2) return null;
-	if (parts[0] === "entries") {
-		const contentType = parts[1];
-		const entryIdentifier = parts[2];
-		const dataIndex = parts.indexOf("data");
-		const fieldName = dataIndex >= 0 ? parts[dataIndex + 1] : "media";
-		if (contentType && entryIdentifier && fieldName) {
-			return `${contentType}-${entryIdentifier}-${fieldName}`;
-		}
-	}
-	if (parts[0] === "pages") {
-		const pageIdentifier = parts[1];
-		const blockIndex = parts.indexOf("blocks");
-		const blockIdentifier = blockIndex >= 0 ? parts[blockIndex + 1] : null;
-		const dataIndex = parts.indexOf("data");
-		const fieldName = dataIndex >= 0 ? parts[dataIndex + 1] : "media";
-		if (pageIdentifier && blockIdentifier && fieldName) {
-			return `${pageIdentifier}-${blockIdentifier}-${fieldName}`;
-		}
-		if (pageIdentifier && fieldName) {
-			return `${pageIdentifier}-${fieldName}`;
-		}
-	}
-	return null;
-};
-const chooseIdentifierBase = (location, asset) => {
-	const baseFromFilename = buildMediaIdentifierFromFilename(asset.filename ?? "");
-	const baseFromContext = buildIdentifierBaseFromLocation(location);
-	if (baseFromFilename && !GENERIC_MEDIA_NAMES.has(baseFromFilename)) {
-		return baseFromFilename;
-	}
-	return baseFromContext || baseFromFilename || "media";
-};
-const allocateIdentifier = (base, existingIdentifiers) => resolveMediaIdentifier(base, existingIdentifiers);
-const parseFilenameFromUrl = (src) => {
-	try {
-		const url = new URL(src);
-		const raw = url.pathname.split("/").filter(Boolean).pop() ?? "";
-		const decoded = raw ? decodeURIComponent(raw) : "";
-		const trimmed = decoded.trim();
-		return trimmed.length > 0 ? trimmed : null;
-	} catch {
-		return null;
-	}
-};
-const ensureFilenameExtension = (filename, mimeType) => {
-	if (path$1.extname(filename)) return filename;
-	const ext = getExtensionForMimeType(mimeType);
-	return ext ? `${filename}${ext}` : filename;
-};
-const chooseRichTextIdentifierBase = (location, src) => {
-	const filename = parseFilenameFromUrl(src) ?? "";
-	const baseFromFilename = filename ? buildMediaIdentifierFromFilename(filename) : null;
-	const baseFromContext = buildIdentifierBaseFromLocation(location);
-	const base = baseFromFilename && !GENERIC_MEDIA_NAMES.has(baseFromFilename) ? baseFromFilename : baseFromContext || baseFromFilename || "rich-text-image";
-	return `${base}-rt`;
-};
-
-//#endregion
-//#region src/media/push-preparation-reads.ts
-const readMediaManifestAndLocalFiles = async (options) => {
-	const manifest = options.manifest ?? await readMediaManifest(options.contentDir);
-	const errors = [];
-	const localFiles = new Map();
-	for (const identifier of options.identifiers) {
-		try {
-			const localFile = await loadLocalMediaFile(options.contentDir, identifier, manifest);
-			localFiles.set(identifier, localFile);
-		} catch (error) {
-			const message = error instanceof Error ? error.message : String(error);
-			errors.push(`Failed to load media file for "${identifier}": ${message}`);
-			localFiles.set(identifier, null);
-		}
-	}
-	return {
-		manifest,
-		localFiles,
-		errors
-	};
-};
-const resolveMediaAssets = async (client, identifiers) => {
-	const resolved = await client.media.resolve({ identifiers: [...identifiers] });
-	const assetsByIdentifier = new Map();
-	for (const asset of resolved.assets) {
-		if (asset.identifier) assetsByIdentifier.set(asset.identifier, asset);
-	}
-	return {
-		assetsByIdentifier,
-		missingIdentifiers: new Set(resolved.missingIdentifiers)
-	};
-};
-const readChecksumMatches = async (options) => {
-	const matchesByChecksum = new Map();
-	for (const identifier of options.identifiers) {
-		if (options.preparedIdentifiers.has(identifier)) continue;
-		const localFile = options.localFiles.get(identifier);
-		const asset = options.assetsByIdentifier.get(identifier);
-		const hasConflict = Boolean(asset && localFile && asset.checksumSha256 && asset.checksumSha256 !== localFile.checksum);
-		if (hasConflict) continue;
-		if (!localFile || !options.missingIdentifiers.has(identifier) && !hasConflict) {
-			continue;
-		}
-		const matches = (await options.client.media.findByChecksum([localFile.checksum])).filter((candidate) => candidate.checksumSha256 === localFile.checksum);
-		const stableMatches = matches.slice().sort((a, b) => a.id.localeCompare(b.id)).map((candidate) => ({ ...candidate }));
-		matchesByChecksum.set(localFile.checksum, stableMatches);
-	}
-	return matchesByChecksum;
-};
-const readRichTextImageSource = async (options) => {
-	const downloaded = await downloadMedia(options.source);
-	if (!downloaded) {
-		throw new Error(`Failed to download rich text image from ${options.source}`);
-	}
-	const mimeType = downloaded.contentType.split(";")[0]?.trim() || "application/octet-stream";
-	if (!mimeType.startsWith("image/")) {
-		throw new Error(`Unsupported content-type for rich text image import: ${mimeType}`);
-	}
-	const data = Buffer.from(downloaded.data);
-	const checksum = sha256(data);
-	const checksumMatches = (await options.client.media.findByChecksum([checksum])).filter((candidate) => candidate.checksumSha256 === checksum).slice().sort((a, b) => a.id.localeCompare(b.id)).map((candidate) => ({ ...candidate }));
-	const filename = ensureFilenameExtension(parseFilenameFromUrl(options.source) ?? "image", mimeType);
-	return {
-		location: options.location,
-		attrs: options.attrs,
-		source: options.source,
-		mimeType,
-		checksum,
-		file: cloneLocalFile({
-			identifier: "planned-rich-text-image",
-			filename,
-			filePath: options.source,
-			mimeType,
-			checksum,
-			data
-		}),
-		checksumMatches
-	};
-};
-/**
-* Reads remote rich-text image sources without changing content or CMS state.
-* Identifier allocation and operation selection happen in the pure planner.
-*/
-const readRichTextImageImports = async (options) => {
-	const successful = [];
-	const failures = [];
-	for (const node of collectRichTextImageAttrs(options.content)) {
-		const rawIdentifier = typeof node.attrs.identifier === "string" ? node.attrs.identifier.trim() : "";
-		const source = typeof node.attrs.src === "string" ? node.attrs.src.trim() : "";
-		if (rawIdentifier || !source) continue;
-		try {
-			successful.push(await readRichTextImageSource({
-				client: options.client,
-				location: node.location,
-				attrs: node.attrs,
-				source
-			}));
-		} catch (error) {
-			failures.push({
-				location: node.location,
-				error: error instanceof Error ? error.message : String(error)
-			});
-		}
-	}
-	return {
-		successful,
-		failures
-	};
-};
-const localFileChecksums = (identifiers, localFiles) => new Map(identifiers.map((identifier) => [identifier, localFiles.get(identifier)?.checksum]));
-const cloneAssetMap = (assets) => new Map(Array.from(assets.entries()).map(([identifier, asset]) => [identifier, { ...asset }]));
-const cloneMissingSet = (missing) => new Set(missing);
-
-//#endregion
-//#region src/media/push-rich-text-plan.ts
-const localFileWithIdentifier = (file, identifier) => ({
-	...file,
-	identifier
-});
-const withLocation = (locations, identifier, location) => {
-	const current = locations.get(identifier) ?? [];
-	current.push(location);
-	locations.set(identifier, current);
-};
-const chooseExistingRichTextAsset = (matches) => matches.slice().sort((a, b) => a.createdAt.localeCompare(b.createdAt))[0];
-const normalizeRichTextIdentifiers = (options) => {
-	for (const node of collectRichTextImageAttrs(options.content)) {
-		const attrs = node.attrs;
-		const rawIdentifier = typeof attrs.identifier === "string" ? attrs.identifier.trim() : "";
-		if (!rawIdentifier) continue;
-		const normalized = normalizeMediaIdentifierInput(rawIdentifier);
-		if (!normalized) {
-			options.errors.push(`Rich text image identifier "${rawIdentifier}" at ${node.location} is invalid.`);
-			delete attrs.src;
-			continue;
-		}
-		if (normalized !== rawIdentifier) {
-			options.warnings.push(`Normalized rich text image identifier "${rawIdentifier}" to "${normalized}" at ${node.location}.`);
-		}
-		attrs.identifier = normalized;
-		delete attrs.src;
-		options.existingIdentifiers.add(normalized);
-		withLocation(options.locationsByIdentifier, normalized, node.location);
-	}
-};
-/**
-* Converts already-read rich-text sources into identifier-only content and
-* closed media operations. It performs no filesystem or CMS I/O.
-*/
-const planRichTextImageImports = (options) => {
-	const operations = [];
-	const warnings = [];
-	const errors = options.imports.failures.map((failure) => `Failed to import rich text image @ ${failure.location}: ${failure.error}`);
-	const preparedIdentifiers = new Set();
-	const locationsByIdentifier = new Map();
-	const checksumAssetsByChecksum = new Map();
-	normalizeRichTextIdentifiers({
-		content: options.content,
-		existingIdentifiers: options.existingIdentifiers,
-		warnings,
-		errors,
-		locationsByIdentifier
-	});
-	for (const imported of options.imports.successful) {
-		const attrs = imported.attrs;
-		const matches = imported.checksumMatches;
-		checksumAssetsByChecksum.set(imported.checksum, matches);
-		const existing = chooseExistingRichTextAsset(matches);
-		const planned = existing ? {
-			identifier: existing.identifier,
-			operation: {
-				kind: "unchanged",
-				identifier: existing.identifier,
-				asset: { ...existing },
-				file: localFileWithIdentifier(imported.file, existing.identifier),
-				locations: [imported.location]
-			}
-		} : (() => {
-			const base = chooseRichTextIdentifierBase(imported.location, imported.source);
-			const identifier = resolveMediaIdentifier(base, options.existingIdentifiers);
-			options.existingIdentifiers.add(identifier);
-			withLocation(locationsByIdentifier, identifier, imported.location);
-			const file = localFileWithIdentifier(imported.file, identifier);
-			return {
-				identifier,
-				operation: {
-					kind: "upload",
-					identifier,
-					file,
-					source: "rich_text",
-					locations: [imported.location]
-				}
-			};
-		})();
-		attrs.identifier = planned.identifier;
-		delete attrs.src;
-		options.existingIdentifiers.add(planned.identifier);
-		preparedIdentifiers.add(planned.identifier);
-		operations.push(planned.operation);
-	}
-	return {
-		operations,
-		errors,
-		warnings,
-		preparedIdentifiers,
-		locationsByIdentifier,
-		checksumAssetsByChecksum
-	};
-};
-
-//#endregion
-//#region src/media/content-normalization.ts
-const normalizeRichTextImage = (node, assetsByIdentifier) => {
-	const attrs = node.attrs;
-	if (!isRecordValue(attrs)) return node;
-	const identifier = typeof attrs.identifier === "string" ? attrs.identifier : "";
-	if (!identifier) return node;
-	const normalizedAttrs = { ...attrs };
-	delete normalizedAttrs.src;
-	const asset = assetsByIdentifier.get(identifier);
-	if (asset) {
-		if (asset.width === null || asset.width === undefined) {
-			delete normalizedAttrs.width;
-		} else {
-			normalizedAttrs.width = asset.width;
-		}
-		if (asset.height === null || asset.height === undefined) {
-			delete normalizedAttrs.height;
-		} else {
-			normalizedAttrs.height = asset.height;
-		}
-	}
-	return {
-		...node,
-		attrs: normalizedAttrs
-	};
-};
-const normalizeValueTree = (value, assetsByIdentifier) => {
-	if (Array.isArray(value)) {
-		return value.map((item) => normalizeValueTree(item, assetsByIdentifier));
-	}
-	if (!isRecordValue(value)) return value;
-	const normalizedChildren = Object.fromEntries(Object.entries(value).map(([key, child]) => [key, normalizeValueTree(child, assetsByIdentifier)]));
-	if (isMediaValue(value) && typeof value.identifier === "string") {
-		return normalizeMediaValueToIdentifierOnly(value, value.identifier, assetsByIdentifier.get(value.identifier));
-	}
-	const normalized = normalizedChildren;
-	if (value.type === "image") {
-		return normalizeRichTextImage(normalized, assetsByIdentifier);
-	}
-	return normalized;
-};
-const normalizeRecord = (value, assetsByIdentifier) => {
-	const normalized = normalizeValueTree(value, assetsByIdentifier);
-	return normalized;
-};
-/**
-* Return local content with media references in the same portable shape that
-* the push diff and command compiler receive. The input is never mutated.
-*/
-const normalizeLocalContentMedia = (content, assetsByIdentifier) => ({
-	...content,
-	entries: new Map(Array.from(content.entries.entries(), ([contentType, entries]) => [contentType, entries.map((entry) => ({
-		...entry,
-		data: normalizeRecord(entry.data, assetsByIdentifier),
-		blocks: entry.blocks ? Object.fromEntries(Object.entries(entry.blocks).map(([slotKey, blocks]) => [slotKey, blocks.map((block) => ({
-			...block,
-			content: normalizeRecord(block.content, assetsByIdentifier)
-		}))])) : entry.blocks
-	}))])),
-	pages: content.pages.map((page) => ({
-		...page,
-		blocks: page.blocks?.map((block) => ({
-			...block,
-			data: normalizeRecord(block.data, assetsByIdentifier)
-		}))
-	})),
-	navigation: normalizeValueTree(content.navigation, assetsByIdentifier),
-	settings: normalizeValueTree(content.settings, assetsByIdentifier),
-	forms: content.forms.map((form) => ({
-		...form,
-		schema: normalizeRecord(form.schema, assetsByIdentifier),
-		settings: normalizeRecord(form.settings, assetsByIdentifier)
-	})),
-	footer: normalizeValueTree(content.footer, assetsByIdentifier),
-	venues: content.venues.map((venue) => normalizeRecord(venue, assetsByIdentifier)),
-	eventCategories: content.eventCategories.map((category) => normalizeRecord(category, assetsByIdentifier)),
-	events: content.events.map((event) => normalizeRecord(event, assetsByIdentifier))
-});
-const addAsset = (assetsByIdentifier, identifier, asset) => {
-	assetsByIdentifier.set(identifier, {
-		...asset,
-		identifier
-	});
-};
-/** Build the CMS asset lookup available while applying a prepared media plan. */
-const assetsForPushMediaPlan = (options) => {
-	const assetsByIdentifier = new Map();
-	const observationsByAssetId = new Map();
-	for (const observation of options.observations) {
-		if (observation.resolvedAsset) {
-			addAsset(assetsByIdentifier, observation.identifier, observation.resolvedAsset);
-			observationsByAssetId.set(observation.resolvedAsset.id, observation.resolvedAsset);
-		}
-		const checksumAssets = observation.localChecksum.kind === "present" && observation.localChecksum.lookup.kind === "read" ? observation.localChecksum.lookup.assets : [];
-		for (const asset of checksumAssets) {
-			observationsByAssetId.set(asset.id, asset);
-		}
-	}
-	for (const operation of options.operations) {
-		if (operation.kind === "unchanged" || operation.kind === "reused") {
-			addAsset(assetsByIdentifier, operation.identifier, operation.asset);
-			continue;
-		}
-	}
-	return assetsByIdentifier;
-};
-
-//#endregion
-//#region src/media/push-preparation.ts
-const cloneLocalContent = (content) => structuredClone(content);
-const collectExistingIdentifiers = (content) => {
-	const identifiers = new Set();
-	walkLocalContentMedia(content, (value) => {
-		if (typeof value.identifier === "string" && value.identifier.trim()) {
-			identifiers.add(value.identifier.trim());
-		}
-	});
-	return identifiers;
-};
-const mergeLocations = (locations, identifier, location) => {
-	const current = locations.get(identifier) ?? [];
-	if (!current.includes(location)) current.push(location);
-	locations.set(identifier, current);
-};
-const mergeRichTextLocations = (locations, additional) => {
-	for (const [identifier, identifierLocations] of additional) {
-		for (const location of identifierLocations) {
-			mergeLocations(locations, identifier, location);
-		}
-	}
-};
-const initialAssetMap = (assetsByIdentifier) => cloneAssetMap(assetsByIdentifier);
-const initialMissingSet = (missingIdentifiers) => cloneMissingSet(missingIdentifiers);
-const appendClassification = (options) => {
-	options.operations.push(...options.classification.operations);
-	options.errors.push(...options.classification.errors);
-	options.warnings.push(...options.classification.warnings ?? []);
-	applyManifestClassification(options.manifest, options.identifier, options.classification);
-};
-const selectPushReferences = (options) => {
-	const collected = collectLocalMediaReferences(options.content);
-	const warnings = [...options.richTextPlan.warnings, ...collected.warnings];
-	const errors = [...options.richTextPlan.errors, ...collected.errors];
-	const locationsByIdentifier = new Map();
-	mergeRichTextLocations(locationsByIdentifier, options.richTextPlan.locationsByIdentifier);
-	mergeRichTextLocations(locationsByIdentifier, collected.locationsByIdentifier);
-	const references = [...collected.mediaReferences.map((reference) => ({
-		identifier: reference.identifier,
-		location: reference.location,
-		richText: false
-	})), ...collected.richTextReferences.map((reference) => ({
-		identifier: reference.identifier,
-		location: reference.location,
-		richText: true
-	}))];
-	for (const reference of references) {
-		mergeLocations(locationsByIdentifier, reference.identifier, reference.location);
-	}
-	const identifiers = Array.from(new Set(references.map((reference) => reference.identifier))).sort();
-	return {
-		references,
-		identifiers,
-		locationsByIdentifier,
-		warnings,
-		errors,
-		summary: emptyPushSummary(references.length, identifiers.length)
-	};
-};
-const prepareLocalReferenceOperations = async (options) => {
-	const loaded = await readMediaManifestAndLocalFiles({
-		contentDir: options.prepare.contentDir,
-		identifiers: options.selection.identifiers,
-		manifest: options.manifest
-	});
-	const errors = [...loaded.errors];
-	const warnings = [];
-	const resolved = await resolveMediaAssets(options.prepare.client, options.selection.identifiers);
-	const initialAssets = initialAssetMap(resolved.assetsByIdentifier);
-	const initialMissing = initialMissingSet(resolved.missingIdentifiers);
-	const checksumMatches = await readChecksumMatches({
-		client: options.prepare.client,
-		identifiers: options.selection.identifiers,
-		localFiles: loaded.localFiles,
-		assetsByIdentifier: resolved.assetsByIdentifier,
-		missingIdentifiers: resolved.missingIdentifiers,
-		preparedIdentifiers: options.richTextPlan.preparedIdentifiers
-	});
-	const operations = [];
-	for (const identifier of options.selection.identifiers) {
-		if (options.richTextPlan.preparedIdentifiers.has(identifier)) continue;
-		const localFile = loaded.localFiles.get(identifier);
-		const classification = classifyLocalMediaReference({
-			identifier,
-			asset: resolved.assetsByIdentifier.get(identifier),
-			localFile,
-			missing: resolved.missingIdentifiers.has(identifier),
-			checksumMatches: localFile ? checksumMatches.get(localFile.checksum) ?? [] : [],
-			locations: locationsForIdentifier(options.selection.locationsByIdentifier, identifier),
-			locationNote: buildLocationNote(options.selection.locationsByIdentifier, identifier)
-		});
-		appendClassification({
-			identifier,
-			classification,
-			manifest: options.manifest,
-			operations,
-			errors,
-			warnings
-		});
-	}
-	const sortedOperations = sortOperations(operations);
-	const localChecksums = localFileChecksums(options.selection.identifiers, loaded.localFiles);
-	for (const operation of sortedOperations) {
-		if ("file" in operation && operation.file) {
-			localChecksums.set(operation.identifier, operation.file.checksum);
-		}
-	}
-	const checksumAssetsByChecksum = new Map(options.richTextPlan.checksumAssetsByChecksum);
-	for (const [checksum, matches] of checksumMatches) {
-		checksumAssetsByChecksum.set(checksum, matches);
-	}
-	return {
-		operations: sortedOperations,
-		errors,
-		warnings,
-		mediaReadSet: buildMediaReadSet({
-			identifiers: options.selection.identifiers,
-			localChecksums,
-			initialAssets,
-			initialMissing,
-			checksumAssetsByChecksum
-		})
-	};
-};
-async function prepareLocalMediaForPush(options) {
-	const content = cloneLocalContent(options.content);
-	const manifest = await readMediaManifest(options.contentDir);
-	const existingIdentifiers = collectExistingIdentifiers(content);
-	const richTextReads = await readRichTextImageImports({
-		content,
-		client: options.client
-	});
-	const richTextPlan = planRichTextImageImports({
-		content,
-		imports: richTextReads,
-		existingIdentifiers
-	});
-	const selection = selectPushReferences({
-		content,
-		richTextPlan
-	});
-	const prepared = selection.identifiers.length > 0 ? await prepareLocalReferenceOperations({
-		prepare: options,
-		manifest,
-		selection,
-		richTextPlan
-	}) : {
-		operations: [],
-		errors: [],
-		warnings: [],
-		mediaReadSet: []
-	};
-	const contentWithPortableMedia = normalizeLocalContentMedia(content, assetsForPushMediaPlan({
-		operations: [...richTextPlan.operations, ...prepared.operations],
-		observations: prepared.mediaReadSet
-	}));
-	return {
-		content: contentWithPortableMedia,
-		manifest,
-		operations: sortOperations([...richTextPlan.operations, ...prepared.operations]),
-		references: selection.references,
-		summary: selection.summary,
-		warnings: [...selection.warnings, ...prepared.warnings],
-		errors: [...selection.errors, ...prepared.errors],
-		targetEnv: options.targetEnv,
-		mediaReadSet: prepared.mediaReadSet
-	};
-}
-
-//#endregion
-//#region src/media/push-failure.ts
-const includesAny = (value, needles) => needles.some((needle) => value.includes(needle));
-const managementErrorRules = [
-	{
-		kind: "max_object_size",
-		matches: (error) => {
-			const code = error.code.toLowerCase();
-			const message = error.message.toLowerCase();
-			return error.statusCode === 413 || code.includes("too_large") || message.includes("too large");
-		}
-	},
-	{
-		kind: "unsupported_mime",
-		matches: (error) => {
-			const code = error.code.toLowerCase();
-			const message = error.message.toLowerCase();
-			return error.statusCode === 415 || includesAny(code, ["mime", "content-type"]) || includesAny(message, ["mime", "content-type"]);
-		}
-	},
-	{
-		kind: "quota_or_storage_limit",
-		matches: (error) => {
-			const code = error.code.toLowerCase();
-			const message = error.message.toLowerCase();
-			return error.statusCode === 402 || error.statusCode === 507 || includesAny(code, ["quota", "storage"]) || includesAny(message, ["quota", "storage limit"]);
-		}
-	},
-	{
-		kind: "auth_or_permission",
-		matches: (error) => {
-			const code = error.code.toLowerCase();
-			return error.statusCode === 401 || error.statusCode === 403 || includesAny(code, ["auth", "permission"]);
-		}
-	},
-	{
-		kind: "network",
-		matches: (error) => {
-			const code = error.code.toLowerCase();
-			return code === "sdk:network-error" || code === "sdk:timeout";
-		}
-	}
-];
-const genericErrorRules = [
-	{
-		kind: "network",
-		matches: (error) => includesAny(error.message.toLowerCase(), [
-			"network",
-			"timeout",
-			"timed out"
-		])
-	},
-	{
-		kind: "max_object_size",
-		matches: (error) => includesAny(error.message.toLowerCase(), [
-			"too large",
-			"payload too large",
-			"413"
-		])
-	},
-	{
-		kind: "unsupported_mime",
-		matches: (error) => includesAny(error.message.toLowerCase(), [
-			"mime",
-			"content-type",
-			"unsupported media"
-		])
-	},
-	{
-		kind: "quota_or_storage_limit",
-		matches: (error) => includesAny(error.message.toLowerCase(), ["quota", "storage limit"])
-	},
-	{
-		kind: "auth_or_permission",
-		matches: (error) => includesAny(error.message.toLowerCase(), [
-			"unauthorized",
-			"forbidden",
-			"permission"
-		])
-	}
-];
-const classifyWithRules = (error, rules) => rules.find((rule) => rule.matches(error))?.kind;
-const classifyManagementApiError = (error) => {
-	const classified = classifyWithRules(error, managementErrorRules);
-	if (classified) return classified;
-	if (error.code.toLowerCase().startsWith("sdk:") || typeof error.statusCode === "number") {
-		return "cms_api";
-	}
-	return "unknown";
-};
-const classifyErrorMessage = (error) => classifyWithRules(error, genericErrorRules) ?? "unknown";
-function classifyLocalMediaUploadFailure(error) {
-	if (error instanceof ManagementApiError) {
-		return classifyManagementApiError(error);
-	}
-	if (error instanceof Error) {
-		return classifyErrorMessage(error);
-	}
-	return "unknown";
-}
-
-//#endregion
-//#region src/media/push-application.ts
-const rawErrorMessage$1 = (error) => error instanceof Error ? error.message : String(error);
-const makeReport = (params) => {
-	const failedIdentifiers = params.items.filter((item) => item.status === "failed").map((item) => item.identifier);
-	const missingIdentifiers = params.items.filter((item) => item.status === "missing_local_file").map((item) => item.identifier);
-	return {
-		targetEnv: params.targetEnv,
-		summary: { ...params.summary },
-		items: params.items,
-		failedIdentifiers,
-		missingIdentifiers
-	};
-};
-const reportForOperation = (operation, status, targetEnv, message, failureKind, rawError) => {
-	const file = "file" in operation ? operation.file : undefined;
-	return {
-		identifier: operation.identifier,
-		status,
-		targetEnv,
-		...file ? {
-			filename: file.filename,
-			sizeBytes: file.dataLength,
-			mimeType: file.mimeType
-		} : {},
-		locations: operation.locations,
-		message,
-		failureKind,
-		rawError
-	};
-};
-const applySimpleMediaOperation = (operation, state, targetEnv) => {
-	switch (operation.kind) {
-		case "unchanged":
-			state.assetsByIdentifier.set(operation.identifier, operation.asset);
-			state.summary.resolved += 1;
-			state.reportItems.push(reportForOperation(operation, "resolved", targetEnv));
-			return;
-		case "reused":
-			state.assetsByIdentifier.set(operation.identifier, operation.asset);
-			state.summary.resolved += 1;
-			state.summary.reused += 1;
-			state.reportItems.push(reportForOperation(operation, "reused", targetEnv, "Reused existing CMS asset with matching identifier and checksum."));
-			return;
-		case "skipped":
-			state.summary.skipped += 1;
-			state.reportItems.push(reportForOperation(operation, "skipped", targetEnv, operation.message));
-			return;
-		case "missing_local_file":
-			state.reportItems.push(reportForOperation(operation, "missing_local_file", targetEnv, operation.message));
-			return;
-		case "conflict":
-			state.reportItems.push(reportForOperation(operation, "failed", targetEnv, operation.message, "unknown"));
-			return;
-		default: return assertNever(operation);
-	}
-};
-const applyUpload = async (operation, context, state) => {
-	const pendingItem = reportForOperation(operation, "pending_upload", context.targetEnv);
-	if (context.dryRun) {
-		state.summary.pendingUploads += 1;
-		state.reportItems.push(pendingItem);
-		return;
-	}
-	context.onEvent?.({
-		type: "upload_started",
-		item: pendingItem
-	});
-	try {
-		const result = await context.client.media.upload({
-			data: Buffer.from(operation.file.dataBase64, "base64"),
-			filename: operation.file.filename,
-			contentType: operation.file.mimeType,
-			identifier: operation.identifier
-		});
-		state.uploadedIdentifiers.push(operation.identifier);
-		if (result.status === "created") state.summary.uploaded += 1;
-		state.summary.resolved += 1;
-		const uploadedItem = reportForOperation(operation, "uploaded", context.targetEnv, result.status === "created" ? "Uploaded local media file." : "CMS reported media already exists.");
-		state.reportItems.push(uploadedItem);
-		context.onEvent?.({
-			type: "upload_succeeded",
-			item: uploadedItem
-		});
-	} catch (error) {
-		const message = rawErrorMessage$1(error);
-		const failedItem = reportForOperation(operation, "failed", context.targetEnv, `Failed to upload "${operation.identifier}": ${message}`, classifyLocalMediaUploadFailure(error), message);
-		state.reportItems.push(failedItem);
-		state.errors.push(`Failed to upload "${operation.identifier}" (${operation.file.filename}, ${operation.file.mimeType}): ${message}`);
-		context.onEvent?.({
-			type: "upload_failed",
-			item: failedItem
-		});
-	}
-};
-const applyMediaOperation = async (operation, context, state) => {
-	switch (operation.kind) {
-		case "unchanged":
-		case "reused":
-		case "skipped":
-		case "missing_local_file":
-		case "conflict":
-			applySimpleMediaOperation(operation, state, context.targetEnv);
-			return;
-		case "upload":
-			await applyUpload(operation, context, state);
-			return;
-		default: return assertNever(operation);
-	}
-};
-const createApplyState = (plan) => ({
-	summary: { ...plan.summary },
-	errors: [...plan.errors],
-	reportItems: [],
-	assetsByIdentifier: new Map(),
-	uploadedIdentifiers: []
-});
-const applyMediaOperations = async (operations, context, state) => {
-	for (const operation of operations) {
-		await applyMediaOperation(operation, context, state);
-	}
-};
-const resolveUploadedAssets = async (state, client, dryRun) => {
-	if (dryRun || state.uploadedIdentifiers.length === 0) return;
-	const resolvedUploads = await client.media.resolve({ identifiers: state.uploadedIdentifiers });
-	for (const asset of resolvedUploads.assets) {
-		if (asset.identifier) {
-			state.assetsByIdentifier.set(asset.identifier, asset);
-		}
-	}
-	for (const missing of resolvedUploads.missingIdentifiers) {
-		state.errors.push(`Upload succeeded but identifier "${missing}" was not found on the CMS.`);
-	}
-};
-const fileByIdentifier = (operations) => {
-	const files = new Map();
-	for (const operation of operations) {
-		if ("file" in operation && !files.has(operation.identifier)) {
-			files.set(operation.identifier, operation.file);
-		}
-	}
-	return files;
-};
-const rewriteAppliedReferences = (plan, state) => {
-	const content = normalizeLocalContentMedia(plan.content, state.assetsByIdentifier);
-	const manifest = structuredClone(plan.manifest);
-	const files = fileByIdentifier(plan.operations);
-	for (const reference of plan.references) {
-		const asset = state.assetsByIdentifier.get(reference.identifier);
-		if (!asset) continue;
-		updateManifestEntry(manifest, reference.identifier, asset, files.get(reference.identifier));
-	}
-	return {
-		content,
-		manifest
-	};
-};
-const finalSummary = (summary, dryRun) => ({
-	...summary,
-	pendingUploads: dryRun ? summary.pendingUploads : 0
-});
-async function applyLocalMediaPush(options) {
-	const { plan, client, dryRun, onEvent } = options;
-	const state = createApplyState(plan);
-	const context = {
-		client,
-		dryRun,
-		targetEnv: plan.targetEnv,
-		onEvent
-	};
-	await applyMediaOperations(plan.operations, context, state);
-	await resolveUploadedAssets(state, client, dryRun);
-	const rewritten = rewriteAppliedReferences(plan, state);
-	const summary = finalSummary(state.summary, dryRun);
-	const hasChanges = summary.uploaded > 0 || summary.pendingUploads > 0;
-	return {
-		...rewritten,
-		summary,
-		report: makeReport({
-			targetEnv: plan.targetEnv,
-			summary,
-			items: state.reportItems
-		}),
-		warnings: [...plan.warnings],
-		errors: state.errors,
-		hasChanges
-	};
-}
-
-//#endregion
-//#region src/media/pull-assets.ts
-const buildPullAssetIndexes = (resolved) => {
-	const assetsById = new Map(resolved.assets.map((asset) => [asset.id, asset]));
-	const assetsByIdentifier = new Map();
-	for (const asset of resolved.assets) {
-		assetsByIdentifier.set(asset.identifier, asset);
-	}
-	return {
-		assetsById,
-		assetsByIdentifier
-	};
-};
-const resolveReferencedAsset = (reference, indexes) => {
-	const byId = reference.value.assetId ? indexes.assetsById.get(reference.value.assetId) : undefined;
-	if (byId) return byId;
-	return reference.value.identifier ? indexes.assetsByIdentifier.get(reference.value.identifier) : undefined;
-};
-const normalizePullIdentifier = (options) => {
-	const { initial, location, existingIdentifiers } = options;
-	if (!initial) return {
-		identifier: null,
-		canonicalized: 0
-	};
-	const normalized = slugifyMediaIdentifier(initial);
-	if (!normalized) {
-		return {
-			identifier: initial,
-			canonicalized: 0,
-			warning: `Could not normalize identifier "${initial}" at ${location}.`
-		};
-	}
-	existingIdentifiers.add(normalized);
-	return {
-		identifier: normalized,
-		canonicalized: normalized === initial ? 0 : 1
-	};
-};
-const planPullAssetReference = (options) => {
-	const resolvedAsset = resolveReferencedAsset(options.reference, options.indexes);
-	let canonicalized = 0;
-	let identifier = resolvedAsset?.identifier ?? options.reference.value.identifier ?? null;
-	const normalized = normalizePullIdentifier({
-		initial: identifier,
-		location: options.reference.location,
-		existingIdentifiers: options.existingIdentifiers
-	});
-	canonicalized += normalized.canonicalized;
-	identifier = normalized.identifier;
-	if (normalized.warning && normalized.identifier) {
-		return {
-			plan: {
-				kind: "identified",
-				reference: options.reference,
-				resolvedAsset,
-				identifier: normalized.identifier
-			},
-			canonicalized,
-			warning: normalized.warning
-		};
-	}
-	if (resolvedAsset && identifier) {
-		options.indexes.assetsByIdentifier.set(identifier, resolvedAsset);
-	}
-	return {
-		plan: identifier ? {
-			kind: "identified",
-			reference: options.reference,
-			resolvedAsset,
-			identifier
-		} : {
-			kind: "unidentified",
-			reference: options.reference,
-			resolvedAsset,
-			identifier: null
-		},
-		canonicalized
-	};
-};
-const planPullAssetIdentifiers = (options) => {
-	const indexes = buildPullAssetIndexes(options.resolved);
-	const assetsById = new Map(indexes.assetsById);
-	const assetsByIdentifier = new Map(indexes.assetsByIdentifier);
-	const existingIdentifiers = new Set(options.identifiers);
-	for (const asset of options.resolved.assets) {
-		existingIdentifiers.add(asset.identifier);
-	}
-	let referencesCanonicalized = 0;
-	const warnings = [];
-	const references = [];
-	for (const reference of options.references) {
-		const planned = planPullAssetReference({
-			reference,
-			indexes: {
-				assetsById,
-				assetsByIdentifier
-			},
-			existingIdentifiers
-		});
-		referencesCanonicalized += planned.canonicalized;
-		if (planned.warning) warnings.push(planned.warning);
-		references.push(planned.plan);
-	}
-	return {
-		indexes: {
-			assetsById,
-			assetsByIdentifier
-		},
-		references,
-		summary: { referencesCanonicalized },
-		warnings
-	};
-};
-const applyPullAssetPlan = (options) => {
-	const assetsById = new Map(options.plan.indexes.assetsById);
-	const assetsByIdentifier = new Map(options.plan.indexes.assetsByIdentifier);
-	const references = [];
-	for (const planned of options.plan.references) {
-		if (planned.kind === "unidentified") {
-			references.push(planned);
-			continue;
-		}
-		planned.reference.value.identifier = planned.identifier;
-		if (planned.resolvedAsset) {
-			updateManifestEntry(options.manifest, planned.identifier, planned.resolvedAsset, null);
-		}
-		references.push(planned);
-	}
-	return {
-		indexes: {
-			assetsById,
-			assetsByIdentifier
-		},
-		references
-	};
-};
-
-//#endregion
-//#region src/media/pull-references.ts
-/**
-* Discover ordinary media values and normalize rich-text nodes that already
-* have an identifier. Rich-text nodes with only a source URL are returned as
-* explicit import intents; importing is an effectful stage owned by the
-* workflow, not by content traversal.
-*/
-const collectPullMediaReferences = (content) => {
-	const references = [];
-	const identifiers = new Set();
-	const assetIds = new Set();
-	const warnings = [];
-	walkPulledContentMedia(content, (value, location) => {
-		references.push({
-			value,
-			location
-		});
-		if (typeof value.identifier === "string") {
-			identifiers.add(value.identifier);
-		}
-		if (typeof value.assetId === "string") {
-			assetIds.add(value.assetId);
-		}
-	});
-	const richTextImports = [];
-	let referencesCanonicalized = 0;
-	const richTextNodes = collectRichTextImageAttrs(content);
-	for (const node of richTextNodes) {
-		const attrs = node.attrs;
-		const rawIdentifier = typeof attrs.identifier === "string" ? attrs.identifier.trim() : "";
-		const rawSrc = typeof attrs.src === "string" ? attrs.src.trim() : "";
-		if (rawIdentifier) {
-			const normalized = normalizeMediaIdentifierInput(rawIdentifier);
-			if (!normalized) {
-				warnings.push(`Invalid rich text image identifier "${rawIdentifier}" at ${node.location}.`);
-				continue;
-			}
-			if (normalized !== rawIdentifier) {
-				attrs.identifier = normalized;
-				referencesCanonicalized += 1;
-			}
-			delete attrs.src;
-			identifiers.add(normalized);
-			references.push({
-				value: {
-					type: "image",
-					identifier: normalized
-				},
-				location: node.location
-			});
-			continue;
-		}
-		if (rawSrc) {
-			richTextImports.push({
-				attrs,
-				location: node.location,
-				src: rawSrc
-			});
-		}
-	}
-	return {
-		references,
-		identifiers,
-		assetIds,
-		richTextImports,
-		referencesCanonicalized,
-		cmsImportsPlanned: 0,
-		cmsAssetsImported: 0,
-		warnings
-	};
-};
-const recordRichTextImport = (collection, intent, identifier) => {
-	intent.attrs.identifier = identifier;
-	delete intent.attrs.src;
-	collection.identifiers.add(identifier);
-	const reference = {
-		value: {
-			type: "image",
-			identifier
-		},
-		location: intent.location
-	};
-	collection.references.push(reference);
-	return {
-		identifier,
-		reference
-	};
-};
-
-//#endregion
-//#region src/media/pull-rich-text.ts
-const chooseChecksumIdentifier = (candidates) => {
-	const chosen = candidates.slice().sort((a, b) => a.createdAt.localeCompare(b.createdAt))[0];
-	if (!chosen) return null;
-	return chosen.identifier;
-};
-const assignOrUploadRichTextIdentifier = async (options) => {
-	for (let attempt = 0; attempt < 10; attempt += 1) {
-		const candidate = resolveMediaIdentifier(options.base, options.existingIdentifiers);
-		options.existingIdentifiers.add(candidate);
-		if (options.dryRun) return {
-			kind: "planned-upload",
-			identifier: candidate
-		};
-		try {
-			const uploaded = await options.client.media.upload({
-				data: options.data,
-				filename: options.filename,
-				contentType: options.mimeType,
-				identifier: candidate
-			});
-			return {
-				kind: "uploaded",
-				identifier: uploaded.identifier
-			};
-		} catch {
-			continue;
-		}
-	}
-	throw new Error("Unable to assign a unique identifier for rich text image import");
-};
-const importRichTextImageSrcToIdentifier = async (options) => {
-	const { client, src, location, existingIdentifiers, dryRun } = options;
-	const downloaded = await downloadMedia(src);
-	if (!downloaded) {
-		throw new Error(`Failed to download rich text image from ${src}`);
-	}
-	const mimeType = downloaded.contentType.split(";")[0]?.trim() || "application/octet-stream";
-	if (!mimeType.startsWith("image/")) {
-		throw new Error(`Unsupported content-type for rich text image import: ${mimeType}`);
-	}
-	const checksum = sha256(downloaded.data);
-	const matches = await client.media.findByChecksum([checksum]);
-	const candidates = matches.filter((asset) => asset.checksumSha256 === checksum);
-	const existingIdentifier = chooseChecksumIdentifier(candidates);
-	if (existingIdentifier) return {
-		kind: "existing",
-		identifier: existingIdentifier
-	};
-	return assignOrUploadRichTextIdentifier({
-		client,
-		base: chooseRichTextIdentifierBase(location, src),
-		existingIdentifiers,
-		dryRun,
-		data: downloaded.data,
-		filename: ensureFilenameExtension(parseFilenameFromUrl(src) ?? "image", mimeType),
-		mimeType
-	});
-};
-async function importRichTextPullReferences(options) {
-	const { collection, client, dryRun, allowCmsWrites } = options;
-	const richTextExisting = new Set(collection.identifiers);
-	for (const intent of collection.richTextImports) {
-		try {
-			const identifier = await importRichTextImageSrcToIdentifier({
-				client,
-				src: intent.src,
-				location: intent.location,
-				existingIdentifiers: richTextExisting,
-				dryRun: dryRun || !allowCmsWrites
-			});
-			if (identifier.kind === "planned-upload") {
-				collection.cmsImportsPlanned += 1;
-				if (!dryRun && !allowCmsWrites) continue;
-			}
-			if (identifier.kind === "uploaded") {
-				collection.cmsAssetsImported += 1;
-			}
-			recordRichTextImport(collection, intent, identifier.identifier);
-			richTextExisting.add(identifier.identifier);
-		} catch (error) {
-			const message = error instanceof Error ? error.message : String(error);
-			collection.warnings.push(`Failed to import rich text image @ ${intent.location}: ${message}`);
-		}
-	}
-}
-
-//#endregion
-//#region src/media/pull-download.ts
-const planLocalMediaDownload = (options) => {
-	const { reference, asset, identifier, existingEntry, local } = options;
-	if (!asset) return {
-		kind: "missing-asset",
-		reference
-	};
-	const filename = buildLocalFilename(identifier, asset);
-	if (local.exists) {
-		if (asset.checksumSha256) {
-			if (existingEntry?.checksum === asset.checksumSha256) {
-				return {
-					kind: "skip",
-					reference,
-					asset,
-					identifier,
-					filename
-				};
-			}
-			if (local.checksum === asset.checksumSha256) {
-				return {
-					kind: "skip",
-					reference,
-					asset,
-					identifier,
-					filename
-				};
-			}
-		} else if (existingEntry?.checksum) {
-			return {
-				kind: "skip",
-				reference,
-				asset,
-				identifier,
-				filename
-			};
-		}
-	}
-	return {
-		kind: "download",
-		reference,
-		asset,
-		identifier,
-		filename
-	};
-};
-const readExistingLocalMedia = async (options) => {
-	const exists = await localMediaFileExists(options.localFilePath);
-	if (!exists) return { exists: false };
-	if (!options.asset.checksumSha256) {
-		return { exists: true };
-	}
-	const manifestChecksum = options.existingEntry?.checksum;
-	if (manifestChecksum === options.asset.checksumSha256) {
-		return {
-			exists: true,
-			checksum: manifestChecksum
-		};
-	}
-	const localChecksum = manifestChecksum ?? await sha256FromFile(options.localFilePath);
-	return {
-		exists: true,
-		checksum: localChecksum
-	};
-};
-const removeStaleLocalFile = async (options) => {
-	if (options.dryRun || !options.previousFilename || options.previousFilename === options.filename) {
-		return;
-	}
-	const previousPath = path$1.join(options.contentDir, "media", options.previousFilename);
-	if (await localMediaFileExists(previousPath)) {
-		await fs$1.unlink(previousPath).catch(() => {});
-	}
-};
-const applySkipDecision = (decision, context, local, existingEntry) => {
-	if (decision.asset.checksumSha256 && local.checksum === decision.asset.checksumSha256 && existingEntry?.checksum !== decision.asset.checksumSha256) {
-		context.manifest.assets[decision.identifier] = {
-			...existingEntry,
-			checksum: local.checksum,
-			filename: decision.filename,
-			mimeType: decision.asset.mimeType ?? existingEntry?.mimeType
-		};
-	}
-	context.summary.skipped += 1;
-	updateManifestEntry(context.manifest, decision.identifier, decision.asset, null);
-};
-const applyDownloadDecision = async (decision, context) => {
-	context.summary.pendingDownloads += 1;
-	if (context.dryRun) return;
-	const relativePath = normalizeStoragePath(decision.asset.storagePath, context.siteId);
-	const urlResult = buildStorageUrl(context.supabaseUrl, relativePath, context.siteId, decision.asset.storageBucket ?? "media");
-	if (!urlResult.ok) {
-		context.warnings.push(`Invalid storage path for "${decision.identifier}": ${urlResult.error.cause.tag}.`);
-		return;
-	}
-	const downloaded = await downloadMedia(urlResult.value);
-	if (!downloaded) {
-		context.warnings.push(`Failed to download media for "${decision.identifier}" from ${urlResult.value}.`);
-		return;
-	}
-	const written = await writeLocalMediaFile(context.contentDir, decision.filename, downloaded.data);
-	context.warnings.push(...localMediaWriteWarningMessages(decision.identifier, written));
-	context.manifest.assets[decision.identifier] = {
-		checksum: sha256(downloaded.data),
-		filename: decision.filename,
-		mimeType: decision.asset.mimeType
-	};
-	context.summary.downloaded += 1;
-};
-const syncPullMediaDownload = async (planned, indexes, context) => {
-	const { reference, identifier } = planned;
-	const byId = reference.value.assetId ? indexes.assetsById.get(reference.value.assetId) : undefined;
-	const asset = byId ?? indexes.assetsByIdentifier.get(identifier);
-	if (!asset) {
-		context.warnings.push(`Unable to resolve asset for "${identifier}" at ${reference.location}.`);
-		return;
-	}
-	const filename = buildLocalFilename(identifier, asset);
-	const localFilePath = path$1.join(context.contentDir, "media", filename);
-	const existingEntry = context.manifest.assets[identifier];
-	await removeStaleLocalFile({
-		contentDir: context.contentDir,
-		previousFilename: existingEntry?.filename,
-		filename,
-		dryRun: context.dryRun
-	});
-	const local = await readExistingLocalMedia({
-		localFilePath,
-		existingEntry,
-		asset
-	});
-	const decision = planLocalMediaDownload({
-		reference,
-		asset,
-		identifier,
-		existingEntry,
-		local
-	});
-	switch (decision.kind) {
-		case "missing-asset":
-			context.warnings.push(`Unable to resolve asset for "${identifier}" at ${reference.location}.`);
-			return;
-		case "skip":
-			applySkipDecision(decision, context, local, existingEntry);
-			return;
-		case "download": await applyDownloadDecision(decision, context);
-	}
-};
-const syncPullMediaDownloads = async (options) => {
-	for (const planned of options.references) {
-		if (planned.kind === "identified") {
-			await syncPullMediaDownload(planned, options.indexes, options);
-		}
-	}
-	if (!options.dryRun) options.summary.pendingDownloads = 0;
-};
-const sha256FromFile = (filePath) => readLocalMediaChecksum(filePath, FILE_SIZE_LIMITS.rawVideoBeforeCompression);
-function localMediaWriteWarningMessages(identifier, outcome) {
-	if (outcome.kind === "written") return [];
-	return outcome.warnings.map((warning) => {
-		switch (warning.tag) {
-			case "temporary_cleanup_failed": return `Downloaded media for "${identifier}", but could not remove temporary file ${warning.temporaryPath}.`;
-			case "directory_sync_failed": return `Downloaded media for "${identifier}", but could not confirm the destination directory was synced.`;
-		}
-	});
-}
-
-//#endregion
-//#region src/media/pull-workflow.ts
-async function syncLocalMediaForPull(options) {
-	const { contentDir, content, client, dryRun, allowCmsWrites = true, supabaseUrl, siteId, downloadFiles } = options;
-	const manifest = await readMediaManifest(contentDir);
-	const collection = collectPullMediaReferences(content);
-	await importRichTextPullReferences({
-		collection,
-		client,
-		dryRun,
-		allowCmsWrites
-	});
-	const summary = {
-		totalReferences: collection.references.length,
-		referencesCanonicalized: collection.referencesCanonicalized,
-		cmsImportsPlanned: collection.cmsImportsPlanned,
-		cmsAssetsImported: collection.cmsAssetsImported,
-		downloaded: 0,
-		skipped: 0,
-		pendingDownloads: 0
-	};
-	const warnings = [...collection.warnings];
-	if (collection.references.length === 0) {
-		return {
-			content,
-			manifest,
-			summary,
-			warnings
-		};
-	}
-	const resolved = await client.media.resolve({
-		...collection.identifiers.size > 0 ? { identifiers: Array.from(collection.identifiers) } : {},
-		...collection.assetIds.size > 0 ? { assetIds: Array.from(collection.assetIds) } : {}
-	});
-	const assetPlan = planPullAssetIdentifiers({
-		references: collection.references,
-		resolved,
-		identifiers: collection.identifiers
-	});
-	warnings.push(...assetPlan.warnings);
-	summary.referencesCanonicalized += assetPlan.summary.referencesCanonicalized;
-	const applied = applyPullAssetPlan({
-		plan: assetPlan,
-		manifest
-	});
-	if (!downloadFiles) {
-		return {
-			content,
-			manifest,
-			summary,
-			warnings
-		};
-	}
-	if (!supabaseUrl || !siteId) {
-		throw new Error("syncLocalMediaForPull requires supabaseUrl and siteId when downloadFiles=true.");
-	}
-	await syncPullMediaDownloads({
-		contentDir,
-		manifest,
-		references: applied.references,
-		indexes: applied.indexes,
-		supabaseUrl,
-		siteId,
-		dryRun,
-		summary,
-		warnings
-	});
-	return {
-		content,
-		manifest,
-		summary,
-		warnings
-	};
-}
-
-//#endregion
-//#region src/media/local-sync.ts
-const rawErrorMessage = (error) => error instanceof Error ? error.message : String(error);
-async function revalidateLocalMediaPushPlan(plan, client) {
-	const identifiers = plan.mediaReadSet.map((observation) => observation.identifier);
-	if (identifiers.length === 0) return { ok: true };
-	try {
-		const resolved = await client.media.resolve({ identifiers });
-		const assets = new Map(resolved.assets.map((asset) => [asset.identifier, asset]));
-		const localChecksums = new Map(plan.mediaReadSet.map((observation) => [observation.identifier, observation.localChecksum.kind === "present" ? observation.localChecksum.checksum : undefined]));
-		const observedChecksums = Array.from(new Set(plan.mediaReadSet.flatMap((observation) => observation.localChecksum.kind === "present" && observation.localChecksum.lookup.kind === "read" ? [observation.localChecksum.checksum] : [])));
-		const currentChecksumAssets = observedChecksums.length > 0 ? await client.media.findByChecksum(observedChecksums) : [];
-		const checksumAssetsByChecksum = new Map(observedChecksums.map((checksum) => [checksum, []]));
-		for (const asset of currentChecksumAssets) {
-			if (!asset.checksumSha256) continue;
-			const matches = checksumAssetsByChecksum.get(asset.checksumSha256);
-			if (!matches) continue;
-			matches.push(asset);
-		}
-		const current = buildMediaReadSet({
-			identifiers,
-			localChecksums,
-			initialAssets: assets,
-			initialMissing: new Set(resolved.missingIdentifiers),
-			checksumAssetsByChecksum
-		});
-		if (stableMediaReadSet(current) !== stableMediaReadSet(plan.mediaReadSet)) {
-			return {
-				ok: false,
-				error: {
-					kind: "remote-media-drift",
-					message: "Remote media state changed after preflight; re-run the push to refresh its media plan."
-				}
-			};
-		}
-		return { ok: true };
-	} catch (error) {
-		return {
-			ok: false,
-			error: {
-				kind: "remote-media-read-failed",
-				message: `Failed to revalidate remote media state: ${rawErrorMessage(error)}`
-			}
-		};
-	}
-}
-async function syncLocalMediaForPush(options) {
-	const plan = await prepareLocalMediaForPush(options);
-	const result = await applyLocalMediaPush({
-		plan,
-		client: options.client,
-		dryRun: options.dryRun,
-		onEvent: options.onEvent
-	});
-	Object.assign(options.content, result.content);
-	return {
-		...result,
-		content: options.content
-	};
-}
-
-//#endregion
-export { sdkUpsertEventResponseSchema as A, isInternalResolvedLinkValue as B, createHttpClient as C, sdkGetEventResponseSchema as D, sdkConfigureBookingVerticalResponseSchema as E, entryLinkSchema$1 as F, sdkGetPageDesignResponseSchema as G, linkSchema as H, externalLinkSchema$1 as I, sdkEventOccurrenceResponseSchema as J, sdkSavePageDesignResponseSchema as K, internalLinkSchema as L, linkPayloadSchema as M, RESOLVED_INTERNAL_LINK_ENTITY_TYPES as N, sdkListEventsResponseSchema as O, customLinkSchema$1 as P, internalResolvedLinkSchema as R, buildRequestInfo as S, managementTransportError as T, pageLinkSchema$1 as U, isResolvedInternalLinkEntityType as V, portablePageDesignSchema as W, sdkReorderResponseSchema as X, sdkListEventOccurrencesResponseSchema as Y, sdkConfiguredBookingVerticalConfigSchema as Z, buildSettingsUpdateInput as _, prepareLocalMediaForPush as a, isMediaValue as b, writeBinaryFileAtomic as c, normalizeMediaValueToIdentifierOnly as d, walkLocalContentMedia as f, SETTINGS_FILE_FIELDS as g, extractMediaIdentifiers as h, applyLocalMediaPush as i, sdkSettingsUpdateSchema as j, sdkTakeEventOfflineResponseSchema as k, sha256 as l, downloadMedia as m, syncLocalMediaForPush as n, admitBinaryWriteDestination as o, buildStorageUrl as p, sdkDeleteEventOccurrenceResponseSchema as q, syncLocalMediaForPull as r, readStableBinaryFile as s, revalidateLocalMediaPushPlan as t, normalizeMediaIdentifierInput as u, hasOwnSettingsField as v, is404Error as w, ManagementApiError as x, writeMediaManifest as y, internalRouteOnlyLinkSchema as z };