emdash 0.38.0 → 0.39.0

package/dist/entry-lock-D3C99MXS.mjs

@@ -0,0 +1,1520 @@
+import { a as MAX_COLLECTION_LIST_COLUMNS, i as MAX_COLLECTION_GROUP_LENGTH } from "./types-B3RkqvDW.mjs";
+import { t as SQL_BATCH_SIZE } from "./chunks-BmWyou79.mjs";
+import { t as isValidFocalPointUpdate } from "./focal-point-Gr34o-4o.mjs";
+import { t as SEARCH_TOKENIZERS } from "./types-CSHgU_-_.mjs";
+import { C as slugPattern, S as roleLevel, g as cursorPaginationQuery, v as httpUrl, y as localeCode } from "./redirects-BCiTaIQ-.mjs";
+import { t as compileUrlPattern } from "./url-pattern-3m3reMzr.mjs";
+import { z } from "zod";
+
+//#region src/api/schemas/bylines.ts
+/** Slug pattern: lowercase letters, digits, and hyphens; must start with a letter */
+const bylineSlugPattern = /^[a-z][a-z0-9-]*$/;
+const bylineSummarySchema = z.object({
+	id: z.string(),
+	slug: z.string(),
+	displayName: z.string(),
+	bio: z.string().nullable(),
+	avatarMediaId: z.string().nullable(),
+	avatarStorageKey: z.string().nullish(),
+	avatarAlt: z.string().nullish(),
+	avatarBlurhash: z.string().nullish(),
+	avatarDominantColor: z.string().nullish(),
+	websiteUrl: z.string().nullable(),
+	userId: z.string().nullable(),
+	isGuest: z.boolean(),
+	createdAt: z.string(),
+	updatedAt: z.string(),
+	locale: z.string(),
+	translationGroup: z.string().nullable(),
+	customFields: z.record(z.string(), z.union([
+		z.string(),
+		z.boolean(),
+		z.null()
+	])).optional()
+}).meta({ id: "BylineSummary" });
+const bylineCreditSchema = z.object({
+	byline: bylineSummarySchema,
+	sortOrder: z.number().int(),
+	roleLabel: z.string().nullable(),
+	source: z.enum(["explicit", "inferred"]).optional().meta({ description: "Whether this credit was explicitly assigned or inferred from authorId" })
+}).meta({ id: "BylineCredit" });
+const contentBylineInputSchema = z.object({
+	bylineId: z.string().min(1),
+	roleLabel: z.string().nullish()
+}).meta({ id: "ContentBylineInput" });
+const bylinesListQuery = cursorPaginationQuery.extend({
+	search: z.string().optional(),
+	isGuest: z.coerce.boolean().optional(),
+	userId: z.string().optional(),
+	locale: localeCode.optional()
+}).meta({ id: "BylinesListQuery" });
+const bylineCreateBody = z.object({
+	slug: z.string().min(1).regex(bylineSlugPattern, "Slug must contain only lowercase letters, digits, and hyphens"),
+	displayName: z.string().min(1),
+	bio: z.string().nullish(),
+	avatarMediaId: z.string().nullish(),
+	websiteUrl: httpUrl.nullish(),
+	userId: z.string().nullish(),
+	isGuest: z.boolean().optional(),
+	locale: localeCode.optional(),
+	translationOf: z.string().min(1).optional(),
+	customFields: z.record(z.string(), z.unknown()).optional()
+}).meta({ id: "BylineCreateBody" });
+const bylineTranslationCreateBody = z.object({
+	locale: localeCode,
+	slug: z.string().min(1).regex(bylineSlugPattern, "Slug must contain only lowercase letters, digits, and hyphens").optional(),
+	displayName: z.string().min(1).optional(),
+	bio: z.string().nullish(),
+	avatarMediaId: z.string().nullish(),
+	websiteUrl: httpUrl.nullish()
+}).meta({ id: "BylineTranslationCreateBody" });
+const bylineTranslationsResponseSchema = z.object({ items: z.array(bylineSummarySchema) }).meta({ id: "BylineTranslationsResponse" });
+const bylineUpdateBody = z.object({
+	slug: z.string().min(1).regex(bylineSlugPattern, "Slug must contain only lowercase letters, digits, and hyphens").optional(),
+	displayName: z.string().min(1).optional(),
+	bio: z.string().nullish(),
+	avatarMediaId: z.string().nullish(),
+	websiteUrl: httpUrl.nullish(),
+	userId: z.string().nullish(),
+	isGuest: z.boolean().optional(),
+	customFields: z.record(z.string(), z.unknown()).optional()
+}).meta({ id: "BylineUpdateBody" });
+const bylineListResponseSchema = z.object({
+	items: z.array(bylineSummarySchema),
+	nextCursor: z.string().optional()
+}).meta({ id: "BylineListResponse" });
+
+//#endregion
+//#region src/api/schemas/content.ts
+const contentDateTime = z.iso.datetime({
+	offset: true,
+	message: "must be an ISO 8601 datetime"
+}).or(z.iso.datetime({
+	offset: true,
+	precision: -1,
+	message: "must be an ISO 8601 datetime"
+}));
+/** SEO input — per-content meta fields */
+const contentSeoInput = z.object({
+	title: z.string().max(200).nullish(),
+	description: z.string().max(500).nullish(),
+	image: z.string().nullish(),
+	canonical: httpUrl.nullish(),
+	noIndex: z.boolean().optional()
+}).meta({ id: "ContentSeoInput" });
+/** ISO 8601 date or datetime bound for the content-list date range filter. */
+const contentDateBound = z.union([contentDateTime, z.iso.date({ message: "must be an ISO 8601 date" })]).optional();
+/**
+* Byline ids for the content-list filter: either the literal `none` or a
+* comma-separated list, parsed into an array.
+*
+* The 25-id cap keeps the `IN (...)` clause clear of D1's bound-parameter
+* ceiling once the rest of the list query's placeholders are counted
+* (`SQL_BATCH_SIZE` is 50 for a query binding nothing else).
+*/
+const bylineFilterParam = z.string().trim().min(1).max(2e3).optional().transform((value) => value === void 0 ? void 0 : value === "none" ? "none" : [...new Set(value.split(",").map((id) => id.trim()))].filter((id) => id.length > 0)).refine((value) => value === void 0 || value === "none" || value.length <= 25, { message: "at most 25 bylines may be selected" }).refine((value) => value === void 0 || value === "none" || value.length > 0, { message: "must contain at least one byline id" });
+/** Query-string boolean. Explicit values only — `z.coerce.boolean()` reads "false" as true. */
+const booleanParam = z.enum([
+	"1",
+	"0",
+	"true",
+	"false"
+]).optional().transform((value) => value === "1" || value === "true");
+const contentFieldComparable = z.union([z.string().max(2048), z.number()]);
+const contentFieldFilterScalar = z.union([
+	contentFieldComparable,
+	z.boolean(),
+	z.null()
+]);
+const contentFieldFilterValue = z.union([
+	contentFieldFilterScalar,
+	z.object({ in: z.array(z.union([contentFieldComparable, z.boolean()])).min(1).max(SQL_BATCH_SIZE) }).strict(),
+	z.object({
+		gt: contentFieldComparable.optional(),
+		gte: contentFieldComparable.optional(),
+		lt: contentFieldComparable.optional(),
+		lte: contentFieldComparable.optional()
+	}).strict().refine((value) => Object.values(value).some((bound) => bound !== void 0), { message: "Range filter must include at least one bound" })
+]);
+function contentFieldFilterOperandCount(value) {
+	if (value === null) return 0;
+	if (!value || typeof value !== "object" || Array.isArray(value)) return 1;
+	if ("in" in value && Array.isArray(value.in)) return value.in.length;
+	return Object.values(value).filter((bound) => bound !== void 0).length;
+}
+/** AND-combined filters over custom fields explicitly marked as indexed. */
+const contentFieldFiltersSchema = z.record(z.string().max(128).regex(/^[a-z][a-z0-9_]*$/, "must be a safe field identifier"), contentFieldFilterValue).refine((filters) => Object.keys(filters).length <= 20, { message: "At most 20 indexed field filters are allowed" }).refine((filters) => Object.values(filters).reduce((total, value) => total + contentFieldFilterOperandCount(value), 0) <= SQL_BATCH_SIZE, { message: `Indexed field filters have a total operand budget of ${SQL_BATCH_SIZE}` });
+const contentFieldFiltersQuery = z.string().max(8192).transform((value, ctx) => {
+	try {
+		return JSON.parse(value);
+	} catch {
+		ctx.addIssue({
+			code: "custom",
+			message: "must be valid JSON"
+		});
+		return z.NEVER;
+	}
+}).pipe(contentFieldFiltersSchema);
+const contentListQuery = cursorPaginationQuery.extend({
+	status: z.string().optional(),
+	orderBy: z.string().optional(),
+	order: z.enum(["asc", "desc"]).optional(),
+	locale: localeCode.optional(),
+	q: z.string().trim().min(1).max(200).optional(),
+	authorId: z.string().min(1).max(64).optional(),
+	dateField: z.enum([
+		"createdAt",
+		"updatedAt",
+		"publishedAt"
+	]).optional(),
+	dateFrom: contentDateBound,
+	dateTo: contentDateBound,
+	bylines: bylineFilterParam,
+	includeInferredBylines: booleanParam,
+	fieldFilters: contentFieldFiltersQuery.optional()
+}).transform(({ bylines, ...rest }) => ({
+	...rest,
+	bylinesNone: bylines === "none",
+	bylines: bylines === "none" ? void 0 : bylines
+})).meta({ id: "ContentListQuery" });
+/** ISO 8601 datetime for `publishedAt` / `createdAt`. Routes gate writes behind `content:publish_any`. */
+const contentDateOverride = contentDateTime.nullish();
+const overrideLockFlag = z.boolean().optional().meta({ description: "Write even though another editor holds this entry's edit lock. Without it the write is refused with 409 ENTRY_LOCKED." });
+const contentCreateBody = z.object({
+	data: z.record(z.string(), z.unknown()),
+	slug: z.string().nullish(),
+	status: z.enum(["draft"]).optional(),
+	bylines: z.array(contentBylineInputSchema).optional(),
+	locale: localeCode.optional(),
+	translationOf: z.string().optional(),
+	seo: contentSeoInput.optional(),
+	taxonomies: z.record(z.string(), z.array(z.string())).optional().meta({ description: "Taxonomy term assignments as { taxonomyName: [termSlug, ...] }, resolved in the entry's locale." }),
+	publishedAt: contentDateOverride,
+	createdAt: contentDateOverride
+}).meta({ id: "ContentCreateBody" });
+const contentUpdateBody = z.object({
+	data: z.record(z.string(), z.unknown()).optional(),
+	slug: z.string().nullish(),
+	status: z.enum(["draft"]).optional(),
+	authorId: z.string().nullish(),
+	bylines: z.array(contentBylineInputSchema).optional(),
+	_rev: z.string().optional().meta({ description: "Opaque revision token for optimistic concurrency" }),
+	skipRevision: z.boolean().optional(),
+	overrideLock: overrideLockFlag,
+	seo: contentSeoInput.optional(),
+	taxonomies: z.record(z.string(), z.array(z.string())).optional().meta({ description: "Replace taxonomy assignments as { taxonomyName: [termSlug, ...] }. Only named taxonomies are touched; pass an empty array to clear a taxonomy." }),
+	publishedAt: contentDateOverride
+}).meta({ id: "ContentUpdateBody" });
+const contentScheduleBody = z.object({
+	scheduledAt: contentDateTime.meta({
+		description: "ISO 8601 datetime with Z or an explicit offset for scheduled publishing",
+		examples: ["2025-06-15T09:00:00Z"]
+	}),
+	overrideLock: overrideLockFlag,
+	_rev: z.string().optional().meta({ description: "Opaque revision token for optimistic concurrency" })
+}).meta({ id: "ContentScheduleBody" });
+const contentRevisionConditionBody = z.object({
+	_rev: z.string().optional().meta({ description: "Opaque revision token for optimistic concurrency" }),
+	overrideLock: overrideLockFlag
+}).meta({ id: "ContentRevisionConditionBody" });
+const contentPublishBody = contentRevisionConditionBody.extend({ publishedAt: contentDateTime.optional().meta({ description: "Optional ISO 8601 datetime to backdate the publish (e.g. when migrating content). Requires content:publish_any permission. Without this, existing published_at is preserved on re-publish." }) }).meta({ id: "ContentPublishBody" });
+const contentPreviewUrlBody = z.object({
+	expiresIn: z.union([z.string(), z.number()]).optional(),
+	pathPattern: z.string().optional()
+}).meta({ id: "ContentPreviewUrlBody" });
+const contentTermsBody = z.object({ termIds: z.array(z.string()) }).meta({ id: "ContentTermsBody" });
+/** A single term variant returned as part of an entry's term assignments. */
+const contentEntryTermSchema = z.object({
+	id: z.string(),
+	name: z.string().meta({ description: "Taxonomy name" }),
+	slug: z.string(),
+	label: z.string(),
+	parentId: z.string().nullable(),
+	locale: localeCode,
+	translationGroup: z.string().nullable()
+}).meta({ id: "ContentEntryTerm" });
+/** Term assignments response for the content terms endpoint. */
+const contentTermsResponseSchema = z.object({
+	terms: z.array(contentEntryTermSchema),
+	unresolved: z.array(z.object({
+		translationGroup: z.string(),
+		availableLocales: z.array(localeCode),
+		translations: z.array(z.object({
+			id: z.string(),
+			slug: z.string(),
+			locale: localeCode
+		}))
+	})),
+	entryLocale: localeCode,
+	defaultLocale: localeCode,
+	implicitDefaultLocale: z.boolean()
+}).meta({ id: "ContentTermsResponse" });
+const contentTrashQuery = cursorPaginationQuery.extend({ locale: localeCode.optional().meta({ description: "Restrict the trash listing to entries in this locale" }) }).meta({ id: "ContentTrashQuery" });
+/** SEO metadata on a content item */
+const contentSeoSchema = z.object({
+	title: z.string().nullable(),
+	description: z.string().nullable(),
+	image: z.string().nullable(),
+	canonical: z.string().nullable(),
+	noIndex: z.boolean()
+}).meta({ id: "ContentSeo" });
+/** A single content item as returned by the API */
+const contentItemSchema = z.object({
+	id: z.string(),
+	type: z.string().meta({ description: "Collection slug this item belongs to" }),
+	slug: z.string().nullable(),
+	status: z.string().meta({ description: "draft, published, or scheduled" }),
+	data: z.record(z.string(), z.unknown()).meta({ description: "User-defined field values" }),
+	authorId: z.string().nullable(),
+	primaryBylineId: z.string().nullable(),
+	byline: bylineSummarySchema.nullable().optional(),
+	bylines: z.array(bylineCreditSchema).optional(),
+	createdAt: z.string(),
+	updatedAt: z.string(),
+	publishedAt: z.string().nullable(),
+	scheduledAt: z.string().nullable(),
+	liveRevisionId: z.string().nullable(),
+	draftRevisionId: z.string().nullable(),
+	version: z.number().int(),
+	locale: z.string().nullable(),
+	translationGroup: z.string().nullable(),
+	seo: contentSeoSchema.optional()
+}).meta({ id: "ContentItem" });
+/** Response for single content item endpoints (get, create, update) */
+const contentResponseSchema = z.object({
+	item: contentItemSchema,
+	_rev: z.string().optional().meta({ description: "Opaque revision token for optimistic concurrency" })
+}).meta({ id: "ContentResponse" });
+/** Response for restoring an item from trash */
+const contentRestoreResponseSchema = z.object({
+	restored: z.literal(true),
+	item: contentItemSchema,
+	_rev: z.string().meta({ description: "Opaque revision token for optimistic concurrency" })
+}).meta({ id: "ContentRestoreResponse" });
+/** Response for content list endpoints */
+const contentListResponseSchema = z.object({
+	items: z.array(contentItemSchema),
+	nextCursor: z.string().optional(),
+	total: z.number().int().nonnegative().optional()
+}).meta({ id: "ContentListResponse" });
+/** A distinct content author for the admin author filter */
+const contentAuthorSchema = z.object({
+	id: z.string(),
+	name: z.string().nullable(),
+	email: z.string(),
+	avatarUrl: z.string().nullable()
+}).meta({ id: "ContentAuthor" });
+/** Response for the content authors endpoint */
+const contentAuthorsResponseSchema = z.object({ items: z.array(contentAuthorSchema) }).meta({ id: "ContentAuthorsResponse" });
+/** Trashed content item */
+const trashedContentItemSchema = z.object({
+	id: z.string(),
+	type: z.string(),
+	slug: z.string().nullable(),
+	status: z.string(),
+	locale: z.string().nullable(),
+	translationGroup: z.string().nullable(),
+	data: z.record(z.string(), z.unknown()),
+	authorId: z.string().nullable(),
+	createdAt: z.string(),
+	updatedAt: z.string(),
+	publishedAt: z.string().nullable(),
+	deletedAt: z.string()
+}).meta({ id: "TrashedContentItem" });
+/** Response for trashed content list */
+const trashedContentListResponseSchema = z.object({
+	items: z.array(trashedContentItemSchema),
+	nextCursor: z.string().optional()
+}).meta({ id: "TrashedContentListResponse" });
+/** Response for content compare (live vs draft) */
+const contentCompareResponseSchema = z.object({
+	hasChanges: z.boolean(),
+	live: z.record(z.string(), z.unknown()).nullable(),
+	draft: z.record(z.string(), z.unknown()).nullable()
+}).meta({ id: "ContentCompareResponse" });
+/** Translation summary for a content item */
+const contentTranslationSchema = z.object({
+	id: z.string(),
+	locale: z.string().nullable(),
+	slug: z.string().nullable(),
+	status: z.string(),
+	updatedAt: z.string()
+});
+/** Response for content translations endpoint */
+const contentTranslationsResponseSchema = z.object({
+	translationGroup: z.string(),
+	translations: z.array(contentTranslationSchema)
+}).meta({ id: "ContentTranslationsResponse" });
+
+//#endregion
+//#region src/api/schemas/media-usage.ts
+const mediaUsageCoverageStatusSchema = z.enum([
+	"complete",
+	"never",
+	"running",
+	"partial",
+	"failed",
+	"stale",
+	"unknown"
+]).meta({ id: "MediaUsageCoverageStatus" });
+const mediaUsageCoverageSchema = z.object({
+	scope: z.literal("all_content_collections"),
+	status: mediaUsageCoverageStatusSchema
+}).meta({ id: "MediaUsageCoverage" });
+const mediaUsageProgressSchema = z.object({
+	status: z.enum([
+		"indexing",
+		"ready",
+		"needs_attention"
+	]),
+	readyCollections: z.number().int().min(0),
+	totalCollections: z.number().int().min(0)
+}).meta({ id: "MediaUsageProgress" });
+const mediaUsageSummarySchema = z.object({
+	count: z.number().int().min(0).nullable(),
+	coverage: mediaUsageCoverageSchema
+}).meta({ id: "MediaUsageSummary" });
+const mediaUsageDetailsQuery = z.object({
+	cursor: z.string().min(1).max(2048).optional().meta({ description: "Opaque content-entry-group cursor" }),
+	limit: z.coerce.number().int().min(1).max(100).optional().default(50).meta({ description: "Maximum number of content entry groups to return (1-100, default 50)" })
+});
+const mediaUsageOccurrenceDetailSchema = z.object({
+	fieldSlug: z.string(),
+	fieldPath: z.string(),
+	occurrenceIndex: z.number().int().min(0),
+	referenceType: z.enum([
+		"image_field",
+		"file_field",
+		"portable_text_image",
+		"unknown"
+	])
+}).meta({ id: "MediaUsageOccurrenceDetail" });
+const mediaUsageSourceDetailSchema = z.object({
+	variant: z.enum(["columns", "draft_overlay"]),
+	occurrences: z.array(mediaUsageOccurrenceDetailSchema)
+}).meta({ id: "MediaUsageSourceDetail" });
+const mediaUsageEntryDetailSchema = z.object({
+	collection: z.string(),
+	contentId: z.string(),
+	title: z.string().nullable(),
+	slug: z.string().nullable(),
+	locale: z.string().nullable(),
+	status: z.string().nullable(),
+	scheduledAt: z.string().nullable(),
+	deletedAt: z.string().nullable(),
+	sources: z.array(mediaUsageSourceDetailSchema)
+}).meta({ id: "MediaUsageEntryDetail" });
+const mediaUsageDetailsResponseSchema = z.object({
+	items: z.array(mediaUsageEntryDetailSchema),
+	nextCursor: z.string().optional(),
+	coverage: mediaUsageCoverageSchema
+}).meta({ id: "MediaUsageDetailsResponse" });
+const mediaUsageRepairStatusSchema = z.enum([
+	"complete",
+	"partial",
+	"failed",
+	"stale"
+]).meta({ id: "MediaUsageRepairStatus" });
+const mediaUsageRepairCollectionBody = z.object({
+	scope: z.literal("collection"),
+	collection: z.string().min(1).max(63).regex(slugPattern, "Invalid collection slug")
+}).strict();
+const mediaUsageRepairAllBody = z.object({ scope: z.literal("all") }).strict();
+const mediaUsageRepairBody = z.discriminatedUnion("scope", [mediaUsageRepairCollectionBody, mediaUsageRepairAllBody]).meta({ id: "MediaUsageRepairBody" });
+const mediaUsageRepairCollectionSummarySchema = z.object({
+	collection: z.string(),
+	status: mediaUsageRepairStatusSchema,
+	indexedSourceCount: z.number().int().min(0),
+	failedSourceCount: z.number().int().min(0),
+	skippedSourceCount: z.number().int().min(0),
+	deletedSourceCount: z.number().int().min(0),
+	lastErrorCode: z.string().nullable(),
+	startedAt: z.string(),
+	completedAt: z.string().nullable()
+}).meta({ id: "MediaUsageRepairCollectionSummary" });
+const mediaUsageRepairResponseSchema = z.object({
+	status: mediaUsageRepairStatusSchema,
+	indexedSourceCount: z.number().int().min(0),
+	failedSourceCount: z.number().int().min(0),
+	skippedSourceCount: z.number().int().min(0),
+	deletedSourceCount: z.number().int().min(0),
+	collections: z.array(mediaUsageRepairCollectionSummarySchema)
+}).meta({ id: "MediaUsageRepairResponse" });
+const mediaUsageWorkStateSchema = z.enum([
+	"pending",
+	"retry",
+	"leased",
+	"failed"
+]).meta({ id: "MediaUsageWorkState" });
+const mediaUsageWorkListQuery = z.object({
+	collection: z.string().min(1).max(63).regex(slugPattern, "Invalid collection slug"),
+	state: mediaUsageWorkStateSchema.optional(),
+	cursor: z.string().min(1).max(2048).optional().meta({ description: "Opaque work-page cursor" }),
+	limit: z.coerce.number().int().min(1).max(100).optional().default(50).meta({ description: "Maximum number of work items to return (1-100, default 50)" })
+});
+const mediaUsageWorkItemSchema = z.object({
+	collectionId: z.string(),
+	collectionSlug: z.string(),
+	contentId: z.string(),
+	state: mediaUsageWorkStateSchema,
+	attemptCount: z.number().int().min(0),
+	nextAttemptAt: z.string(),
+	leaseExpiresAt: z.string().nullable(),
+	lastAttemptedAt: z.string().nullable(),
+	lastErrorCode: z.string().nullable(),
+	updatedAt: z.string()
+}).meta({ id: "MediaUsageWorkItem" });
+const mediaUsageWorkListResponseSchema = z.object({
+	items: z.array(mediaUsageWorkItemSchema),
+	nextCursor: z.string().optional()
+}).meta({ id: "MediaUsageWorkListResponse" });
+const boundedOpaqueMediaUsageId = z.string().min(1).max(2048);
+const mediaUsageWorkRetryBody = z.object({
+	collectionId: boundedOpaqueMediaUsageId.meta({ description: "Current immutable collection identity" }),
+	contentId: boundedOpaqueMediaUsageId.meta({ description: "Content entry identity, including a deleted entry" })
+}).strict().meta({ id: "MediaUsageWorkRetryBody" });
+const mediaUsageWorkRetryResponseSchema = z.object({
+	changed: z.boolean(),
+	item: mediaUsageWorkItemSchema
+}).meta({ id: "MediaUsageWorkRetryResponse" });
+const mediaUsageWorkRetryConflictSchema = z.object({
+	success: z.literal(false),
+	error: z.discriminatedUnion("code", [z.object({
+		code: z.literal("WORK_LEASE_ACTIVE"),
+		message: z.string(),
+		details: z.object({ leaseExpiresAt: z.string() })
+	}), z.object({
+		code: z.literal("WORK_CHANGED"),
+		message: z.string()
+	})])
+});
+const mediaUsageActivationStateSchema = z.enum([
+	"expanded",
+	"activating",
+	"active"
+]).meta({ id: "MediaUsageActivationState" });
+const mediaUsageActivationStatusSchema = z.object({
+	state: mediaUsageActivationStateSchema,
+	collectionCursor: z.string().nullable(),
+	attemptCount: z.number().int().min(0),
+	drainConfirmedAt: z.string().nullable(),
+	lastAttemptedAt: z.string().nullable(),
+	lastErrorCode: z.literal("MEDIA_USAGE_ACTIVATION_FAILED").nullable(),
+	leaseExpiresAt: z.string().nullable(),
+	activatedAt: z.string().nullable(),
+	updatedAt: z.string()
+}).meta({ id: "MediaUsageActivationStatus" });
+const mediaUsageActivationAdvanceBody = z.object({ writersDrained: z.literal(true) }).strict().meta({ id: "MediaUsageActivationAdvanceBody" });
+const mediaUsageActivationAdvanceResponseSchema = z.object({
+	outcome: z.enum(["activating", "active"]),
+	processedCollections: z.number().int().min(0).max(1),
+	activation: mediaUsageActivationStatusSchema
+}).meta({ id: "MediaUsageActivationAdvanceResponse" });
+const mediaUsageProgressAdvanceResponseSchema = z.object({
+	activation: mediaUsageActivationStatusSchema,
+	progress: mediaUsageProgressSchema.nullable(),
+	nextRequestInMs: z.union([
+		z.literal(0),
+		z.literal(3e4),
+		z.null()
+	])
+}).meta({ id: "MediaUsageProgressAdvanceResponse" });
+const mediaUsageActivationConflictSchema = z.object({
+	success: z.literal(false),
+	error: z.discriminatedUnion("code", [
+		z.object({
+			code: z.literal("MEDIA_USAGE_ACTIVATION_BUSY"),
+			message: z.string(),
+			details: z.object({ leaseExpiresAt: z.string() })
+		}),
+		z.object({
+			code: z.literal("MEDIA_USAGE_ACTIVATION_CONFLICT"),
+			message: z.string()
+		}),
+		z.object({
+			code: z.literal("MEDIA_USAGE_ACTIVATION_VERSION_MISMATCH"),
+			message: z.string()
+		})
+	])
+});
+const mediaUsageCollectionDeletionStateSchema = z.enum([
+	"pending",
+	"retry",
+	"leased",
+	"failed"
+]).meta({ id: "MediaUsageCollectionDeletionState" });
+const mediaUsageCollectionDeletionPhaseSchema = z.enum([
+	"fence",
+	"registry",
+	"table",
+	"work",
+	"sources",
+	"status",
+	"finalize"
+]).meta({ id: "MediaUsageCollectionDeletionPhase" });
+const mediaUsageCollectionDeletionListQuery = z.object({
+	state: mediaUsageCollectionDeletionStateSchema.optional().default("failed"),
+	cursor: z.string().min(1).max(2048).optional(),
+	limit: z.coerce.number().int().min(1).max(100).optional().default(50)
+}).meta({ id: "MediaUsageCollectionDeletionListQuery" });
+const mediaUsageCollectionDeletionItemSchema = z.object({
+	collectionId: z.string(),
+	collectionSlug: z.string(),
+	state: mediaUsageCollectionDeletionStateSchema,
+	phase: mediaUsageCollectionDeletionPhaseSchema,
+	attemptCount: z.number().int().min(0),
+	nextAttemptAt: z.string(),
+	leaseExpiresAt: z.string().nullable(),
+	lastErrorCode: z.string().nullable(),
+	updatedAt: z.string()
+}).meta({ id: "MediaUsageCollectionDeletionItem" });
+const mediaUsageCollectionDeletionListResponseSchema = z.object({
+	items: z.array(mediaUsageCollectionDeletionItemSchema),
+	nextCursor: z.string().optional()
+}).meta({ id: "MediaUsageCollectionDeletionListResponse" });
+const mediaUsageCollectionDeletionRetryBody = z.object({ collectionId: boundedOpaqueMediaUsageId }).strict().meta({ id: "MediaUsageCollectionDeletionRetryBody" });
+const mediaUsageCollectionDeletionRetryResponseSchema = z.object({
+	changed: z.boolean(),
+	item: mediaUsageCollectionDeletionItemSchema
+}).meta({ id: "MediaUsageCollectionDeletionRetryResponse" });
+
+//#endregion
+//#region src/api/schemas/media.ts
+/**
+* Accepts a comma-separated string (from URL query params) or an array of
+* strings (from JSON body or programmatic use) and normalises to string[].
+*/
+const mimeTypeFilter = z.union([z.string(), z.array(z.string())]).transform((v) => {
+	return (Array.isArray(v) ? v : v.split(",")).map((s) => s.trim()).filter((s) => s.length > 0);
+}).optional();
+const mediaListQuery = cursorPaginationQuery.extend({
+	page: z.coerce.number().int().min(1).max(Number.MAX_SAFE_INTEGER).optional(),
+	mimeType: mimeTypeFilter,
+	folderId: z.union([z.literal("unfiled"), z.string().min(1).max(64)]).optional().meta({ description: "Filter by a media folder ID. Use `unfiled` for the Main library; omit for all media." }),
+	q: z.string().trim().min(1).max(200).optional(),
+	includeUsage: z.literal("1").optional().meta({ description: "Include a coverage-aware usage summary on each media item" })
+}).refine(({ cursor, page }) => cursor === void 0 || page === void 0, {
+	message: "cursor and page cannot be used together",
+	path: ["page"]
+}).meta({ id: "MediaListQuery" });
+const mediaGetQuery = z.object({ includeUsage: z.literal("1").optional().meta({ description: "Include a coverage-aware usage summary on the media item" }) }).meta({ id: "MediaGetQuery" });
+const mediaUpdateBody = z.object({
+	alt: z.string().optional(),
+	caption: z.string().optional(),
+	width: z.number().int().positive().optional(),
+	height: z.number().int().positive().optional(),
+	folderId: z.union([z.literal("unfiled"), z.string().min(1).max(64)]).nullable().optional().transform((value) => value === "unfiled" ? null : value).meta({ description: "Assign a media folder ID, or use null or `unfiled` to return the item to the Main library." }),
+	focalX: z.number().min(0).max(1).nullable().optional(),
+	focalY: z.number().min(0).max(1).nullable().optional()
+}).superRefine((value, context) => {
+	if (!isValidFocalPointUpdate(value)) context.addIssue({
+		code: "custom",
+		message: "focalX and focalY must both be numbers or both be null",
+		path: ["focalX"]
+	});
+}).meta({ id: "MediaUpdateBody" });
+const mediaFolderIdSchema = z.string().min(1).max(64);
+const mediaFolderListQuery = cursorPaginationQuery.extend({ q: z.string().trim().min(1).max(200).optional() }).meta({ id: "MediaFolderListQuery" });
+const mediaFolderNameSchema = z.string().refine((value) => {
+	const length = value.trim().length;
+	return length >= 1 && length <= 200;
+}, { message: "Folder name must be between 1 and 200 characters" });
+const mediaFolderBody = z.object({ name: mediaFolderNameSchema }).meta({ id: "MediaFolderBody" });
+/** Default maximum allowed file upload size (50 MB). */
+const DEFAULT_MAX_UPLOAD_SIZE = 50 * 1024 * 1024;
+function formatFileSize(bytes) {
+	if (bytes < 1024) return `${bytes}B`;
+	if (bytes < 1024 * 1024) return `${Math.floor(bytes / 1024)}KB`;
+	return `${Math.floor(bytes / 1024 / 1024)}MB`;
+}
+const CONTENT_TYPE_RE = /^[a-z0-9][a-z0-9!#$&^_+\-.]*\/[a-z0-9!#$&^_+\-.]+(\s*;[^\r\n]*)?$/i;
+function mediaUploadUrlBody(maxSize) {
+	if (!Number.isFinite(maxSize) || maxSize <= 0) throw new Error(`EmDash: maxUploadSize must be a positive finite number, got ${maxSize}`);
+	return z.object({
+		filename: z.string().min(1, "filename is required"),
+		contentType: z.string().min(1, "contentType is required").regex(CONTENT_TYPE_RE, "Invalid content type"),
+		size: z.number().int().nonnegative().max(maxSize, `File size must not exceed ${formatFileSize(maxSize)}`),
+		contentHash: z.string().optional(),
+		fieldId: z.string().optional(),
+		deduplicate: z.boolean().optional(),
+		ensureUniqueFilename: z.boolean().optional(),
+		folderId: mediaFolderIdSchema.nullable().optional()
+	}).meta({ id: "MediaUploadUrlBody" });
+}
+const mediaUploadDeduplicateForm = z.enum(["true", "false"]).default("true").transform((value) => value === "true");
+const mediaUploadEnsureUniqueFilenameForm = z.enum(["true", "false"]).default("false").transform((value) => value === "true");
+const mediaReplaceMetadataForm = z.object({
+	width: z.coerce.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+	height: z.coerce.number().int().positive().max(Number.MAX_SAFE_INTEGER)
+});
+const binaryFileSchema = z.string().meta({ format: "binary" });
+const mediaDirectUploadBody = z.object({
+	file: binaryFileSchema,
+	width: z.string().optional(),
+	height: z.string().optional(),
+	thumbnail: binaryFileSchema.optional(),
+	fieldId: z.string().optional(),
+	deduplicate: z.enum(["true", "false"]).optional(),
+	ensureUniqueFilename: z.enum(["true", "false"]).optional(),
+	folderId: z.union([mediaFolderIdSchema, z.literal("unfiled")]).optional()
+}).meta({ id: "MediaDirectUploadBody" });
+const mediaReplaceBody = z.object({
+	file: binaryFileSchema,
+	width: z.number().int().positive(),
+	height: z.number().int().positive()
+}).meta({ id: "MediaReplaceBody" });
+const mediaConfirmBody = z.object({
+	size: z.number().int().nonnegative().optional(),
+	width: z.number().int().positive().optional(),
+	height: z.number().int().positive().optional()
+}).meta({ id: "MediaConfirmBody" });
+const mediaProviderListQuery = cursorPaginationQuery.extend({
+	query: z.string().optional(),
+	mimeType: mimeTypeFilter
+}).meta({ id: "MediaProviderListQuery" });
+const mediaStatusSchema = z.enum([
+	"pending",
+	"ready",
+	"failed"
+]);
+const mediaItemSchema = z.object({
+	id: z.string(),
+	filename: z.string(),
+	mimeType: z.string(),
+	size: z.number().nullable(),
+	width: z.number().nullable(),
+	height: z.number().nullable(),
+	focalX: z.number().nullable(),
+	focalY: z.number().nullable(),
+	alt: z.string().nullable(),
+	caption: z.string().nullable(),
+	storageKey: z.string(),
+	status: mediaStatusSchema,
+	contentHash: z.string().nullable(),
+	blurhash: z.string().nullable(),
+	dominantColor: z.string().nullable(),
+	createdAt: z.string(),
+	authorId: z.string().nullable(),
+	folderId: z.string().nullable()
+}).meta({ id: "MediaItem" });
+const mediaFolderSchema = z.object({
+	id: z.string(),
+	name: z.string()
+}).meta({ id: "MediaFolder" });
+const mediaFolderResponseSchema = z.object({ item: mediaFolderSchema }).meta({ id: "MediaFolderResponse" });
+const mediaFolderListResponseSchema = z.object({
+	items: z.array(mediaFolderSchema),
+	nextCursor: z.string().optional()
+}).meta({ id: "MediaFolderListResponse" });
+const mediaResponseSchema = z.object({ item: mediaItemSchema }).meta({ id: "MediaResponse" });
+const mediaReadItemSchema = mediaItemSchema.extend({ usage: mediaUsageSummarySchema.optional() }).meta({ id: "MediaReadItem" });
+const mediaReadResponseSchema = z.object({ item: mediaReadItemSchema }).meta({ id: "MediaReadResponse" });
+const mediaListReadItemSchema = mediaReadItemSchema.extend({ url: z.string() }).meta({ id: "MediaListReadItem" });
+const mediaListReadResponseSchema = z.object({
+	items: z.array(mediaListReadItemSchema),
+	nextCursor: z.string().optional(),
+	totalCount: z.number().int().nonnegative().optional()
+}).meta({ id: "MediaListReadResponse" });
+const mediaListResponseSchema = z.object({
+	items: z.array(mediaItemSchema),
+	nextCursor: z.string().optional(),
+	totalCount: z.number().int().nonnegative().optional()
+}).meta({ id: "MediaListResponse" });
+const mediaUploadUrlResponseSchema = z.object({
+	uploadUrl: z.string(),
+	method: z.literal("PUT"),
+	headers: z.record(z.string(), z.string()),
+	mediaId: z.string(),
+	storageKey: z.string(),
+	expiresAt: z.string()
+}).meta({ id: "MediaUploadUrlResponse" });
+const mediaExistingResponseSchema = z.object({
+	existing: z.literal(true),
+	mediaId: z.string(),
+	storageKey: z.string(),
+	url: z.string()
+}).meta({ id: "MediaExistingResponse" });
+const mediaConfirmResponseSchema = z.object({ item: mediaItemSchema.extend({ url: z.string() }) }).meta({ id: "MediaConfirmResponse" });
+const mediaUploadResponseSchema = z.object({
+	item: mediaItemSchema.extend({ url: z.string() }),
+	deduplicated: z.literal(true).optional()
+}).meta({ id: "MediaUploadResponse" });
+const mediaReplaceResponseSchema = z.object({ item: mediaItemSchema.extend({ url: z.string() }) }).meta({ id: "MediaReplaceResponse" });
+const mediaStreamUploadResponseSchema = z.object({
+	uploaded: z.literal(true),
+	size: z.number().int().nonnegative()
+}).meta({ id: "MediaStreamUploadResponse" });
+
+//#endregion
+//#region src/api/schemas/schema.ts
+const collectionSupportValues = z.enum([
+	"drafts",
+	"revisions",
+	"preview",
+	"scheduling",
+	"search",
+	"seo"
+]);
+const collectionSourcePattern = /^(template:.+|import:.+|manual|discovered|seed)$/;
+const collectionListColumns = z.array(z.string().min(1).max(63).regex(slugPattern, "Invalid field slug format"));
+const collectionAdminInputConfig = z.object({ listColumns: collectionListColumns.max(MAX_COLLECTION_LIST_COLUMNS, `At most ${MAX_COLLECTION_LIST_COLUMNS} list columns are allowed`).optional() });
+const collectionAdminResponseConfig = z.object({ listColumns: collectionListColumns.optional() });
+const fieldTypeValues = z.enum([
+	"string",
+	"text",
+	"url",
+	"number",
+	"integer",
+	"boolean",
+	"datetime",
+	"select",
+	"multiSelect",
+	"portableText",
+	"image",
+	"file",
+	"reference",
+	"json",
+	"slug",
+	"repeater"
+]);
+const repeaterSubFieldSchema = z.object({
+	slug: z.string().min(1).max(63).regex(slugPattern, "Invalid slug format"),
+	type: z.enum([
+		"string",
+		"text",
+		"url",
+		"number",
+		"integer",
+		"boolean",
+		"datetime",
+		"select",
+		"image"
+	]),
+	label: z.string().min(1),
+	required: z.boolean().optional(),
+	options: z.array(z.string()).optional()
+});
+const urlPatternValue = z.string().superRefine((pattern, ctx) => {
+	try {
+		compileUrlPattern(pattern);
+	} catch {
+		ctx.addIssue({
+			code: "custom",
+			message: "Invalid URL pattern"
+		});
+	}
+});
+const fieldValidation = z.object({
+	required: z.boolean().optional(),
+	min: z.number().optional(),
+	max: z.number().optional(),
+	minLength: z.number().int().min(0).optional(),
+	maxLength: z.number().int().min(0).optional(),
+	pattern: z.string().optional(),
+	options: z.array(z.string()).optional(),
+	subFields: z.array(repeaterSubFieldSchema).min(1).optional(),
+	minItems: z.number().int().min(0).optional(),
+	maxItems: z.number().int().min(1).optional(),
+	allowedMimeTypes: z.array(z.string().regex(/^[a-z0-9][a-z0-9!#$&^_+\-.]*\/[a-z0-9!#$&^_+\-.]*$/i, "Invalid MIME type")).min(1, "allowedMimeTypes must not be empty — omit the field to allow all types").max(64, "allowedMimeTypes may contain at most 64 entries").optional()
+}).superRefine((validation, ctx) => {
+	for (const [minimum, maximum] of [
+		["min", "max"],
+		["minLength", "maxLength"],
+		["minItems", "maxItems"]
+	]) {
+		const minimumValue = validation[minimum];
+		const maximumValue = validation[maximum];
+		if (minimumValue !== void 0 && maximumValue !== void 0 && minimumValue > maximumValue) ctx.addIssue({
+			code: "custom",
+			path: [maximum],
+			message: `${maximum} must be greater than or equal to ${minimum}`
+		});
+	}
+	if (validation.pattern !== void 0) try {
+		RegExp(validation.pattern);
+	} catch {
+		ctx.addIssue({
+			code: "custom",
+			path: ["pattern"],
+			message: "Invalid validation pattern"
+		});
+	}
+}).optional();
+const fieldWidgetOptions = z.record(z.string(), z.unknown()).optional();
+/** Admin sidebar folder label; an empty string clears it like `null`. */
+const navGroupValue = z.string().trim().max(MAX_COLLECTION_GROUP_LENGTH);
+const createCollectionBody = z.object({
+	slug: z.string().min(1).max(63).regex(slugPattern, "Invalid slug format"),
+	label: z.string().min(1),
+	labelSingular: z.string().optional(),
+	description: z.string().optional(),
+	icon: z.string().optional(),
+	admin: collectionAdminInputConfig.optional(),
+	supports: z.array(collectionSupportValues).optional(),
+	source: z.string().regex(collectionSourcePattern).optional(),
+	urlPattern: urlPatternValue.optional(),
+	routable: z.boolean().optional(),
+	hasSeo: z.boolean().optional(),
+	hidden: z.boolean().optional(),
+	sortOrder: z.number().int().nullish(),
+	editLocking: z.boolean().optional(),
+	group: navGroupValue.nullish()
+}).meta({ id: "CreateCollectionBody" });
+const updateCollectionBody = z.object({
+	label: z.string().min(1).optional(),
+	labelSingular: z.string().optional(),
+	description: z.string().optional(),
+	icon: z.string().optional(),
+	admin: collectionAdminInputConfig.optional(),
+	supports: z.array(collectionSupportValues).optional(),
+	urlPattern: urlPatternValue.nullish(),
+	routable: z.boolean().optional(),
+	hasSeo: z.boolean().optional(),
+	hidden: z.boolean().optional(),
+	sortOrder: z.number().int().nullish(),
+	group: navGroupValue.nullish(),
+	commentsEnabled: z.boolean().optional(),
+	commentsModeration: z.enum([
+		"all",
+		"first_time",
+		"none"
+	]).optional(),
+	commentsClosedAfterDays: z.number().int().min(0).optional(),
+	commentsAutoApproveUsers: z.boolean().optional(),
+	editLocking: z.boolean().optional(),
+	titleField: z.string().min(1).max(63).regex(slugPattern, "Invalid field slug format").nullish(),
+	dateField: z.string().min(1).max(63).regex(slugPattern, "Invalid field slug format").nullish()
+}).meta({ id: "UpdateCollectionBody" });
+const createFieldBody = z.object({
+	slug: z.string().min(1).max(63).regex(slugPattern, "Invalid slug format"),
+	label: z.string().min(1),
+	type: fieldTypeValues,
+	required: z.boolean().optional(),
+	unique: z.boolean().optional(),
+	defaultValue: z.unknown().optional(),
+	validation: fieldValidation.nullable(),
+	widget: z.string().optional(),
+	options: fieldWidgetOptions,
+	sortOrder: z.number().int().min(0).optional(),
+	searchable: z.boolean().optional(),
+	indexed: z.boolean().optional(),
+	translatable: z.boolean().optional()
+}).meta({ id: "CreateFieldBody" });
+const updateFieldBody = z.object({
+	label: z.string().min(1).optional(),
+	type: fieldTypeValues.optional(),
+	required: z.boolean().optional(),
+	unique: z.boolean().optional(),
+	defaultValue: z.unknown().optional(),
+	validation: fieldValidation.nullable(),
+	widget: z.string().optional(),
+	options: fieldWidgetOptions,
+	sortOrder: z.number().int().min(0).optional(),
+	searchable: z.boolean().optional(),
+	indexed: z.boolean().optional(),
+	translatable: z.boolean().optional()
+}).meta({ id: "UpdateFieldBody" });
+const fieldReorderBody = z.object({ fieldSlugs: z.array(z.string().min(1)) }).meta({ id: "FieldReorderBody" });
+const collectionReorderBody = z.object({ slugs: z.array(z.string().min(1)) }).meta({ id: "CollectionReorderBody" });
+const orphanRegisterBody = z.object({
+	label: z.string().optional(),
+	labelSingular: z.string().optional(),
+	description: z.string().optional()
+}).meta({ id: "OrphanRegisterBody" });
+const schemaExportQuery = z.object({ format: z.string().optional() });
+const collectionGetQuery = z.object({ includeFields: z.string().transform((v) => v === "true").optional() });
+const collectionSchema = z.object({
+	id: z.string(),
+	slug: z.string(),
+	label: z.string(),
+	labelSingular: z.string().nullable(),
+	description: z.string().nullable(),
+	icon: z.string().nullable(),
+	admin: collectionAdminResponseConfig.optional(),
+	supports: z.array(z.string()),
+	source: z.string().nullable(),
+	urlPattern: z.string().nullable(),
+	routable: z.boolean(),
+	hasSeo: z.boolean(),
+	hidden: z.boolean(),
+	sortOrder: z.number().int().nullable(),
+	editLocking: z.boolean(),
+	group: z.string().nullish(),
+	createdAt: z.string(),
+	updatedAt: z.string(),
+	titleField: z.string().nullish(),
+	dateField: z.string().nullish()
+}).meta({ id: "Collection" });
+const fieldSchema = z.object({
+	id: z.string(),
+	collectionId: z.string(),
+	slug: z.string(),
+	label: z.string(),
+	type: fieldTypeValues,
+	required: z.boolean(),
+	unique: z.boolean(),
+	defaultValue: z.unknown().nullable(),
+	validation: z.record(z.string(), z.unknown()).nullable(),
+	widget: z.string().nullable(),
+	options: z.record(z.string(), z.unknown()).nullable(),
+	sortOrder: z.number().int(),
+	searchable: z.boolean(),
+	indexed: z.boolean(),
+	translatable: z.boolean(),
+	createdAt: z.string(),
+	updatedAt: z.string()
+}).meta({ id: "Field" });
+const collectionResponseSchema = z.object({ item: collectionSchema }).meta({ id: "CollectionResponse" });
+const collectionWithFieldsResponseSchema = z.object({ item: collectionSchema.extend({ fields: z.array(fieldSchema) }) }).meta({ id: "CollectionWithFieldsResponse" });
+const collectionListResponseSchema = z.object({ items: z.array(collectionSchema) }).meta({ id: "CollectionListResponse" });
+const fieldResponseSchema = z.object({ item: fieldSchema }).meta({ id: "FieldResponse" });
+const fieldListResponseSchema = z.object({ items: z.array(fieldSchema) }).meta({ id: "FieldListResponse" });
+const orphanedTableSchema = z.object({
+	slug: z.string(),
+	tableName: z.string(),
+	rowCount: z.number().int()
+}).meta({ id: "OrphanedTable" });
+const orphanedTableListResponseSchema = z.object({ items: z.array(orphanedTableSchema) }).meta({ id: "OrphanedTableListResponse" });
+
+//#endregion
+//#region src/utils/url.ts
+/**
+* URL scheme validation utilities
+*
+* Prevents XSS via dangerous URL schemes (javascript:, data:, vbscript:, etc.)
+* by allowlisting known-safe schemes before rendering into href attributes.
+*/
+/**
+* Matches URLs that are safe to render in href attributes.
+*
+* Allowed:
+* - http:// and https://
+* - mailto: and tel:
+* - Relative paths (starting with /)
+* - Fragment links (starting with #)
+* - Protocol-relative URLs are NOT allowed (starting with //) as they can
+*   redirect to attacker-controlled hosts.
+*/
+const SAFE_URL_SCHEME_RE = /^(https?:|mailto:|tel:|\/(?!\/)|#)/i;
+/**
+* Returns the URL unchanged if it uses a safe scheme, otherwise returns "#".
+*
+* Use this at the render layer as the primary defense against XSS via
+* dangerous URL schemes like `javascript:`, `data:`, or `vbscript:`.
+*
+* @example
+* ```ts
+* sanitizeHref("https://example.com")        // "https://example.com"
+* sanitizeHref("/about")                      // "/about"
+* sanitizeHref("#section")                    // "#section"
+* sanitizeHref("mailto:a@b.com")              // "mailto:a@b.com"
+* sanitizeHref("javascript:alert(1)")         // "#"
+* sanitizeHref("data:text/html,<script>")     // "#"
+* sanitizeHref("")                            // "#"
+* ```
+*/
+function sanitizeHref(url) {
+	if (!url) return "#";
+	return SAFE_URL_SCHEME_RE.test(url) ? url : "#";
+}
+/**
+* Returns true if the URL uses a safe scheme for rendering in href attributes.
+*/
+function isSafeHref(url) {
+	return SAFE_URL_SCHEME_RE.test(url);
+}
+
+//#endregion
+//#region src/api/schemas/menus.ts
+/**
+* Allowed menu item types. `custom` uses `customUrl`; the others resolve a URL
+* from `referenceCollection` + `referenceId` (a translation_group id).
+*/
+const menuItemTypeEnum = z.enum([
+	"custom",
+	"page",
+	"post",
+	"taxonomy",
+	"collection"
+]);
+const safeHref = z.string().trim().refine(isSafeHref, "URL must use http, https, mailto, tel, a relative path, or a fragment identifier");
+const createMenuBody = z.object({
+	name: z.string().min(1),
+	label: z.string().min(1),
+	locale: localeCode.optional(),
+	translationOf: z.string().min(1).optional()
+}).strict().meta({ id: "CreateMenuBody" });
+const updateMenuBody = z.object({ label: z.string().min(1).optional() }).strict().meta({ id: "UpdateMenuBody" });
+const createMenuItemBody = z.object({
+	type: menuItemTypeEnum,
+	label: z.string().min(1),
+	referenceCollection: z.string().optional(),
+	referenceId: z.string().optional(),
+	customUrl: safeHref.optional(),
+	target: z.string().optional(),
+	titleAttr: z.string().optional(),
+	cssClasses: z.string().optional(),
+	parentId: z.string().optional(),
+	sortOrder: z.number().int().min(0).optional()
+}).strict().meta({ id: "CreateMenuItemBody" });
+const updateMenuItemBody = z.object({
+	label: z.string().min(1).optional(),
+	customUrl: safeHref.optional(),
+	target: z.string().optional(),
+	titleAttr: z.string().optional(),
+	cssClasses: z.string().optional(),
+	parentId: z.string().nullish(),
+	sortOrder: z.number().int().min(0).optional()
+}).strict().meta({ id: "UpdateMenuItemBody" });
+const reorderMenuItemsBody = z.object({ items: z.array(z.object({
+	id: z.string().min(1),
+	parentId: z.string().nullable(),
+	sortOrder: z.number().int().min(0)
+})) }).meta({ id: "ReorderMenuItemsBody" });
+const menuSchema = z.object({
+	id: z.string(),
+	name: z.string(),
+	label: z.string(),
+	createdAt: z.string(),
+	updatedAt: z.string(),
+	locale: z.string(),
+	translationGroup: z.string().nullable()
+}).meta({ id: "Menu" });
+const menuItemSchema = z.object({
+	id: z.string(),
+	menuId: z.string(),
+	parentId: z.string().nullable(),
+	sortOrder: z.number().int(),
+	type: z.string(),
+	referenceCollection: z.string().nullable(),
+	referenceId: z.string().nullable(),
+	customUrl: z.string().nullable(),
+	label: z.string(),
+	titleAttr: z.string().nullable(),
+	target: z.string().nullable(),
+	cssClasses: z.string().nullable(),
+	createdAt: z.string(),
+	locale: z.string(),
+	translationGroup: z.string().nullable()
+}).meta({ id: "MenuItem" });
+const menuTranslationsSchema = z.object({
+	translationGroup: z.string().nullable(),
+	translations: z.array(z.object({
+		id: z.string(),
+		name: z.string(),
+		label: z.string(),
+		locale: z.string(),
+		updatedAt: z.string()
+	}))
+}).meta({ id: "MenuTranslations" });
+const menuListItemSchema = menuSchema.extend({ itemCount: z.number().int() }).meta({ id: "MenuListItem" });
+const menuWithItemsSchema = menuSchema.extend({ items: z.array(menuItemSchema) }).meta({ id: "MenuWithItems" });
+
+//#endregion
+//#region src/api/schemas/taxonomies.ts
+const collectionSlug = z.string().min(1).max(63).regex(/^[a-z][a-z0-9_]*$/, "Invalid collection slug format");
+const createTaxonomyDefBody = z.object({
+	name: z.string().min(1).max(63).regex(/^[a-z][a-z0-9_]*$/, "Name must be lowercase alphanumeric with underscores"),
+	label: z.string().min(1).max(200),
+	labelSingular: z.string().min(1).max(200).optional(),
+	hierarchical: z.boolean().optional(),
+	collections: z.array(collectionSlug).max(100).optional(),
+	locale: localeCode.optional(),
+	translationOf: z.string().min(1).optional()
+}).meta({ id: "CreateTaxonomyDefBody" });
+/**
+* `name` and `locale` are absent on purpose: both identify the definition row
+* being written, and `.strict()` turns an attempt to change either into a 400
+* rather than a silently ignored field.
+*/
+const updateTaxonomyDefBody = z.object({
+	label: z.string().min(1).max(200).optional(),
+	labelSingular: z.string().min(1).max(200).nullish(),
+	hierarchical: z.boolean().optional(),
+	collections: z.array(collectionSlug).max(100).optional()
+}).strict().meta({ id: "UpdateTaxonomyDefBody" });
+const createTermBody = z.object({
+	slug: z.string().min(1).optional().meta({ description: "Term slug. Omit to derive a unique slug from the label." }),
+	label: z.string().min(1),
+	parentId: z.string().nullish(),
+	description: z.string().optional(),
+	locale: localeCode.optional(),
+	translationOf: z.string().min(1).optional()
+}).meta({ id: "CreateTermBody" });
+const updateTermBody = z.object({
+	slug: z.string().min(1).optional(),
+	label: z.string().min(1).optional(),
+	parentId: z.string().nullish(),
+	description: z.string().optional()
+}).meta({ id: "UpdateTermBody" });
+const reorderTermsBody = z.object({
+	parentId: z.string().min(1).nullish().meta({ description: "Parent term whose children are being ordered (translation_group or row id). Omit or null for the top level, which for a flat taxonomy is every term." }),
+	ids: z.array(z.string().min(1)).max(100).meta({ description: "Terms to move, in the desired order — each a row id or translation_group. May be a subset of the group: the listed terms are permuted within the positions they already occupy and every other member keeps its place. An id outside the group is rejected with REORDER_MISMATCH." })
+}).strict().meta({ id: "ReorderTermsBody" });
+const termListQuery = z.object({
+	locale: localeCode.optional(),
+	includeCounts: z.enum(["true", "false"]).transform((v) => v === "true").optional().default(true).meta({ description: "Include each term's visible-usage count. Pass false to skip the aggregate; `count` is then absent from every term." }),
+	resolveFallback: z.enum(["true", "false"]).transform((value) => value === "true").optional().default(false).meta({ description: "Resolve one term per translation group, preferring the requested locale and then the configured default locale." })
+}).meta({ id: "TermListQuery" });
+const taxonomyDefSchema = z.object({
+	id: z.string(),
+	name: z.string(),
+	label: z.string(),
+	labelSingular: z.string().optional(),
+	hierarchical: z.boolean(),
+	collections: z.array(z.string()),
+	locale: z.string(),
+	translationGroup: z.string().nullable()
+}).meta({ id: "TaxonomyDef" });
+const taxonomyDefTranslationsSchema = z.object({
+	translationGroup: z.string().nullable(),
+	translations: z.array(z.object({
+		id: z.string(),
+		name: z.string(),
+		label: z.string(),
+		locale: z.string()
+	}))
+}).meta({ id: "TaxonomyDefTranslations" });
+const taxonomyListResponseSchema = z.object({ taxonomies: z.array(taxonomyDefSchema) }).meta({ id: "TaxonomyListResponse" });
+const taxonomyResponseSchema = z.object({ taxonomy: taxonomyDefSchema }).meta({ id: "TaxonomyResponse" });
+const termSchema = z.object({
+	id: z.string(),
+	name: z.string(),
+	slug: z.string(),
+	label: z.string(),
+	parentId: z.string().nullable(),
+	description: z.string().optional(),
+	locale: z.string(),
+	translationGroup: z.string().nullable()
+}).meta({ id: "Term" });
+const termTranslationsSchema = z.object({
+	translationGroup: z.string().nullable(),
+	translations: z.array(z.object({
+		id: z.string(),
+		slug: z.string(),
+		label: z.string(),
+		locale: z.string()
+	}))
+}).meta({ id: "TermTranslations" });
+const termWithCountSchema = z.object({
+	id: z.string(),
+	name: z.string(),
+	slug: z.string(),
+	label: z.string(),
+	parentId: z.string().nullable(),
+	description: z.string().optional(),
+	count: z.number().int().optional(),
+	children: z.array(z.lazy(() => termWithCountSchema)),
+	locale: z.string(),
+	translationGroup: z.string().nullable()
+}).meta({ id: "TermWithCount" });
+const termListResponseSchema = z.object({ terms: z.array(termWithCountSchema) }).meta({ id: "TermListResponse" });
+const termResponseSchema = z.object({ term: termSchema }).meta({ id: "TermResponse" });
+const termReorderResponseSchema = z.object({ reordered: z.literal(true) }).meta({ id: "TermReorderResponse" });
+const termGetResponseSchema = z.object({ term: termSchema.extend({
+	count: z.number().int(),
+	children: z.array(z.object({
+		id: z.string(),
+		slug: z.string(),
+		label: z.string()
+	}))
+}) }).meta({ id: "TermGetResponse" });
+
+//#endregion
+//#region src/api/schemas/sections.ts
+const sectionSource = z.enum([
+	"theme",
+	"user",
+	"import"
+]);
+const sectionsListQuery = z.object({
+	source: sectionSource.optional(),
+	search: z.string().optional(),
+	limit: z.coerce.number().int().min(1).max(100).optional().default(50),
+	cursor: z.string().max(2048).optional()
+}).meta({ id: "SectionsListQuery" });
+const createSectionBody = z.object({
+	slug: z.string().min(1),
+	title: z.string().min(1),
+	description: z.string().optional(),
+	keywords: z.array(z.string()).optional(),
+	content: z.array(z.record(z.string(), z.unknown())),
+	previewMediaId: z.string().optional(),
+	source: z.enum(["user", "import"]).optional(),
+	themeId: z.string().optional()
+}).meta({ id: "CreateSectionBody" });
+const updateSectionBody = z.object({
+	slug: z.string().min(1).optional(),
+	title: z.string().min(1).optional(),
+	description: z.string().optional(),
+	keywords: z.array(z.string()).optional(),
+	content: z.array(z.record(z.string(), z.unknown())).optional(),
+	previewMediaId: z.string().nullish()
+}).meta({ id: "UpdateSectionBody" });
+const sectionSchema = z.object({
+	id: z.string(),
+	slug: z.string(),
+	title: z.string(),
+	description: z.string().nullable(),
+	keywords: z.array(z.string()).nullable(),
+	content: z.array(z.record(z.string(), z.unknown())),
+	previewMediaId: z.string().nullable(),
+	source: z.string(),
+	themeId: z.string().nullable(),
+	createdAt: z.string(),
+	updatedAt: z.string()
+}).meta({ id: "Section" });
+const sectionListResponseSchema = z.object({
+	items: z.array(sectionSchema),
+	nextCursor: z.string().optional()
+}).meta({ id: "SectionListResponse" });
+
+//#endregion
+//#region src/api/schemas/settings.ts
+const mediaReferenceInput = z.object({
+	mediaId: z.string(),
+	alt: z.string().optional()
+});
+const socialSettings = z.object({
+	twitter: z.string().optional(),
+	github: z.string().optional(),
+	facebook: z.string().optional(),
+	instagram: z.string().optional(),
+	linkedin: z.string().optional(),
+	youtube: z.string().optional()
+});
+const seoSettingsInput = z.object({
+	titleSeparator: z.string().max(10).optional(),
+	defaultOgImage: mediaReferenceInput.optional(),
+	robotsTxt: z.string().max(5e3).optional(),
+	googleVerification: z.string().max(100).optional(),
+	bingVerification: z.string().max(100).optional()
+});
+const settingsUpdateBody = z.object({
+	title: z.string().optional(),
+	tagline: z.string().optional(),
+	logo: mediaReferenceInput.optional(),
+	favicon: mediaReferenceInput.optional(),
+	url: z.union([httpUrl, z.literal("")]).optional(),
+	postsPerPage: z.number().int().min(1).max(100).optional(),
+	dateFormat: z.string().optional(),
+	timezone: z.string().optional(),
+	social: socialSettings.optional(),
+	seo: seoSettingsInput.optional()
+}).meta({ id: "SettingsUpdateBody" });
+const mediaReferenceResponse = z.object({
+	mediaId: z.string(),
+	alt: z.string().optional(),
+	url: z.string().optional(),
+	contentType: z.string().optional(),
+	width: z.number().int().optional(),
+	height: z.number().int().optional()
+});
+const seoSettingsResponse = z.object({
+	titleSeparator: z.string().max(10).optional(),
+	defaultOgImage: mediaReferenceResponse.optional(),
+	robotsTxt: z.string().max(5e3).optional(),
+	googleVerification: z.string().max(100).optional(),
+	bingVerification: z.string().max(100).optional()
+});
+const siteSettingsSchema = z.object({
+	title: z.string().optional(),
+	tagline: z.string().optional(),
+	logo: mediaReferenceResponse.optional(),
+	favicon: mediaReferenceResponse.optional(),
+	url: z.string().optional(),
+	postsPerPage: z.number().int().optional(),
+	dateFormat: z.string().optional(),
+	timezone: z.string().optional(),
+	social: socialSettings.optional(),
+	seo: seoSettingsResponse.optional()
+}).meta({ id: "SiteSettings" });
+
+//#endregion
+//#region src/api/schemas/search.ts
+const searchQuery = z.object({
+	q: z.string().min(1),
+	collections: z.string().optional(),
+	status: z.string().optional(),
+	locale: localeCode.optional(),
+	limit: z.coerce.number().int().min(1).max(100).optional(),
+	cursor: z.string().optional(),
+	scope: z.enum(["all", "title"]).optional().meta({ description: "Which indexed fields to match against. 'title' matches only the collection's title field; collections without an indexed title field return no results. Defaults to 'all'." })
+}).meta({ id: "SearchQuery" });
+const searchSuggestQuery = z.object({
+	q: z.string().min(1),
+	collections: z.string().optional(),
+	locale: localeCode.optional(),
+	limit: z.coerce.number().int().min(1).max(20).optional()
+}).meta({ id: "SearchSuggestQuery" });
+const searchRebuildBody = z.object({ collection: z.string().min(1) }).meta({ id: "SearchRebuildBody" });
+const searchEnableBody = z.object({
+	collection: z.string().min(1),
+	enabled: z.boolean(),
+	weights: z.record(z.string(), z.number()).optional(),
+	tokenize: z.enum(SEARCH_TOKENIZERS).optional()
+}).meta({ id: "SearchEnableBody" });
+const searchResultSchema = z.object({
+	collection: z.string(),
+	id: z.string(),
+	slug: z.string().nullable(),
+	locale: z.string(),
+	title: z.string().optional(),
+	snippet: z.string().optional(),
+	score: z.number()
+}).meta({ id: "SearchResult" });
+const searchResponseSchema = z.object({
+	items: z.array(searchResultSchema),
+	nextCursor: z.string().optional()
+}).meta({ id: "SearchResponse" });
+
+//#endregion
+//#region src/api/schemas/users.ts
+const usersListQuery = z.object({
+	search: z.string().optional(),
+	role: z.string().optional(),
+	cursor: z.string().max(2048).optional(),
+	limit: z.coerce.number().int().min(1).max(100).optional().default(50)
+}).meta({ id: "UsersListQuery" });
+const userUpdateBody = z.object({
+	name: z.string().optional(),
+	email: z.email().optional(),
+	role: roleLevel.optional()
+}).meta({ id: "UserUpdateBody" });
+const allowedDomainCreateBody = z.object({
+	domain: z.string().min(1),
+	defaultRole: roleLevel
+}).meta({ id: "AllowedDomainCreateBody" });
+const allowedDomainUpdateBody = z.object({
+	enabled: z.boolean().optional(),
+	defaultRole: roleLevel.optional()
+}).meta({ id: "AllowedDomainUpdateBody" });
+const userSchema = z.object({
+	id: z.string(),
+	email: z.string(),
+	name: z.string().nullable(),
+	avatarUrl: z.string().nullable(),
+	role: z.number().int(),
+	emailVerified: z.boolean(),
+	disabled: z.boolean(),
+	createdAt: z.string(),
+	updatedAt: z.string(),
+	lastLogin: z.string().nullable(),
+	credentialCount: z.number().int().optional(),
+	oauthProviders: z.array(z.string()).optional()
+}).meta({ id: "User" });
+const userListResponseSchema = z.object({
+	items: z.array(userSchema),
+	nextCursor: z.string().optional()
+}).meta({ id: "UserListResponse" });
+const userDetailSchema = z.object({
+	id: z.string(),
+	email: z.string(),
+	name: z.string().nullable(),
+	avatarUrl: z.string().nullable(),
+	role: z.number().int(),
+	emailVerified: z.boolean(),
+	disabled: z.boolean(),
+	createdAt: z.string(),
+	updatedAt: z.string(),
+	lastLogin: z.string().nullable(),
+	credentials: z.array(z.object({
+		id: z.string(),
+		name: z.string().nullable(),
+		deviceType: z.string().nullable(),
+		createdAt: z.string(),
+		lastUsedAt: z.string()
+	})),
+	oauthAccounts: z.array(z.object({
+		provider: z.string(),
+		createdAt: z.string()
+	}))
+}).meta({ id: "UserDetail" });
+
+//#endregion
+//#region src/api/schemas/widgets.ts
+const widgetType = z.enum([
+	"content",
+	"menu",
+	"component"
+]);
+const createWidgetAreaBody = z.object({
+	name: z.string().min(1),
+	label: z.string().min(1),
+	description: z.string().optional()
+}).meta({ id: "CreateWidgetAreaBody" });
+const createWidgetBody = z.object({
+	type: widgetType,
+	title: z.string().optional(),
+	content: z.array(z.record(z.string(), z.unknown())).optional(),
+	menuName: z.string().optional(),
+	componentId: z.string().optional(),
+	componentProps: z.record(z.string(), z.unknown()).optional()
+}).meta({ id: "CreateWidgetBody" });
+const updateWidgetBody = z.object({
+	type: widgetType.optional(),
+	title: z.string().optional(),
+	content: z.array(z.record(z.string(), z.unknown())).optional(),
+	menuName: z.string().optional(),
+	componentId: z.string().optional(),
+	componentProps: z.record(z.string(), z.unknown()).optional()
+}).meta({ id: "UpdateWidgetBody" });
+const reorderWidgetsBody = z.object({ widgetIds: z.array(z.string().min(1)) }).meta({ id: "ReorderWidgetsBody" });
+const widgetAreaSchema = z.object({
+	id: z.string(),
+	name: z.string(),
+	label: z.string(),
+	description: z.string().nullable(),
+	created_at: z.string(),
+	updated_at: z.string()
+}).meta({ id: "WidgetArea" });
+const widgetSchema = z.object({
+	id: z.string(),
+	type: widgetType,
+	title: z.string().optional(),
+	content: z.array(z.record(z.string(), z.unknown())).optional(),
+	menuName: z.string().optional(),
+	componentId: z.string().optional(),
+	componentProps: z.record(z.string(), z.unknown()).optional()
+}).meta({ id: "Widget" });
+const widgetAreaWithWidgetsSchema = widgetAreaSchema.extend({ widgets: z.array(widgetSchema) }).meta({ id: "WidgetAreaWithWidgets" });
+const widgetAreaWithWidgetsAndCountSchema = widgetAreaWithWidgetsSchema.extend({ widgetCount: z.number().int() }).meta({ id: "WidgetAreaWithWidgetsAndCount" });
+
+//#endregion
+//#region src/api/schemas/entry-lock.ts
+const entryLockAcquireBody = z.object({
+	takeover: z.boolean().optional().meta({ description: "Take the lock from whoever holds it. Their next heartbeat or save reports the new holder." }),
+	token: z.string().min(1).max(128).optional().meta({ description: "Identifies the caller's editing session. Send the same value on DELETE so a release from one tab does not drop a lock another tab of the same account still relies on." })
+}).meta({ id: "EntryLockAcquireBody" });
+const entryLockHolderSchema = z.object({
+	userId: z.string(),
+	userName: z.string().nullable(),
+	acquiredAt: z.string(),
+	expiresAt: z.string()
+}).meta({ id: "EntryLockHolder" });
+const entryLockStatusSchema = z.object({
+	enabled: z.boolean().meta({ description: "Whether the collection takes edit locks at all" }),
+	holder: entryLockHolderSchema.nullable(),
+	heldByCaller: z.boolean()
+}).meta({ id: "EntryLockStatus" });
+const entryLockReleaseResponseSchema = z.object({ released: z.boolean() }).meta({ id: "EntryLockReleaseResponse" });
+const entryLockConflictSchema = z.object({
+	success: z.literal(false),
+	error: z.object({
+		code: z.literal("ENTRY_LOCKED"),
+		message: z.string(),
+		details: entryLockHolderSchema
+	})
+});
+const entryMutationConflictSchema = z.object({
+	success: z.literal(false),
+	error: z.object({
+		code: z.string().meta({ examples: ["CONFLICT", "ENTRY_LOCKED"] }),
+		message: z.string(),
+		details: entryLockHolderSchema.optional()
+	})
+});
+
+//#endregion
+export { createMenuItemBody as $, contentRevisionConditionBody as $n, mediaReplaceResponseSchema as $t, createSectionBody as A, mediaUsageRepairResponseSchema as An, DEFAULT_MAX_UPLOAD_SIZE as At, taxonomyListResponseSchema as B, mediaUsageWorkStateSchema as Bn, mediaFolderResponseSchema as Bt, searchQuery as C, mediaUsageDetailsResponseSchema as Cn, orphanRegisterBody as Ct, searchSuggestQuery as D, mediaUsageProgressSchema as Dn, updateCollectionBody as Dt, searchResultSchema as E, mediaUsageProgressAdvanceResponseSchema as En, schemaExportQuery as Et, createTaxonomyDefBody as F, mediaUsageWorkListQuery as Fn, mediaExistingResponseSchema as Ft, termReorderResponseSchema as G, contentFieldFiltersSchema as Gn, mediaListReadItemSchema as Gt, termGetResponseSchema as H, contentAuthorsResponseSchema as Hn, mediaGetQuery as Ht, createTermBody as I, mediaUsageWorkListResponseSchema as In, mediaFolderBody as It, termTranslationsSchema as J, contentListResponseSchema as Jn, mediaProviderListQuery as Jt, termResponseSchema as K, contentItemSchema as Kn, mediaListReadResponseSchema as Kt, reorderTermsBody as L, mediaUsageWorkRetryBody as Ln, mediaFolderIdSchema as Lt, sectionSchema as M, mediaUsageSourceDetailSchema as Mn, mediaConfirmBody as Mt, sectionsListQuery as N, mediaUsageSummarySchema as Nn, mediaConfirmResponseSchema as Nt, settingsUpdateBody as O, mediaUsageRepairBody as On, updateFieldBody as Ot, updateSectionBody as P, mediaUsageWorkItemSchema as Pn, mediaDirectUploadBody as Pt, createMenuBody as Q, contentRestoreResponseSchema as Qn, mediaReplaceMetadataForm as Qt, taxonomyDefSchema as R, mediaUsageWorkRetryConflictSchema as Rn, mediaFolderListQuery as Rt, searchEnableBody as S, mediaUsageDetailsQuery as Sn, fieldSchema as St, searchResponseSchema as T, mediaUsageOccurrenceDetailSchema as Tn, orphanedTableSchema as Tt, termListQuery as U, contentCompareResponseSchema as Un, mediaItemSchema as Ut, taxonomyResponseSchema as V, contentAuthorSchema as Vn, mediaFolderSchema as Vt, termListResponseSchema as W, contentCreateBody as Wn, mediaListQuery as Wt, updateTaxonomyDefBody as X, contentPublishBody as Xn, mediaReadResponseSchema as Xt, termWithCountSchema as Y, contentPreviewUrlBody as Yn, mediaReadItemSchema as Yt, updateTermBody as Z, contentResponseSchema as Zn, mediaReplaceBody as Zt, userDetailSchema as _, mediaUsageCollectionDeletionRetryBody as _n, bylineUpdateBody as _r, createCollectionBody as _t, entryLockStatusSchema as a, mediaUploadResponseSchema as an, contentTranslationSchema as ar, menuWithItemsSchema as at, userUpdateBody as b, mediaUsageCoverageSchema as bn, fieldReorderBody as bt, createWidgetBody as c, mediaUsageActivationAdvanceBody as cn, contentUpdateBody as cr, updateMenuItemBody as ct, widgetAreaSchema as d, mediaUsageActivationStateSchema as dn, bylineCreateBody as dr, collectionGetQuery as dt, mediaResponseSchema as en, contentScheduleBody as er, menuItemSchema as et, widgetAreaWithWidgetsAndCountSchema as f, mediaUsageActivationStatusSchema as fn, bylineCreditSchema as fr, collectionListResponseSchema as ft, allowedDomainUpdateBody as g, mediaUsageCollectionDeletionPhaseSchema as gn, bylineTranslationsResponseSchema as gr, collectionWithFieldsResponseSchema as gt, allowedDomainCreateBody as h, mediaUsageCollectionDeletionListResponseSchema as hn, bylineTranslationCreateBody as hr, collectionSchema as ht, entryLockReleaseResponseSchema as i, mediaUploadEnsureUniqueFilenameForm as in, contentTermsResponseSchema as ir, menuTranslationsSchema as it, sectionListResponseSchema as j, mediaUsageRepairStatusSchema as jn, formatFileSize as jt, siteSettingsSchema as k, mediaUsageRepairCollectionSummarySchema as kn, CONTENT_TYPE_RE as kt, reorderWidgetsBody as l, mediaUsageActivationAdvanceResponseSchema as ln, trashedContentItemSchema as lr, isSafeHref as lt, widgetSchema as m, mediaUsageCollectionDeletionListQuery as mn, bylineSummarySchema as mr, collectionResponseSchema as mt, entryLockConflictSchema as n, mediaUpdateBody as nn, contentSeoSchema as nr, menuListItemSchema as nt, entryMutationConflictSchema as o, mediaUploadUrlBody as on, contentTranslationsResponseSchema as or, reorderMenuItemsBody as ot, widgetAreaWithWidgetsSchema as p, mediaUsageCollectionDeletionItemSchema as pn, bylineListResponseSchema as pr, collectionReorderBody as pt, termSchema as q, contentListQuery as qn, mediaListResponseSchema as qt, entryLockHolderSchema as r, mediaUploadDeduplicateForm as rn, contentTermsBody as rr, menuSchema as rt, createWidgetAreaBody as s, mediaUploadUrlResponseSchema as sn, contentTrashQuery as sr, updateMenuBody as st, entryLockAcquireBody as t, mediaStreamUploadResponseSchema as tn, contentSeoInput as tr, menuItemTypeEnum as tt, updateWidgetBody as u, mediaUsageActivationConflictSchema as un, trashedContentListResponseSchema as ur, sanitizeHref as ut, userListResponseSchema as v, mediaUsageCollectionDeletionRetryResponseSchema as vn, bylinesListQuery as vr, createFieldBody as vt, searchRebuildBody as w, mediaUsageEntryDetailSchema as wn, orphanedTableListResponseSchema as wt, usersListQuery as x, mediaUsageCoverageStatusSchema as xn, fieldResponseSchema as xt, userSchema as y, mediaUsageCollectionDeletionStateSchema as yn, contentBylineInputSchema as yr, fieldListResponseSchema as yt, taxonomyDefTranslationsSchema as z, mediaUsageWorkRetryResponseSchema as zn, mediaFolderListResponseSchema as zt };
+//# sourceMappingURL=entry-lock-D3C99MXS.mjs.map