dineway 0.1.49 → 0.2.1

package/dist/{site-url-DIMD68go.mjs → site-url-DJEid0ml.mjs}

@@ -1,4 +1,4 @@
-import { t as OptionsRepository } from "./options-LsPjZlqD.mjs";
+import { t as OptionsRepository } from "./options-DQPTH5n0.mjs";
 
 //#region src/api/site-url.ts
 async function getSiteBaseUrl(db, request) {

package/dist/stable-hash-DshcXvRE.mjs

@@ -0,0 +1,19 @@
+//#region src/utils/stable-hash.ts
+async function buildStableHash(value) {
+	return sha256Hex(stableStringify(value));
+}
+function stableStringify(value) {
+	if (Array.isArray(value)) return `[${value.map((item) => stableStringify(item)).join(",")}]`;
+	if (isRecord(value)) return `{${Object.entries(value).filter(([, entryValue]) => entryValue !== void 0).toSorted(([left], [right]) => left.localeCompare(right)).map(([key, entryValue]) => `${JSON.stringify(key)}:${stableStringify(entryValue)}`).join(",")}}`;
+	return JSON.stringify(value ?? null);
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+async function sha256Hex(value) {
+	const buffer = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(value));
+	return Array.from(new Uint8Array(buffer), (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+
+//#endregion
+export { stableStringify as n, buildStableHash as t };

package/dist/status-NqWOSFAD.mjs

@@ -0,0 +1,21 @@
+//#region src/redirects/status.ts
+/**
+* Redirect rule status codes.
+*
+* Redirect statuses issue a Location header. Terminal statuses serve the
+* status directly with no destination.
+*/
+const REDIRECT_STATUSES = [
+	301,
+	302,
+	307,
+	308
+];
+const TERMINAL_STATUSES = [410, 451];
+const REDIRECT_RULE_STATUSES = [...REDIRECT_STATUSES, ...TERMINAL_STATUSES];
+function isTerminalStatus(type) {
+	return TERMINAL_STATUSES.includes(type);
+}
+
+//#endregion
+export { isTerminalStatus as n, REDIRECT_RULE_STATUSES as t };

package/dist/storage/local.d.mts

@@ -1,4 +1,4 @@
-import { a as ListOptions, d as Storage, l as SignedUploadOptions, o as ListResult, p as UploadResult, r as DownloadResult, s as LocalStorageConfig, u as SignedUploadUrl } from "../types-DZpT-PnG.mjs";
+import { a as ListOptions, d as Storage, l as SignedUploadOptions, o as ListResult, p as UploadResult, r as DownloadResult, s as LocalStorageConfig, u as SignedUploadUrl } from "../types-wFu80FrO.mjs";
 
 //#region src/storage/local.d.ts
 /**

package/dist/storage/local.mjs

@@ -1,4 +1,4 @@
-import { t as DinewayStorageError } from "../types-Cg276-3z.mjs";
+import { t as DinewayStorageError } from "../types-mVVgRPaU.mjs";
 import { createReadStream, existsSync } from "node:fs";
 import * as path from "node:path";
 import mime from "mime/lite";

package/dist/storage/s3.d.mts

@@ -1,4 +1,4 @@
-import { a as ListOptions, c as S3StorageConfig, d as Storage, l as SignedUploadOptions, o as ListResult, p as UploadResult, r as DownloadResult, u as SignedUploadUrl } from "../types-DZpT-PnG.mjs";
+import { a as ListOptions, c as S3StorageConfig, d as Storage, l as SignedUploadOptions, o as ListResult, p as UploadResult, r as DownloadResult, u as SignedUploadUrl } from "../types-wFu80FrO.mjs";
 
 //#region src/storage/s3.d.ts
 /**

package/dist/storage/s3.mjs

@@ -1,4 +1,4 @@
-import { t as DinewayStorageError } from "../types-Cg276-3z.mjs";
+import { t as DinewayStorageError } from "../types-mVVgRPaU.mjs";
 import { DeleteObjectCommand, GetObjectCommand, HeadObjectCommand, ListObjectsV2Command, PutObjectCommand, S3Client } from "@aws-sdk/client-s3";
 import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
 

package/dist/{taxonomies-D9Sw4wWM.mjs → taxonomies-BiM9NtgW.mjs}

@@ -1,6 +1,6 @@
-import { a as __exportAll } from "./runner-DzIpHGND.mjs";
-import { t as TaxonomyRepository } from "./taxonomy-B169Nm6B.mjs";
-import { c as invalidateTermCache } from "./taxonomies-CZ-_DitR.mjs";
+import { a as __exportAll } from "./runner-BgmttQmD.mjs";
+import { t as TaxonomyRepository } from "./taxonomy-0k_vRVsD.mjs";
+import { c as invalidateTaxonomyDefsCache, l as invalidateTermCache } from "./taxonomies-DSnY5nOa.mjs";
 import { ulid } from "ulidx";
 
 //#region src/api/handlers/taxonomies.ts
@@ -19,11 +19,14 @@ const NAME_PATTERN = /^[a-z][a-z0-9_]*$/;
 * Build tree structure from flat terms
 */
 function buildTree(flatTerms) {
-	const map = /* @__PURE__ */ new Map();
+	const byLocaleGroup = /* @__PURE__ */ new Map();
 	const roots = [];
-	for (const term of flatTerms) map.set(term.id, term);
-	for (const term of flatTerms) if (term.parentId && map.has(term.parentId)) map.get(term.parentId).children.push(term);
-	else roots.push(term);
+	for (const term of flatTerms) byLocaleGroup.set(`${term.locale}::${term.translationGroup ?? term.id}`, term);
+	for (const term of flatTerms) {
+		const parent = term.parentId ? byLocaleGroup.get(`${term.locale}::${term.parentId}`) : void 0;
+		if (parent) parent.children.push(term);
+		else roots.push(term);
+	}
 	return roots;
 }
 /**
@@ -144,6 +147,7 @@ async function handleTaxonomyCreate(db, input) {
 			...input.locale !== void 0 ? { locale: input.locale } : {},
 			translation_group: translationGroup ?? id
 		}).execute();
+		invalidateTaxonomyDefsCache();
 		return {
 			success: true,
 			data: { taxonomy: rowToDef(await db.selectFrom("_dineway_taxonomy_defs").selectAll().where("id", "=", id).executeTakeFirstOrThrow()) }
@@ -212,15 +216,12 @@ async function handleTermList(db, taxonomyName, options = {}) {
 *   - `parentId === null` -> caller intends to detach; no-op here.
 *   - parent must exist (FK exists -> term row not soft-deleted).
 *   - parent must live in the same taxonomy.
-*   - if `termId` is provided (update path), reject `parentId === termId`
-*     (self-parent) and walk up the parent chain to detect cycles.
+*   - reject a parent in the term's own translation_group.
+*   - if `termId` is provided (update path), walk up the parent chain to
+*     detect cycles.
 */
-async function validateParentTerm(repo, taxonomyName, termId, parentId) {
+async function validateParentTerm(repo, taxonomyName, termId, parentId, selfGroup) {
 	if (parentId === void 0 || parentId === null) return null;
-	if (termId !== void 0 && parentId === termId) return {
-		code: "VALIDATION_ERROR",
-		message: "A term cannot be its own parent"
-	};
 	const parent = await repo.findById(parentId);
 	if (!parent) return {
 		code: "VALIDATION_ERROR",
@@ -230,11 +231,21 @@ async function validateParentTerm(repo, taxonomyName, termId, parentId) {
 		code: "VALIDATION_ERROR",
 		message: `Parent term '${parentId}' belongs to taxonomy '${parent.name}', not '${taxonomyName}'`
 	};
+	const parentGroup = parent.translationGroup ?? parent.id;
+	let termGroup = selfGroup ?? null;
+	if (termId !== void 0) {
+		const term = await repo.findById(termId);
+		termGroup = term ? term.translationGroup ?? term.id : termId;
+	}
+	if (termGroup !== null && parentGroup === termGroup) return {
+		code: "VALIDATION_ERROR",
+		message: "A term cannot be its own parent"
+	};
 	const MAX_DEPTH = 100;
 	let cursor = parent.parentId;
 	let steps = 0;
 	while (cursor !== null && steps < MAX_DEPTH) {
-		if (termId !== void 0 && cursor === termId) return {
+		if (termGroup !== null && cursor === termGroup) return {
 			code: "VALIDATION_ERROR",
 			message: "Cycle detected: cannot make a descendant the parent"
 		};
@@ -257,7 +268,7 @@ async function handleTermCreate(db, taxonomyName, input) {
 		const lookup = await requireTaxonomyDef(db, taxonomyName);
 		if (!lookup.success) return lookup;
 		const repo = new TaxonomyRepository(db);
-		let parentId = input.parentId === "" || input.parentId === void 0 ? void 0 : input.parentId;
+		const parentId = input.parentId === "" || input.parentId === void 0 ? void 0 : input.parentId;
 		if (await repo.findBySlug(taxonomyName, input.slug, input.locale)) return {
 			success: false,
 			error: {
@@ -265,16 +276,12 @@ async function handleTermCreate(db, taxonomyName, input) {
 				message: input.locale ? `Term '${input.slug}' already exists in '${taxonomyName}' (${input.locale})` : `Term with slug '${input.slug}' already exists in taxonomy '${taxonomyName}'`
 			}
 		};
-		if (input.translationOf && parentId) {
-			if ((await repo.findById(input.translationOf))?.parentId === parentId && input.locale) {
-				const sourceParent = await repo.findById(parentId);
-				if (sourceParent?.translationGroup) {
-					const translatedParent = await db.selectFrom("taxonomies").select("id").where("translation_group", "=", sourceParent.translationGroup).where("locale", "=", input.locale).executeTakeFirst();
-					if (translatedParent) parentId = translatedParent.id;
-				}
-			}
+		let selfGroup = null;
+		if (input.translationOf) {
+			const source = await repo.findById(input.translationOf);
+			selfGroup = source ? source.translationGroup ?? source.id : null;
 		}
-		const parentError = await validateParentTerm(repo, taxonomyName, void 0, parentId);
+		const parentError = await validateParentTerm(repo, taxonomyName, void 0, parentId, selfGroup);
 		if (parentError) return {
 			success: false,
 			error: parentError
@@ -288,7 +295,7 @@ async function handleTermCreate(db, taxonomyName, input) {
 			locale: input.locale,
 			translationOf: input.translationOf
 		});
-		/* @__PURE__ */ invalidateTermCache();
+		invalidateTermCache();
 		return {
 			success: true,
 			data: { term: {
@@ -327,7 +334,7 @@ async function handleTermGet(db, taxonomyName, termSlug, options = {}) {
 			}
 		};
 		const count = await repo.countEntriesWithTerm(term.id);
-		const children = await repo.findChildren(term.id);
+		const children = await repo.findChildren(term.id, term.locale);
 		return {
 			success: true,
 			data: { term: {
@@ -428,7 +435,7 @@ async function handleTermUpdate(db, taxonomyName, termSlug, input, options = {})
 			parentId: newParentId,
 			data: input.description !== void 0 ? { description: input.description } : void 0
 		});
-		/* @__PURE__ */ invalidateTermCache();
+		invalidateTermCache();
 		if (!updated) return {
 			success: false,
 			error: {
@@ -487,7 +494,7 @@ async function handleTermDelete(db, taxonomyName, termSlug, options = {}) {
 				message: "Failed to delete term"
 			}
 		};
-		/* @__PURE__ */ invalidateTermCache();
+		invalidateTermCache();
 		return {
 			success: true,
 			data: { deleted: true }

package/dist/taxonomies-DSnY5nOa.mjs

@@ -0,0 +1,443 @@
+import { a as __exportAll } from "./runner-BgmttQmD.mjs";
+import { getRequestContext } from "./request-context.mjs";
+import { a as resetTaxonomyNamesCache, o as isMissingTableError, r as getDb } from "./loader-aWkkc1_o.mjs";
+import { d as invalidateTaxonomyObjectCache, f as isObjectCacheActive, n as cachedQuery, t as CacheNamespace } from "./object-cache-D51qOseS.mjs";
+import { n as chunks, t as SQL_BATCH_SIZE } from "./chunks-ChGNDY8r.mjs";
+import { i as setRequestCacheEntry, n as peekRequestCache, r as requestCached } from "./request-cache-CBFjCwSt.mjs";
+import { i as resolveLocaleChain, r as resolveLocale } from "./resolve-DE71WcL9.mjs";
+
+//#region src/taxonomies/index.ts
+/**
+* Runtime API for taxonomies.
+*
+* Public helpers are locale-aware. Because `content_taxonomies.taxonomy_id`
+* stores a term translation_group, joins use `taxonomies.translation_group`
+* and optionally filter the requested locale.
+*/
+var taxonomies_exports = /* @__PURE__ */ __exportAll({
+	getAllTermsForEntries: () => getAllTermsForEntries,
+	getEntriesByTerm: () => getEntriesByTerm,
+	getEntryTerms: () => getEntryTerms,
+	getTaxonomyDef: () => getTaxonomyDef,
+	getTaxonomyDefs: () => getTaxonomyDefs,
+	getTaxonomyTerms: () => getTaxonomyTerms,
+	getTerm: () => getTerm,
+	getTermsForEntries: () => getTermsForEntries,
+	invalidateTaxonomyDefsCache: () => invalidateTaxonomyDefsCache,
+	invalidateTermCache: () => invalidateTermCache,
+	primeFoldedEntryTerms: () => primeFoldedEntryTerms
+});
+function invalidateTermCache() {
+	invalidateTaxonomyObjectCache();
+}
+const TAXONOMY_DEFS_CACHE_KEY = Symbol.for("dineway:taxonomy-defs");
+function getTaxonomyDefsHolder() {
+	const existing = Reflect.get(globalThis, TAXONOMY_DEFS_CACHE_KEY);
+	if (isTaxonomyDefsHolder(existing)) return existing;
+	const holder = {
+		version: 0,
+		cache: /* @__PURE__ */ new Map()
+	};
+	Reflect.set(globalThis, TAXONOMY_DEFS_CACHE_KEY, holder);
+	return holder;
+}
+function isTaxonomyDefsHolder(value) {
+	if (value && typeof value === "object" && "version" in value && "cache" in value) return typeof value.version === "number" && value.cache instanceof Map;
+	return false;
+}
+const taxonomyDefsHolder = getTaxonomyDefsHolder();
+function invalidateTaxonomyDefsCache() {
+	taxonomyDefsHolder.version++;
+	taxonomyDefsHolder.cache.clear();
+	resetTaxonomyNamesCache();
+	invalidateTaxonomyObjectCache();
+}
+async function fetchTaxonomyDefs(locale) {
+	let query = (await getDb()).selectFrom("_dineway_taxonomy_defs").selectAll();
+	if (locale !== void 0) query = query.where("locale", "=", locale);
+	return (await query.execute()).map(rowToTaxonomyDef);
+}
+function loadTaxonomyDefs(localeKey, locale) {
+	if (getRequestContext()?.dbIsIsolated === true) return fetchTaxonomyDefs(locale);
+	const cached = taxonomyDefsHolder.cache.get(localeKey);
+	if (cached && cached.version === taxonomyDefsHolder.version) return cached.promise;
+	const version = taxonomyDefsHolder.version;
+	const promise = fetchTaxonomyDefs(locale).catch((error) => {
+		if (taxonomyDefsHolder.cache.get(localeKey)?.promise === promise) taxonomyDefsHolder.cache.delete(localeKey);
+		throw error;
+	});
+	taxonomyDefsHolder.cache.set(localeKey, {
+		version,
+		promise
+	});
+	return promise;
+}
+/**
+* Get every taxonomy definition for the active locale.
+*/
+async function getTaxonomyDefs(options = {}) {
+	const locale = resolveLocale(options.locale);
+	const localeKey = locale ?? "*";
+	return requestCached(`taxonomy-defs:${localeKey}`, async () => {
+		if (await isObjectCacheActive()) return cachedQuery({
+			namespace: CacheNamespace.TAXONOMIES,
+			key: `defs:${localeKey}`,
+			load: () => fetchTaxonomyDefs(locale)
+		});
+		return loadTaxonomyDefs(localeKey, locale);
+	});
+}
+/**
+* Get a single taxonomy definition by name, following the locale fallback chain.
+*/
+async function getTaxonomyDef(name, options = {}) {
+	const chain = resolveLocaleChain(options.locale);
+	const allDefs = peekRequestCache(`taxonomy-defs:${resolveLocale(options.locale) ?? "*"}`);
+	if (allDefs) {
+		const defs = await allDefs;
+		if (chain.length === 0) return defs.find((def) => def.name === name) ?? null;
+		for (const locale of chain) {
+			const found = defs.find((def) => def.name === name && def.locale === locale);
+			if (found) return found;
+		}
+		return null;
+	}
+	return requestCached(`taxonomy-def:${name}:${chain.join(",")}`, async () => {
+		const db = await getDb();
+		if (chain.length === 0) {
+			const row = await db.selectFrom("_dineway_taxonomy_defs").selectAll().where("name", "=", name).orderBy("locale", "asc").executeTakeFirst();
+			return row ? rowToTaxonomyDef(row) : null;
+		}
+		for (const locale of chain) {
+			const row = await db.selectFrom("_dineway_taxonomy_defs").selectAll().where("name", "=", name).where("locale", "=", locale).executeTakeFirst();
+			if (row) return rowToTaxonomyDef(row);
+		}
+		return null;
+	});
+}
+/**
+* Get all terms for a taxonomy in the active locale.
+*/
+async function getTaxonomyTerms(taxonomyName, options = {}) {
+	const locale = resolveLocale(options.locale);
+	const localeKey = locale ?? "*";
+	return requestCached(`taxonomy-terms:${taxonomyName}:${localeKey}`, () => cachedQuery({
+		namespace: CacheNamespace.TAXONOMIES,
+		key: `terms:${taxonomyName}:${localeKey}`,
+		load: async () => {
+			const db = await getDb();
+			const def = await getTaxonomyDef(taxonomyName, options);
+			if (!def) return [];
+			let termsQuery = db.selectFrom("taxonomies").selectAll().where("name", "=", taxonomyName).orderBy("label", "asc");
+			if (locale !== void 0) termsQuery = termsQuery.where("locale", "=", locale);
+			const rows = await termsQuery.execute();
+			const counts = await getTaxonomyTermCounts();
+			const flatTerms = rows.map((row) => ({
+				id: row.id,
+				name: row.name,
+				slug: row.slug,
+				label: row.label,
+				parent_id: row.parent_id,
+				data: row.data,
+				locale: row.locale,
+				translation_group: row.translation_group
+			}));
+			if (def.hierarchical) return buildTree(flatTerms, counts);
+			return flatTerms.map((term) => ({
+				id: term.id,
+				name: term.name,
+				slug: term.slug,
+				label: term.label,
+				description: term.data ? JSON.parse(term.data).description : void 0,
+				children: [],
+				count: counts.get(term.translation_group ?? term.id) ?? 0,
+				locale: term.locale,
+				translationGroup: term.translation_group
+			}));
+		}
+	}));
+}
+function getTaxonomyTermCounts() {
+	return requestCached("taxonomy-term-counts", async () => {
+		const countsResult = await (await getDb()).selectFrom("content_taxonomies").select(["taxonomy_id"]).select((eb) => eb.fn.count("entry_id").as("count")).groupBy("taxonomy_id").execute();
+		const counts = /* @__PURE__ */ new Map();
+		for (const row of countsResult) counts.set(row.taxonomy_id, row.count);
+		return counts;
+	});
+}
+/**
+* Get a single term by taxonomy and slug, following the locale fallback chain.
+*/
+async function getTerm(taxonomyName, slug, options = {}) {
+	const chain = resolveLocaleChain(options.locale);
+	return cachedQuery({
+		namespace: CacheNamespace.TAXONOMIES,
+		key: `term:${taxonomyName}:${slug}:${chain.join(",")}`,
+		load: async () => {
+			const db = await getDb();
+			const selectTerm = () => db.selectFrom("taxonomies").selectAll().where("name", "=", taxonomyName).where("slug", "=", slug);
+			let row;
+			if (chain.length === 0) row = await selectTerm().orderBy("locale", "asc").executeTakeFirst();
+			else {
+				row = void 0;
+				for (const locale of chain) {
+					row = await selectTerm().where("locale", "=", locale).executeTakeFirst();
+					if (row) break;
+				}
+			}
+			if (!row) return null;
+			let childrenQuery = db.selectFrom("taxonomies").selectAll().where("parent_id", "=", row.translation_group ?? row.id).orderBy("label", "asc");
+			if (row.locale) childrenQuery = childrenQuery.where("locale", "=", row.locale);
+			const [countResult, childRows] = await Promise.all([db.selectFrom("content_taxonomies").select((eb) => eb.fn.count("entry_id").as("count")).where("taxonomy_id", "=", row.translation_group ?? row.id).executeTakeFirst(), childrenQuery.execute()]);
+			const count = countResult?.count ?? 0;
+			const children = childRows.map((child) => ({
+				id: child.id,
+				name: child.name,
+				slug: child.slug,
+				label: child.label,
+				parentId: child.parent_id ?? void 0,
+				children: [],
+				locale: child.locale,
+				translationGroup: child.translation_group
+			}));
+			return {
+				id: row.id,
+				name: row.name,
+				slug: row.slug,
+				label: row.label,
+				parentId: row.parent_id ?? void 0,
+				description: row.data ? JSON.parse(row.data).description : void 0,
+				children,
+				count,
+				locale: row.locale,
+				translationGroup: row.translation_group
+			};
+		}
+	});
+}
+/**
+* Get terms assigned to an entry, resolved into the active locale.
+*/
+function getEntryTerms(collection, entryId, taxonomyName, options = {}) {
+	const locale = resolveLocale(options.locale);
+	return requestCached(`terms:${collection}:${entryId}:${taxonomyName ?? "*"}:${locale ?? "*"}`, () => cachedQuery({
+		namespace: CacheNamespace.TAXONOMIES,
+		key: `entry-terms:${collection}:${entryId}:${taxonomyName ?? "*"}:${locale ?? "*"}`,
+		load: async () => {
+			let query = (await getDb()).selectFrom("content_taxonomies").innerJoin("taxonomies", "taxonomies.translation_group", "content_taxonomies.taxonomy_id").selectAll("taxonomies").where("content_taxonomies.collection", "=", collection).where("content_taxonomies.entry_id", "=", entryId);
+			if (taxonomyName) query = query.where("taxonomies.name", "=", taxonomyName);
+			if (locale !== void 0) query = query.where("taxonomies.locale", "=", locale);
+			return (await query.execute()).map((row) => ({
+				id: row.id,
+				name: row.name,
+				slug: row.slug,
+				label: row.label,
+				parentId: row.parent_id ?? void 0,
+				children: [],
+				locale: row.locale,
+				translationGroup: row.translation_group
+			}));
+		}
+	}));
+}
+/**
+* Get terms for multiple entries in one taxonomy.
+*/
+async function getTermsForEntries(collection, entryIds, taxonomyName, options = {}) {
+	const result = /* @__PURE__ */ new Map();
+	const uniqueIds = [...new Set(entryIds)];
+	for (const id of uniqueIds) result.set(id, []);
+	if (uniqueIds.length === 0) return result;
+	const locale = resolveLocale(options.locale);
+	const localeKey = locale ?? "*";
+	const missedIds = [];
+	const cacheReads = [];
+	for (const id of uniqueIds) {
+		const cached = peekRequestCache(`terms:${collection}:${id}:${taxonomyName}:${localeKey}`);
+		if (cached) cacheReads.push(cached.then((terms) => ({
+			id,
+			terms
+		}), () => ({
+			id,
+			miss: true
+		})));
+		else missedIds.push(id);
+	}
+	for (const read of await Promise.all(cacheReads)) {
+		if ("miss" in read) {
+			missedIds.push(read.id);
+			continue;
+		}
+		result.set(read.id, read.terms.map((term) => ({
+			...term,
+			children: [...term.children]
+		})));
+	}
+	if (missedIds.length === 0) return result;
+	const db = await getDb();
+	for (const chunk of chunks(missedIds, SQL_BATCH_SIZE)) {
+		let rows;
+		try {
+			let query = db.selectFrom("content_taxonomies").innerJoin("taxonomies", "taxonomies.translation_group", "content_taxonomies.taxonomy_id").select([
+				"content_taxonomies.entry_id",
+				"taxonomies.id",
+				"taxonomies.name",
+				"taxonomies.slug",
+				"taxonomies.label",
+				"taxonomies.parent_id",
+				"taxonomies.locale",
+				"taxonomies.translation_group"
+			]).where("content_taxonomies.collection", "=", collection).where("content_taxonomies.entry_id", "in", chunk).where("taxonomies.name", "=", taxonomyName).orderBy("taxonomies.label", "asc");
+			if (locale !== void 0) query = query.where("taxonomies.locale", "=", locale);
+			rows = await query.execute();
+		} catch (error) {
+			if (isMissingTableError(error)) return result;
+			throw error;
+		}
+		for (const row of rows) {
+			const term = {
+				id: row.id,
+				name: row.name,
+				slug: row.slug,
+				label: row.label,
+				parentId: row.parent_id ?? void 0,
+				children: [],
+				locale: row.locale,
+				translationGroup: row.translation_group
+			};
+			const terms = result.get(row.entry_id);
+			if (terms) terms.push(term);
+		}
+	}
+	return result;
+}
+/**
+* Batch-fetch terms for multiple entries across all taxonomies.
+*/
+async function getAllTermsForEntries(collection, entryIds, options = {}) {
+	const result = /* @__PURE__ */ new Map();
+	const uniqueIds = [...new Set(entryIds)];
+	for (const id of uniqueIds) result.set(id, {});
+	if (uniqueIds.length === 0) return result;
+	const db = await getDb();
+	const locale = resolveLocale(options.locale);
+	const applicableTaxonomyNames = await getCollectionTaxonomyNames(collection, { locale });
+	for (const chunk of chunks(uniqueIds, SQL_BATCH_SIZE)) {
+		let rows;
+		try {
+			let query = db.selectFrom("content_taxonomies").innerJoin("taxonomies", "taxonomies.translation_group", "content_taxonomies.taxonomy_id").select([
+				"content_taxonomies.entry_id",
+				"taxonomies.id",
+				"taxonomies.name",
+				"taxonomies.slug",
+				"taxonomies.label",
+				"taxonomies.parent_id",
+				"taxonomies.locale",
+				"taxonomies.translation_group"
+			]).where("content_taxonomies.collection", "=", collection).where("content_taxonomies.entry_id", "in", chunk).orderBy("taxonomies.label", "asc");
+			if (locale !== void 0) query = query.where("taxonomies.locale", "=", locale);
+			rows = await query.execute();
+		} catch (error) {
+			if (isMissingTableError(error)) {
+				for (const id of uniqueIds) primeEntryTermsCache(collection, id, {}, applicableTaxonomyNames, locale);
+				return result;
+			}
+			throw error;
+		}
+		for (const row of rows) {
+			const term = {
+				id: row.id,
+				name: row.name,
+				slug: row.slug,
+				label: row.label,
+				parentId: row.parent_id ?? void 0,
+				children: [],
+				locale: row.locale,
+				translationGroup: row.translation_group
+			};
+			const byTaxonomy = result.get(row.entry_id);
+			if (!byTaxonomy) continue;
+			const existing = byTaxonomy[row.name];
+			if (existing) existing.push(term);
+			else byTaxonomy[row.name] = [term];
+		}
+	}
+	for (const [entryId, byTaxonomy] of result) primeEntryTermsCache(collection, entryId, byTaxonomy, applicableTaxonomyNames, locale);
+	return result;
+}
+async function getCollectionTaxonomyNames(collection, options) {
+	try {
+		return (await getTaxonomyDefs(options)).filter((def) => def.collections.includes(collection)).map((def) => def.name);
+	} catch (error) {
+		if (isMissingTableError(error)) return [];
+		throw error;
+	}
+}
+function primeEntryTermsCache(collection, entryId, byTaxonomy, applicableTaxonomyNames, locale) {
+	const localeKey = locale ?? "*";
+	for (const name of applicableTaxonomyNames) setRequestCacheEntry(`terms:${collection}:${entryId}:${name}:${localeKey}`, byTaxonomy[name] ?? []);
+	for (const [name, terms] of Object.entries(byTaxonomy)) setRequestCacheEntry(`terms:${collection}:${entryId}:${name}:${localeKey}`, terms);
+	setRequestCacheEntry(`terms:${collection}:${entryId}:*:${localeKey}`, Object.values(byTaxonomy).flat());
+}
+/**
+* Prime the per-entry request cache from terms folded into the content query.
+* Seeds the wildcard key and one key per taxonomy present on the entry without
+* adding a taxonomy-definition lookup to the fast path.
+*/
+function primeFoldedEntryTerms(collection, perEntry, options = {}) {
+	if (perEntry.length === 0) return;
+	const locale = resolveLocale(options.locale);
+	for (const { entryId, byTaxonomy } of perEntry) primeEntryTermsCache(collection, entryId, byTaxonomy, [], locale);
+}
+/**
+* Get entries by term.
+*/
+async function getEntriesByTerm(collection, taxonomyName, termSlug, options = {}) {
+	const { getDinewayCollection } = await import("./query-DEv5x6yB.mjs").then((n) => n.o);
+	const queryOptions = { where: { [taxonomyName]: termSlug } };
+	if (options.locale !== void 0) queryOptions.locale = options.locale;
+	const { entries } = await getDinewayCollection(collection, queryOptions);
+	return entries;
+}
+function rowToTaxonomyDef(row) {
+	return {
+		id: row.id,
+		name: row.name,
+		label: row.label,
+		labelSingular: row.label_singular ?? void 0,
+		hierarchical: row.hierarchical === 1,
+		collections: row.collections ? JSON.parse(row.collections) : [],
+		locale: row.locale,
+		translationGroup: row.translation_group
+	};
+}
+function buildTree(flatTerms, counts) {
+	const byLocaleGroup = /* @__PURE__ */ new Map();
+	const nodes = [];
+	const roots = [];
+	for (const term of flatTerms) {
+		const node = {
+			id: term.id,
+			name: term.name,
+			slug: term.slug,
+			label: term.label,
+			parentId: term.parent_id ?? void 0,
+			description: term.data ? JSON.parse(term.data).description : void 0,
+			children: [],
+			count: counts.get(term.translation_group ?? term.id) ?? 0,
+			locale: term.locale,
+			translationGroup: term.translation_group
+		};
+		byLocaleGroup.set(`${term.locale}::${term.translation_group ?? term.id}`, node);
+		nodes.push(node);
+	}
+	for (const node of nodes) {
+		const parent = node.parentId ? byLocaleGroup.get(`${node.locale}::${node.parentId}`) : void 0;
+		if (parent) parent.children.push(node);
+		else roots.push(node);
+	}
+	return roots;
+}
+
+//#endregion
+export { getTaxonomyTerms as a, invalidateTaxonomyDefsCache as c, getTaxonomyDefs as i, invalidateTermCache as l, getEntryTerms as n, getTerm as o, getTaxonomyDef as r, getTermsForEntries as s, getEntriesByTerm as t, taxonomies_exports as u };