emdash 0.33.0 → 0.35.0

package/dist/{menus-Y54RDPIN.mjs → menus-DSo5QeW0.mjs}

@@ -1,17 +1,19 @@
 import { t as validateIdentifier } from "./validate-BpwoDOgt.mjs";
 import { n as cachedQuery, t as CacheNamespace } from "./object-cache-71tPfV4A.mjs";
-import { a as decodeCursor, o as encodeCursor } from "./types-Cd8iuS1J.mjs";
-import { t as CommentRepository } from "./comment-BIkJ6Fil.mjs";
+import { n as chunks, t as SQL_BATCH_SIZE } from "./chunks-fiZ8G9RJ.mjs";
+import { o as decodeCursor, s as encodeCursor } from "./types-CQPWhPxE.mjs";
+import { t as CommentRepository } from "./comment-Dxlep6cE.mjs";
 import { t as OptionsRepository } from "./options-CBXIHUoT.mjs";
-import { t as PluginContextFactory } from "./context-C_1nrqnW.mjs";
+import { t as PluginContextFactory } from "./context-ZldbZcle.mjs";
 import { r as requestCached } from "./request-cache-BSUptuJR.mjs";
-import { i as resolveLocaleChain, r as resolveLocale } from "./resolve-DZzG4HqM.mjs";
-import { o as getDb } from "./loader-CGugY7Zl.mjs";
-import { a as normalizeCapabilities } from "./types-DKuWPYV5.mjs";
-import { mt as sanitizeHref } from "./redirects-G8wAhWAf.mjs";
-import { t as extractRequestMeta } from "./request-meta-Df-jFbAd.mjs";
-import { r as setCronTasksEnabled } from "./cron-DRV-UC4K.mjs";
-import { t as CommentReactionRepository } from "./comment-reaction-D-laEceb.mjs";
+import { i as resolveLocaleChain, r as resolveLocale } from "./resolve-DOhVEvty.mjs";
+import { s as getDb } from "./loader-CdG_Ci3H.mjs";
+import { a as normalizeCapabilities } from "./types-CP1CflWf.mjs";
+import { gt as sanitizeHref } from "./redirects-DTDHWH31.mjs";
+import { t as extractRequestMeta } from "./request-meta-DgZJh3zG.mjs";
+import { r as setCronTasksEnabled } from "./cron-Y9aLtgrA.mjs";
+import { t as MediaUsageActivationWriteBlockedError } from "./media-usage-write-fence-aHEgN1zB.mjs";
+import { t as CommentReactionRepository } from "./comment-reaction-D-2J84UE.mjs";
 import { sql } from "kysely";
 import { ulid } from "ulidx";
 import { AsyncLocalStorage } from "node:async_hooks";
@@ -142,10 +144,17 @@ var AuditRepository = class {
 //#region src/fields/image.ts
 const imageSchema = z.object({
 	id: z.string(),
-	src: z.string(),
+	src: z.string().optional(),
 	alt: z.string().optional(),
 	width: z.number().optional(),
-	height: z.number().optional()
+	height: z.number().optional(),
+	filename: z.string().optional(),
+	mimeType: z.string().optional(),
+	blurhash: z.string().optional(),
+	dominantColor: z.string().optional(),
+	provider: z.string().optional(),
+	previewUrl: z.string().optional(),
+	meta: z.record(z.string(), z.unknown()).optional()
 });
 function image(options = {}) {
 	const validation = options.allowedTypes && options.allowedTypes.length > 0 ? { allowedMimeTypes: [...options.allowedTypes] } : void 0;
@@ -164,10 +173,13 @@ function image(options = {}) {
 function file(options = {}) {
 	const fileObjSchema = z.object({
 		id: z.string(),
-		url: z.string(),
-		filename: z.string(),
-		mimeType: z.string(),
-		size: z.number()
+		url: z.string().optional(),
+		src: z.string().optional(),
+		filename: z.string().optional(),
+		mimeType: z.string().optional(),
+		size: z.number().optional(),
+		provider: z.string().optional(),
+		meta: z.record(z.string(), z.unknown()).optional()
 	});
 	return {
 		type: "file",
@@ -239,10 +251,10 @@ function sanitizeGalleryImages(value, generateKey) {
 	if (!Array.isArray(value)) return [];
 	const images = [];
 	for (const entry of value) {
-		if (!isRecord(entry)) continue;
+		if (!isRecord$2(entry)) continue;
 		const record = entry;
 		const asset = record.asset;
-		if (!isRecord(asset)) continue;
+		if (!isRecord$2(asset)) continue;
 		const assetRecord = asset;
 		const image = {
 			_type: "image",
@@ -264,10 +276,85 @@ function sanitizeGalleryImages(value, generateKey) {
 	}
 	return images;
 }
-function isRecord(value) {
+function isRecord$2(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
+//#endregion
+//#region src/content/converters/mark-safety.ts
+const SUPPORTED_PORTABLE_TEXT_DECORATORS = new Set([
+	"strong",
+	"em",
+	"underline",
+	"strike-through",
+	"subscript",
+	"superscript",
+	"code"
+]);
+const SUPPORTED_PROSEMIRROR_MARKS = new Set([
+	"bold",
+	"strong",
+	"italic",
+	"em",
+	"underline",
+	"strike",
+	"strikethrough",
+	"subscript",
+	"superscript",
+	"code",
+	"link"
+]);
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function collectPortableTextMarks(value, inheritedMarkDefs, unsupported) {
+	if (Array.isArray(value)) {
+		for (const item of value) collectPortableTextMarks(item, inheritedMarkDefs, unsupported);
+		return;
+	}
+	if (!isRecord$1(value)) return;
+	let markDefs = inheritedMarkDefs;
+	if (Array.isArray(value.markDefs)) {
+		const localMarkDefs = new Map(inheritedMarkDefs);
+		for (const markDef of value.markDefs) if (isRecord$1(markDef) && typeof markDef._key === "string") localMarkDefs.set(markDef._key, markDef);
+		markDefs = localMarkDefs;
+	}
+	if (value._type === "span" && Array.isArray(value.marks)) for (const mark of value.marks) {
+		if (typeof mark !== "string" || SUPPORTED_PORTABLE_TEXT_DECORATORS.has(mark)) continue;
+		const markDef = markDefs.get(mark);
+		if (markDef?._type === "link") continue;
+		unsupported.add(typeof markDef?._type === "string" ? markDef._type : mark);
+	}
+	for (const [key, child] of Object.entries(value)) if (key !== "markDefs") collectPortableTextMarks(child, markDefs, unsupported);
+}
+function collectProseMirrorMarks(node, unsupported) {
+	for (const mark of node.marks ?? []) if (!SUPPORTED_PROSEMIRROR_MARKS.has(mark.type)) unsupported.add(mark.type);
+	for (const child of node.content ?? []) collectProseMirrorMarks(child, unsupported);
+}
+var UnsupportedPortableTextMarksError = class extends Error {
+	marks;
+	constructor(marks) {
+		const sortedMarks = [...new Set(marks)].toSorted();
+		super(`Unsupported Portable Text marks: ${sortedMarks.join(", ")}`);
+		this.name = "UnsupportedPortableTextMarksError";
+		this.marks = sortedMarks;
+	}
+};
+function findUnsupportedPortableTextMarks(blocks) {
+	const unsupported = /* @__PURE__ */ new Set();
+	for (const block of blocks) if (block._type === "block" || block._type === "table") collectPortableTextMarks(block, /* @__PURE__ */ new Map(), unsupported);
+	return [...unsupported].toSorted();
+}
+function assertPortableTextMarksSupported(blocks) {
+	const unsupported = findUnsupportedPortableTextMarks(blocks);
+	if (unsupported.length > 0) throw new UnsupportedPortableTextMarksError(unsupported);
+}
+function assertProseMirrorMarksSupported(document) {
+	const unsupported = /* @__PURE__ */ new Set();
+	for (const node of document.content) collectProseMirrorMarks(node, unsupported);
+	if (unsupported.size > 0) throw new UnsupportedPortableTextMarksError(unsupported);
+}
+
 //#endregion
 //#region src/content/converters/numbered-list.ts
 const MAX_ORDERED_LIST_START = 2147483647;
@@ -402,6 +489,7 @@ function generateKey() {
 */
 function prosemirrorToPortableText(doc) {
 	if (!doc || doc.type !== "doc" || !doc.content) return [];
+	assertProseMirrorMarksSupported(doc);
 	const blocks = [];
 	for (const [i, node] of doc.content.entries()) {
 		const converted = convertNode(node, `root:${i}`);
@@ -658,6 +746,8 @@ function convertMark(mark, markDefs, markDefMap) {
 		case "underline": return "underline";
 		case "strike":
 		case "strikethrough": return "strike-through";
+		case "subscript": return "subscript";
+		case "superscript": return "superscript";
 		case "code": return "code";
 		case "link": {
 			const href = (typeof mark.attrs?.href === "string" ? mark.attrs.href : "") || "";
@@ -672,7 +762,7 @@ function convertMark(mark, markDefs, markDefMap) {
 			markDefMap.set(href, key);
 			return key;
 		}
-		default: return mark.type;
+		default: throw new UnsupportedPortableTextMarksError([mark.type]);
 	}
 }
 
@@ -691,6 +781,7 @@ function portableTextToProsemirror(blocks) {
 		type: "doc",
 		content: [{ type: "paragraph" }]
 	};
+	assertPortableTextMarksSupported(blocks);
 	const content = [];
 	let i = 0;
 	while (i < blocks.length) {
@@ -960,22 +1051,25 @@ function convertMarks(marks, markDefs) {
 		case "strike-through":
 			pmMarks.push({ type: "strike" });
 			break;
+		case "subscript":
+			pmMarks.push({ type: "subscript" });
+			break;
+		case "superscript":
+			pmMarks.push({ type: "superscript" });
+			break;
 		case "code":
 			pmMarks.push({ type: "code" });
 			break;
 		default: {
 			const markDef = markDefs.get(mark);
-			if (markDef) if (markDef._type === "link") pmMarks.push({
+			if (markDef?._type === "link") pmMarks.push({
 				type: "link",
 				attrs: {
 					href: markDef.href,
 					target: markDef.blank ? "_blank" : null
 				}
 			});
-			else pmMarks.push({
-				type: markDef._type,
-				attrs: markDef
-			});
+			else throw new UnsupportedPortableTextMarksError([typeof markDef?._type === "string" ? markDef._type : mark]);
 			break;
 		}
 	}
@@ -2374,6 +2468,20 @@ async function parseRouteInput(request) {
 	return input;
 }
 /**
+* Convert the host's authenticated user into the read-only `UserInfo` shape
+* exposed to plugins as `ctx.user`. Strips sensitive/irrelevant fields and
+* keeps the value structured-clone-safe for sandboxed plugins.
+*/
+function toRouteCallerInfo(user) {
+	return {
+		id: user.id,
+		email: user.email,
+		name: user.name,
+		role: user.role,
+		createdAt: typeof user.createdAt === "string" ? user.createdAt : user.createdAt.toISOString()
+	};
+}
+/**
 * Route handler for a plugin
 */
 var PluginRouteHandler = class {
@@ -2416,7 +2524,8 @@ var PluginRouteHandler = class {
 			...this.contextFactory.createContext(this.plugin),
 			input: validatedInput,
 			request: guardConsumedRequestBody(options.request),
-			requestMeta: extractRequestMeta(options.request, this.trustedProxyHeaders)
+			requestMeta: extractRequestMeta(options.request, this.trustedProxyHeaders),
+			user: options.user
 		};
 		try {
 			return {
@@ -2425,6 +2534,14 @@ var PluginRouteHandler = class {
 				status: 200
 			};
 		} catch (error) {
+			if (error instanceof MediaUsageActivationWriteBlockedError) return {
+				success: false,
+				error: {
+					code: error.code,
+					message: error.message
+				},
+				status: error.status
+			};
 			if (error instanceof PluginRouteError) return {
 				success: false,
 				error: {
@@ -2972,12 +3089,16 @@ var NodeCronScheduler = class {
 	timer = null;
 	running = false;
 	systemCleanup = null;
+	mediaUsageMaintenance = null;
 	constructor(executor) {
 		this.executor = executor;
 	}
 	setSystemCleanup(fn) {
 		this.systemCleanup = fn;
 	}
+	setMediaUsageMaintenance(fn) {
+		this.mediaUsageMaintenance = fn;
+	}
 	start() {
 		this.running = true;
 		this.arm();
@@ -3024,8 +3145,13 @@ var NodeCronScheduler = class {
 		if (!this.running) return;
 		const tasks = [this.executor.tick(), this.executor.recoverStaleLocks()];
 		if (this.systemCleanup) tasks.push(this.systemCleanup());
-		Promise.allSettled(tasks).then((results) => {
+		Promise.allSettled(tasks).then(async (results) => {
 			for (const r of results) if (r.status === "rejected") console.error("[cron:node] Tick task failed:", r.reason);
+			if (this.mediaUsageMaintenance) try {
+				await this.mediaUsageMaintenance();
+			} catch (error) {
+				console.error("[cron:node] Media Usage maintenance failed:", error);
+			}
 		}).finally(() => {
 			if (this.running) this.arm();
 		});
@@ -3090,6 +3216,56 @@ function createNoopSandboxRunner(_options) {
 
 //#endregion
 //#region src/plugins/sandbox/types.ts
+const SANDBOX_ROUTE_ERROR_DEFINITIONS = {
+	MEDIA_USAGE_ACTIVATION_IN_PROGRESS: {
+		message: "Media usage activation is in progress",
+		status: 503
+	},
+	MEDIA_USAGE_ACTIVATION_CHECK_FAILED: {
+		message: "Unable to verify media usage activation state",
+		status: 503
+	}
+};
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+function isSandboxRouteErrorCode(value) {
+	return typeof value === "string" && value in SANDBOX_ROUTE_ERROR_DEFINITIONS;
+}
+function getSandboxRouteErrorDetails(error) {
+	if (!isRecord(error)) return null;
+	const propertyCode = isSandboxRouteErrorCode(error.code) ? error.code : null;
+	const nameCode = error instanceof Error && isSandboxRouteErrorCode(error.name) ? error.name : null;
+	if (propertyCode && nameCode && propertyCode !== nameCode) return null;
+	const code = propertyCode ?? nameCode;
+	if (!code || error.status !== void 0 && error.status !== 503) return null;
+	return {
+		code,
+		...SANDBOX_ROUTE_ERROR_DEFINITIONS[code]
+	};
+}
+function createSandboxRouteError(code) {
+	const details = {
+		code,
+		...SANDBOX_ROUTE_ERROR_DEFINITIONS[code]
+	};
+	return Object.assign(new Error(details.message), details, { name: code });
+}
+function createSandboxRouteErrorEnvelope(error) {
+	const details = getSandboxRouteErrorDetails(error);
+	return details ? {
+		__emdashSandboxRouteError: true,
+		error: details
+	} : null;
+}
+function getSandboxRouteErrorEnvelope(value) {
+	if (!isRecord(value) || value.__emdashSandboxRouteError !== true) return null;
+	const details = getSandboxRouteErrorDetails(value.error);
+	return details ? {
+		__emdashSandboxRouteError: true,
+		error: details
+	} : null;
+}
 /**
 * Error thrown when the sandbox runtime is unavailable.
 * This happens when the sidecar process has crashed or hasn't started.
@@ -3336,13 +3512,14 @@ async function getMenusWithDb(db, options = {}) {
 * per-locale content rows.
 */
 async function buildMenuTree(items, db, locale) {
-	const collectionSlugs = /* @__PURE__ */ new Set();
-	for (const item of items) {
-		if (item.reference_collection) collectionSlugs.add(item.reference_collection);
-		if (item.type === "page" || item.type === "post") collectionSlugs.add(item.reference_collection || `${item.type}s`);
-	}
-	const urlPatterns = collectionSlugs.size > 0 ? await getCollectionUrlPatterns(db, collectionSlugs) : /* @__PURE__ */ new Map();
-	const validItems = (await Promise.all(items.map((item) => resolveMenuItem(item, db, urlPatterns, locale)))).filter((item) => item !== null);
+	const contentReferences = collectContentReferences(items);
+	const taxonomyReferences = new Set(items.flatMap((item) => item.type === "taxonomy" && item.reference_id ? [item.reference_id] : []));
+	const [urlPatterns, contentLookup, taxonomyLookup] = await Promise.all([
+		contentReferences.size > 0 ? getCollectionUrlPatterns(db, new Set(contentReferences.keys())) : /* @__PURE__ */ new Map(),
+		resolveContentReferences(db, contentReferences, locale),
+		resolveTaxonomyReferences(db, taxonomyReferences, locale)
+	]);
+	const validItems = items.map((item) => resolveMenuItem(item, urlPatterns, contentLookup, taxonomyLookup)).filter((item) => item !== null);
 	const itemMap = /* @__PURE__ */ new Map();
 	const rootItems = [];
 	for (const item of validItems) itemMap.set(item.id, {
@@ -3360,6 +3537,41 @@ async function buildMenuTree(items, db, locale) {
 	}
 	return rootItems;
 }
+function collectContentReferences(items) {
+	const references = /* @__PURE__ */ new Map();
+	for (const item of items) {
+		const reference = getContentReference(item);
+		if (!reference) continue;
+		let ids = references.get(reference.collection);
+		if (!ids) {
+			ids = /* @__PURE__ */ new Set();
+			references.set(reference.collection, ids);
+		}
+		ids.add(reference.id);
+	}
+	return references;
+}
+function getContentReference(item) {
+	if (item.type === "page" || item.type === "post") {
+		if (!item.reference_id) return null;
+		return {
+			collection: item.reference_collection || `${item.type}s`,
+			id: item.reference_id
+		};
+	}
+	if (item.type === "collection") {
+		if (!item.reference_collection || !item.reference_id) return null;
+		return {
+			collection: item.reference_collection,
+			id: item.reference_id
+		};
+	}
+	if (item.type !== "custom" && item.type !== "taxonomy" && item.reference_collection && item.reference_id) return {
+		collection: item.reference_collection,
+		id: item.reference_id
+	};
+	return null;
+}
 /**
 * Look up the `url_pattern` for a set of collection slugs, request-cached so
 * a page rendering several menus (header, footer, ...) only pays for the
@@ -3376,40 +3588,35 @@ function getCollectionUrlPatterns(db, collectionSlugs) {
 }
 /**
 * Resolve a single menu item's URL. `reference_id` is a translation_group
-* (migration 036 remapped all existing references); we join it against
+* (migration 036 remapped all existing references); we look it up against
 * the per-locale ec_* row or per-locale taxonomy row.
 */
-async function resolveMenuItem(item, db, urlPatterns, locale) {
+function resolveMenuItem(item, urlPatterns, contentLookup, taxonomyLookup) {
 	let url;
-	try {
-		switch (item.type) {
-			case "custom":
-				url = item.custom_url || "#";
-				break;
-			case "page":
-			case "post":
-				url = await resolveContentUrl(item.reference_collection || `${item.type}s`, item.reference_id, db, urlPatterns, locale);
-				if (url === null) return null;
-				break;
-			case "taxonomy":
-				url = await resolveTaxonomyUrl(item.reference_id, db, locale);
-				if (url === null) return null;
-				break;
-			case "collection":
-				if (!item.reference_collection) return null;
-				if (item.reference_id) {
-					url = await resolveContentUrl(item.reference_collection, item.reference_id, db, urlPatterns, locale);
-					if (url === null) return null;
-				} else url = `/${item.reference_collection}/`;
-				break;
-			default: if (item.reference_collection && item.reference_id) {
-				url = await resolveContentUrl(item.reference_collection, item.reference_id, db, urlPatterns, locale);
+	switch (item.type) {
+		case "custom":
+			url = item.custom_url || "#";
+			break;
+		case "page":
+		case "post":
+			url = resolveContentUrl(item.reference_collection || `${item.type}s`, item.reference_id, urlPatterns, contentLookup);
+			if (url === null) return null;
+			break;
+		case "taxonomy":
+			url = resolveTaxonomyUrl(item.reference_id, taxonomyLookup);
+			if (url === null) return null;
+			break;
+		case "collection":
+			if (!item.reference_collection) return null;
+			if (item.reference_id) {
+				url = resolveContentUrl(item.reference_collection, item.reference_id, urlPatterns, contentLookup);
 				if (url === null) return null;
-			} else url = "#";
-		}
-	} catch (error) {
-		console.error(`Failed to resolve menu item ${item.id}:`, error);
-		return null;
+			} else url = `/${item.reference_collection}/`;
+			break;
+		default: if (item.reference_collection && item.reference_id) {
+			url = resolveContentUrl(item.reference_collection, item.reference_id, urlPatterns, contentLookup);
+			if (url === null) return null;
+		} else url = "#";
 	}
 	return {
 		id: item.id,
@@ -3431,56 +3638,105 @@ const ID_PLACEHOLDER = /\{id\}/g;
 function interpolateUrlPattern(pattern, slug, id) {
 	return pattern.replace(SLUG_PLACEHOLDER, slug).replace(ID_PLACEHOLDER, id);
 }
+async function resolveContentReferences(db, references, locale) {
+	const entries = await Promise.all(Array.from(references, async ([collection, referenceGroups]) => {
+		const lookup = /* @__PURE__ */ new Map();
+		const localized = /* @__PURE__ */ new Map();
+		try {
+			validateIdentifier(collection, "menu item collection");
+			for (const batch of chunks([...referenceGroups], SQL_BATCH_SIZE)) {
+				const result = await sql`
+						SELECT id, slug, locale, translation_group
+						FROM ${sql.ref(`ec_${collection}`)}
+						WHERE translation_group IN (${sql.join(batch)})
+					`.execute(db);
+				for (const row of result.rows) if (shouldPreferLocalizedRow(row, localized.get(row.translation_group), locale)) localized.set(row.translation_group, row);
+			}
+			for (const [referenceGroup, row] of localized) lookup.set(referenceGroup, {
+				id: row.id,
+				slug: row.slug
+			});
+			const unresolved = [...referenceGroups].filter((id) => !lookup.has(id));
+			for (const batch of chunks(unresolved, SQL_BATCH_SIZE)) {
+				const result = await sql`
+						SELECT id, slug FROM ${sql.ref(`ec_${collection}`)}
+						WHERE id IN (${sql.join(batch)})
+					`.execute(db);
+				for (const row of result.rows) lookup.set(row.id, row);
+			}
+		} catch (error) {
+			console.error(`Failed to resolve content URLs for ${collection}:`, error);
+		}
+		return [collection, lookup];
+	}));
+	return new Map(entries);
+}
+function shouldPreferLocalizedRow(candidate, existing, locale) {
+	if (!existing) return true;
+	if (candidate.locale === locale) return existing.locale !== locale || candidate.id < existing.id;
+	if (existing.locale === locale) return false;
+	return candidate.locale < existing.locale || candidate.locale === existing.locale && candidate.id < existing.id;
+}
 /**
 * Resolve the URL for a content reference. `referenceGroup` is the content
 * row's translation_group; we look up the row in the requested locale
 * (falling back to the source if no translation exists so the menu link is
 * still clickable).
 */
-async function resolveContentUrl(collection, referenceGroup, db, urlPatterns, locale) {
+function resolveContentUrl(collection, referenceGroup, urlPatterns, contentLookup) {
 	if (!referenceGroup) return null;
+	const row = contentLookup.get(collection)?.get(referenceGroup);
+	if (!row) return null;
+	const pattern = urlPatterns.get(collection);
+	if (pattern) return interpolateUrlPattern(pattern, row.slug, row.id);
+	return `/${collection}/${row.slug}`;
+}
+async function resolveTaxonomyReferences(db, referenceGroups, locale) {
+	const lookup = /* @__PURE__ */ new Map();
+	const localized = /* @__PURE__ */ new Map();
 	try {
-		validateIdentifier(collection, "menu item collection");
-		let result = await sql`
-			SELECT id, slug FROM ${sql.ref(`ec_${collection}`)}
-			WHERE translation_group = ${referenceGroup} AND locale = ${locale}
-			LIMIT 1
-		`.execute(db);
-		let row = result.rows[0];
-		if (!row) {
-			result = await sql`
-				SELECT id, slug FROM ${sql.ref(`ec_${collection}`)}
-				WHERE translation_group = ${referenceGroup}
-				ORDER BY locale ASC LIMIT 1
-			`.execute(db);
-			row = result.rows[0];
+		for (const batch of chunks([...referenceGroups], SQL_BATCH_SIZE)) {
+			const rows = await db.selectFrom("taxonomies").select([
+				"id",
+				"name",
+				"slug",
+				"locale",
+				"translation_group"
+			]).where("translation_group", "in", batch).$narrowType().execute();
+			for (const row of rows) if (shouldPreferLocalizedRow(row, localized.get(row.translation_group), locale)) localized.set(row.translation_group, row);
+		}
+		for (const [referenceGroup, row] of localized) lookup.set(referenceGroup, {
+			name: row.name,
+			slug: row.slug
+		});
+		const unresolved = [...referenceGroups].filter((id) => !lookup.has(id));
+		for (const batch of chunks(unresolved, SQL_BATCH_SIZE)) {
+			const rows = await db.selectFrom("taxonomies").select([
+				"id",
+				"name",
+				"slug"
+			]).where("id", "in", batch).execute();
+			for (const row of rows) lookup.set(row.id, {
+				name: row.name,
+				slug: row.slug
+			});
 		}
-		if (!row) row = (await sql`
-				SELECT id, slug FROM ${sql.ref(`ec_${collection}`)}
-				WHERE id = ${referenceGroup} LIMIT 1
-			`.execute(db)).rows[0];
-		if (!row) return null;
-		const pattern = urlPatterns.get(collection);
-		if (pattern) return interpolateUrlPattern(pattern, row.slug, row.id);
-		return `/${collection}/${row.slug}`;
 	} catch (error) {
-		console.error(`Failed to resolve content URL for ${collection}/${referenceGroup}:`, error);
-		return null;
+		console.error("Failed to resolve taxonomy URLs:", error);
 	}
+	return lookup;
 }
 /**
 * Resolve URL for a taxonomy term reference. `referenceGroup` is the term's
 * translation_group; we pick the row in the active locale (or fall back).
 */
-async function resolveTaxonomyUrl(referenceGroup, db, locale) {
+function resolveTaxonomyUrl(referenceGroup, taxonomyLookup) {
 	if (!referenceGroup) return null;
-	let taxonomy = await db.selectFrom("taxonomies").select(["name", "slug"]).where("translation_group", "=", referenceGroup).where("locale", "=", locale).executeTakeFirst();
-	if (!taxonomy) taxonomy = await db.selectFrom("taxonomies").select(["name", "slug"]).where("translation_group", "=", referenceGroup).orderBy("locale", "asc").executeTakeFirst();
-	if (!taxonomy) taxonomy = await db.selectFrom("taxonomies").select(["name", "slug"]).where("id", "=", referenceGroup).executeTakeFirst();
+	const taxonomy = taxonomyLookup.get(referenceGroup);
 	if (!taxonomy) return null;
 	return `/${taxonomy.name}/${taxonomy.slug}`;
 }
 
 //#endregion
-export { portableText as C, AuditRepository as D, image as E, prosemirrorToPortableText as S, file as T, HookPipeline as _, SandboxUnavailableError as a, definePlugin as b, createNoopSandboxRunner as c, createPluginManager as d, PluginRouteError as f, EmailPipeline as g, parseRouteInput as h, getComments as i, NodeCronScheduler as l, buildRouteMeta as m, getMenus as n, NoopSandboxRunner as o, PluginRouteRegistry as p, getCommentCount as r, SandboxNotAvailableError as s, getMenu as t, PluginManager as u, createHookPipeline as v, reference as w, portableTextToProsemirror as x, resolveExclusiveHooks as y };
-//# sourceMappingURL=menus-Y54RDPIN.mjs.map
+export { file as A, createHookPipeline as C, prosemirrorToPortableText as D, portableTextToProsemirror as E, AuditRepository as M, portableText as O, HookPipeline as S, definePlugin as T, PluginRouteRegistry as _, SandboxUnavailableError as a, toRouteCallerInfo as b, getSandboxRouteErrorDetails as c, SandboxNotAvailableError as d, createNoopSandboxRunner as f, PluginRouteError as g, createPluginManager as h, getComments as i, image as j, reference as k, getSandboxRouteErrorEnvelope as l, PluginManager as m, getMenus as n, createSandboxRouteError as o, NodeCronScheduler as p, getCommentCount as r, createSandboxRouteErrorEnvelope as s, getMenu as t, NoopSandboxRunner as u, buildRouteMeta as v, resolveExclusiveHooks as w, EmailPipeline as x, parseRouteInput as y };
+//# sourceMappingURL=menus-DSo5QeW0.mjs.map