emdash 1.3.0 → 1.3.1

package/dist/loader-CswroUbe.mjs

@@ -1,1380 +0,0 @@
-import { d as __exportAll } from "./runner-C5NeAkBQ.mjs";
-import { n as isMissingTableError, t as isMissingColumnError } from "./db-errors-CBD5yMro.mjs";
-import { t as validateIdentifier } from "./validate-DANX1-Qi.mjs";
-import { n as buildStatusCondition, u as isPostgres } from "./dialect-helpers-7_IqPdh9.mjs";
-import { r as getI18nConfig } from "./config-CvmjJcVw.mjs";
-import { getRequestContext } from "./request-context.mjs";
-import { n as chunks, t as SQL_BATCH_SIZE } from "./chunks-xC4UD5-S.mjs";
-import { i as setRequestCacheEntry } from "./request-cache-C4CIo5ad.mjs";
-import { c as decodeCursor, i as InvalidCursorError, l as encodeCursor } from "./types-D2NEXtgB.mjs";
-import { kyselyLogOption } from "./database/instrumentation.mjs";
-import { t as jsonTextValues } from "./json-recordset-BUjxhr77.mjs";
-import { Kysely, sql } from "kysely";
-
-//#region src/database/repositories/taxonomy-def.ts
-/**
-* Select definition rows (aliased `d`) with their taxonomy's structure.
-* Qualify columns in `where` and `orderBy`: `id` and `name` exist on both tables.
-*
-* A row that has no group yet, because code without the group table wrote it
-* during a rolling deploy, reads its own copy.
-*/
-function selectTaxonomyDefs(db) {
-	return db.selectFrom("_emdash_taxonomy_defs as d").leftJoin("_emdash_taxonomy_def_groups as g", "g.name", "d.name").select([
-		"d.id",
-		"d.name",
-		"d.label",
-		"d.label_singular",
-		"d.created_at",
-		"d.locale",
-		"d.translation_group",
-		sql`coalesce(g.hierarchical, d.hierarchical)`.as("hierarchical"),
-		sql`coalesce(g.collections, d.collections)`.as("collections")
-	]);
-}
-/**
-* The taxonomy's group id and structure, or null when no locale defines `name`.
-* A group whose definitions are all gone counts as deleted.
-*/
-async function findTaxonomyStructure(db, name) {
-	const row = await selectTaxonomyDefs(db).where("d.name", "=", name).orderBy("d.id", "asc").executeTakeFirst();
-	if (!row) return null;
-	return {
-		id: row.translation_group ?? row.id,
-		hierarchical: row.hierarchical === 1,
-		collections: parseTaxonomyCollections(row.collections)
-	};
-}
-/**
-* Write a taxonomy's structure for every locale and return its group id.
-*
-* Creates the group with `groupId` and `structure` when the name has none. An
-* existing group changes only the fields in `overwrite`, so a caller holding an
-* older read of the other field does not write it back. Every definition row of
-* the name is then linked to the group and copies its values, including rows
-* written without it.
-*/
-async function saveTaxonomyStructure(db, name, groupId, structure, overwrite = structure) {
-	const changes = {};
-	if (overwrite.hierarchical !== void 0) changes.hierarchical = overwrite.hierarchical ? 1 : 0;
-	if (overwrite.collections !== void 0) changes.collections = JSON.stringify([...new Set(overwrite.collections)]);
-	const group = await db.insertInto("_emdash_taxonomy_def_groups").values({
-		id: groupId,
-		name,
-		hierarchical: structure.hierarchical ? 1 : 0,
-		collections: JSON.stringify([...new Set(structure.collections)])
-	}).onConflict((oc) => Object.keys(changes).length > 0 ? oc.column("name").doUpdateSet(changes) : oc.column("name").doNothing()).returning([
-		"id",
-		"hierarchical",
-		"collections"
-	]).executeTakeFirst() ?? await db.selectFrom("_emdash_taxonomy_def_groups").select([
-		"id",
-		"hierarchical",
-		"collections"
-	]).where("name", "=", name).executeTakeFirstOrThrow();
-	await db.updateTable("_emdash_taxonomy_defs").set({
-		hierarchical: group.hierarchical,
-		collections: group.collections,
-		translation_group: group.id
-	}).where("name", "=", name).execute();
-	return group.id;
-}
-/** Parse a stored `collections` value, skipping anything that isn't a string list. */
-function parseTaxonomyCollections(value) {
-	if (!value) return [];
-	let parsed;
-	try {
-		parsed = JSON.parse(value);
-	} catch {
-		return [];
-	}
-	if (!Array.isArray(parsed)) return [];
-	return [...new Set(parsed.filter((entry) => typeof entry === "string"))];
-}
-
-//#endregion
-//#region src/page/seo-panel.ts
-function seoPanelCacheKey(collection, id) {
-	return `seo-panel:${collection}:${id}`;
-}
-/**
-* Prime the request-scoped SEO panel cache for a content entry.
-*
-* Called wherever an entry's folded SEO data materializes: the loader's
-* single-entry path (fresh query) and the object-cache revive path in
-* `getEmDashEntry` (warm hit, where the loader never runs). No-ops outside
-* a request context; never overwrites an already-primed value.
-*/
-function primeSeoPanel(collection, id, seo) {
-	setRequestCacheEntry(seoPanelCacheKey(collection, id), seo);
-}
-
-//#endregion
-//#region src/loader.ts
-var loader_exports = /* @__PURE__ */ __exportAll({
-	CURSOR_RAW_VALUES: () => CURSOR_RAW_VALUES,
-	FOLDED_BYLINES: () => FOLDED_BYLINES,
-	FOLDED_BYLINES_EXIST: () => FOLDED_BYLINES_EXIST,
-	FOLDED_TERMS: () => FOLDED_TERMS,
-	LARGE_TERM_ASSIGNMENTS: () => LARGE_TERM_ASSIGNMENTS,
-	buildTaxonomyPivotQuery: () => buildTaxonomyPivotQuery,
-	creditsFromFoldedBylines: () => creditsFromFoldedBylines,
-	emdashLoader: () => emdashLoader,
-	encodeSortCursor: () => encodeSortCursor,
-	getDb: () => getDb,
-	loadEntriesByGroups: () => loadEntriesByGroups,
-	resetTaxonomyNamesCache: () => resetTaxonomyNamesCache
-});
-const FIELD_NAME_PATTERN = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
-/**
-* SEO columns folded into the single-entry query as a single JSON column
-* (`_emdash_seo` in the result set), then expanded onto the row under these
-* aliases for `extractSeo()`. Surfacing SEO as one aggregated column keeps the
-* result-set width bounded regardless of how many fields the collection has,
-* which matters for D1: a flat `LEFT JOIN _emdash_seo` adds 5 alias columns to
-* every row and pushes wide collections (common after WordPress / ACF imports)
-* past D1's per-result-set column limit, surfacing as a silent null entry.
-* One JSON column is one column, so the join stays safe at any schema width.
-*
-* The aliases mirror the strategy used by `foldedHydrationSelects` for byline
-* and taxonomy hydration: aggregate in SQL, expand in JS. SEO is 1:1 with
-* content, so the subquery uses `json_object` (not the array aggregator).
-*
-* The `_emdash_` prefix on the aliases guarantees they can never collide with
-* a content field. Field slugs must match `/^[a-z][a-z0-9_]*$/`, so a user can
-* legitimately define a `seo_title` field; surfacing the SEO column under its
-* bare name would shadow that field in the result set and drop the user's
-* value. The prefix (illegal as a leading slug char) sidesteps this entirely.
-*/
-const SEO_COLUMN_ALIASES = {
-	seo_title: "_emdash_seo_title",
-	seo_description: "_emdash_seo_description",
-	seo_image: "_emdash_seo_image",
-	seo_canonical: "_emdash_seo_canonical",
-	seo_no_index: "_emdash_seo_no_index"
-};
-/** Aliased SEO result keys — excluded from generic field mapping. */
-const SEO_ALIAS_COLUMNS = Object.values(SEO_COLUMN_ALIASES);
-/** Folded SEO JSON column name in the result set (expanded onto aliases in JS). */
-const SEO_FOLDED_COLUMN = "_emdash_seo";
-/** Folded boolean field slugs used to restore SQLite integer values. */
-const BOOLEAN_FIELDS_FOLDED_COLUMN = "_emdash_boolean_fields";
-/** Rank of a row among its translation group's variants, in {@link loadEntriesByGroups}. */
-const VARIANT_RANK_COLUMN = "_emdash_variant_rank";
-/**
-* System columns excluded from entry.data
-* Note: slug is intentionally NOT excluded - it's useful as data.slug in templates
-*/
-const SYSTEM_COLUMNS = new Set([
-	"id",
-	"status",
-	"author_id",
-	"primary_byline_id",
-	"created_at",
-	"updated_at",
-	"published_at",
-	"scheduled_at",
-	"deleted_at",
-	"version",
-	"live_revision_id",
-	"draft_revision_id",
-	"locale",
-	"translation_group",
-	...SEO_ALIAS_COLUMNS,
-	"_emdash_terms",
-	"_emdash_bylines",
-	"_emdash_bylines_exist",
-	SEO_FOLDED_COLUMN,
-	BOOLEAN_FIELDS_FOLDED_COLUMN,
-	VARIANT_RANK_COLUMN
-]);
-/** Markers for byline/taxonomy hydration folded into the content query. */
-const FOLDED_TERMS = Symbol.for("emdash:foldedTerms");
-const FOLDED_BYLINES = Symbol.for("emdash:foldedBylines");
-/**
-* Marker for whether `_emdash_bylines` has any rows at all (`false` = table
-* empty). Lets byline hydration trust an empty fold instead of re-checking
-* via the byline query path on sites that never use bylines.
-*/
-const FOLDED_BYLINES_EXIST = Symbol.for("emdash:foldedBylinesExist");
-/**
-* Correlated JSON-array subqueries that fold taxonomy-term and byline hydration
-* into the content query, removing the two separate hydration round trips per
-* fetch. `outer` is the content table's alias/name; each subquery correlates on
-* `<outer>.id`, so the base query stays one row per entry (no join fan-out, no
-* duplicated content payload). Order is NOT applied in the aggregate (it differs
-* across dialects) — the consumer sorts terms by label and credits by sortOrder.
-*
-* Dialect-specific aggregation: SQLite `json_group_array`/`json_object` returns
-* a JSON *string*; Postgres `json_agg`/`json_build_object` (coalesced to `[]`)
-* returns parsed JSON. {@link stashFolded} handles both.
-*/
-function foldedHydrationSelects(db, type, outer) {
-	const o = sql.ref(outer);
-	const pg = isPostgres(db);
-	const obj = (pairs) => pg ? sql.raw(`json_build_object(${pairs})`) : sql.raw(`json_object(${pairs})`);
-	const agg = (inner) => pg ? sql`coalesce(json_agg(${inner}), '[]'::json)` : sql`json_group_array(${inner})`;
-	const foldJoin = pg ? sql`JOIN` : sql`CROSS JOIN`;
-	const termObj = obj("'id', coalesce(exact_term.id, default_term.id), 'name', coalesce(exact_term.name, default_term.name), 'slug', coalesce(exact_term.slug, default_term.slug), 'label', coalesce(exact_term.label, default_term.label), 'parent_id', coalesce(exact_term.parent_id, default_term.parent_id), 'locale', coalesce(exact_term.locale, default_term.locale), 'translation_group', coalesce(exact_term.translation_group, default_term.translation_group)");
-	const defaultLocale = getI18nConfig()?.defaultLocale ?? "en";
-	const selectedTermId = sql`coalesce(exact_term.id, default_term.id)`;
-	const terms = sql`(SELECT ${pg ? sql`coalesce(json_agg(${termObj}) FILTER (WHERE ${selectedTermId} IS NOT NULL), '[]'::json)` : sql`json_group_array(${termObj}) FILTER (WHERE ${selectedTermId} IS NOT NULL)`} FROM ${sql.ref("content_taxonomies")} AS ct LEFT JOIN ${sql.ref("taxonomies")} AS exact_term ON exact_term.translation_group = ct.taxonomy_id AND exact_term.locale = ${o}.locale LEFT JOIN ${sql.ref("taxonomies")} AS default_term ON default_term.translation_group = ct.taxonomy_id AND default_term.locale = ${defaultLocale} WHERE ct.collection = ${type} AND ct.entry_id = ${o}.translation_group) AS ${sql.ref("_emdash_terms")}`;
-	const bylineInner = obj("'id', b.id, 'slug', b.slug, 'displayName', b.display_name, 'bio', b.bio, 'avatarMediaId', b.avatar_media_id, 'avatarStorageKey', m.storage_key, 'avatarAlt', m.alt, 'avatarBlurhash', m.blurhash, 'avatarDominantColor', m.dominant_color, 'websiteUrl', b.website_url, 'userId', b.user_id, 'isGuest', b.is_guest, 'createdAt', b.created_at, 'updatedAt', b.updated_at, 'locale', b.locale, 'translationGroup', b.translation_group");
-	return {
-		terms,
-		bylines: sql`(SELECT ${agg(sql`${pg ? sql.raw("json_build_object('roleLabel', cb.role_label, 'sortOrder', cb.sort_order, 'byline', ") : sql.raw("json_object('roleLabel', cb.role_label, 'sortOrder', cb.sort_order, 'byline', ")}${bylineInner})`)} FROM ${sql.ref("_emdash_content_bylines")} AS cb ${foldJoin} ${sql.ref("_emdash_bylines")} AS b ON b.translation_group = cb.byline_id LEFT JOIN ${sql.ref("media")} AS m ON m.id = b.avatar_media_id WHERE cb.collection_slug = ${type} AND cb.content_id = ${o}.id AND b.locale = ${o}.locale) AS ${sql.ref("_emdash_bylines")}`,
-		bylinesExist: sql`(SELECT 1 FROM ${sql.ref("_emdash_bylines")} LIMIT 1) AS ${sql.ref("_emdash_bylines_exist")}`
-	};
-}
-/**
-* Correlated JSON-object subquery that folds per-entry SEO into the content
-* query without widening the result set: 1 row of `_emdash_seo` becomes 1 JSON
-* column rather than 5 flat columns. The JSON column is expanded onto the row
-* via {@link expandFoldedSeo} after the query runs, preserving the alias keys
-* that {@link extractSeo} reads. Missing SEO row (no entry in `_emdash_seo`)
-* yields NULL, which {@link expandFoldedSeo} treats as "no SEO" - identical to
-* the prior LEFT JOIN miss behavior.
-*
-* Dialect-specific aggregation mirrors {@link foldedHydrationSelects}: SQLite
-* `json_object` returns a JSON *string*, Postgres `json_build_object` returns
-* parsed JSON; both branches are handled in expansion.
-*/
-function foldedSeoSelect(db, type, outer) {
-	const o = sql.ref(outer);
-	const pg = isPostgres(db);
-	const pairs = "'seo_title', s.seo_title, 'seo_description', s.seo_description, 'seo_image', s.seo_image, 'seo_canonical', s.seo_canonical, 'seo_no_index', s.seo_no_index";
-	return sql`(SELECT ${pg ? sql.raw(`json_build_object(${pairs})`) : sql.raw(`json_object(${pairs})`)} FROM ${sql.ref("_emdash_seo")} AS s WHERE s.collection = ${type} AND s.content_id = ${o}.id LIMIT 1) AS ${sql.ref(SEO_FOLDED_COLUMN)}`;
-}
-function foldedBooleanFieldsSelect(db, type) {
-	return sql`(
-		SELECT ${isPostgres(db) ? sql`coalesce(json_agg(f.slug), '[]'::json)` : sql`json_group_array(f.slug)`}
-		FROM ${sql.ref("_emdash_fields")} AS f
-		INNER JOIN ${sql.ref("_emdash_collections")} AS c ON c.id = f.collection_id
-		WHERE c.slug = ${type} AND f.type = ${"boolean"}
-	) AS ${sql.ref(BOOLEAN_FIELDS_FOLDED_COLUMN)}`;
-}
-/**
-* Expand the folded `_emdash_seo` JSON column onto the row using SEO_COLUMN_ALIASES,
-* so {@link extractSeo} reads it transparently. SQLite returns a JSON string
-* (parse it); Postgres returns already-parsed JSON. Missing/malformed/null is
-* a no-op: {@link extractSeo} returns null when the aliases are absent.
-*/
-function isPlainObject(value) {
-	return !!value && typeof value === "object" && !Array.isArray(value);
-}
-function expandFoldedSeo(row) {
-	const raw = row[SEO_FOLDED_COLUMN];
-	delete row[SEO_FOLDED_COLUMN];
-	let parsed = null;
-	if (typeof raw === "string") try {
-		const candidate = JSON.parse(raw);
-		if (isPlainObject(candidate)) parsed = candidate;
-	} catch {
-		return;
-	}
-	else if (isPlainObject(raw)) parsed = raw;
-	if (!parsed) return;
-	for (const [col, alias] of Object.entries(SEO_COLUMN_ALIASES)) row[alias] = parsed[col] ?? null;
-}
-function creditsFromFoldedBylines(folded) {
-	return folded.map((raw) => {
-		const credit = isPlainObject(raw) ? raw : {};
-		const byline = isPlainObject(credit.byline) ? credit.byline : {};
-		return {
-			roleLabel: typeof credit.roleLabel === "string" ? credit.roleLabel : null,
-			sortOrder: Number(credit.sortOrder ?? 0),
-			source: "explicit",
-			byline: {
-				...byline,
-				isGuest: Boolean(byline.isGuest),
-				customFields: {}
-			}
-		};
-	}).toSorted((a, b) => a.sortOrder - b.sortOrder);
-}
-/**
-* Stash folded hydration JSON (non-enumerable) for the query.ts fast paths.
-* SQLite returns a JSON string (parse it); Postgres returns already-parsed JSON.
-*/
-function stashFolded(data, row) {
-	for (const [col, sym] of [["_emdash_terms", FOLDED_TERMS], ["_emdash_bylines", FOLDED_BYLINES]]) {
-		const raw = row[col];
-		let value;
-		if (typeof raw === "string") try {
-			value = JSON.parse(raw);
-		} catch {
-			continue;
-		}
-		else if (Array.isArray(raw)) value = raw;
-		else continue;
-		Object.defineProperty(data, sym, {
-			value,
-			enumerable: false,
-			configurable: true
-		});
-	}
-	if ("_emdash_bylines_exist" in row) Object.defineProperty(data, FOLDED_BYLINES_EXIST, {
-		value: row["_emdash_bylines_exist"] != null,
-		enumerable: false,
-		configurable: true
-	});
-	const foldedBylines = Reflect.get(data, FOLDED_BYLINES);
-	if (!Array.isArray(foldedBylines)) return;
-	const credits = creditsFromFoldedBylines(foldedBylines);
-	data.bylines = credits;
-	data.byline = credits[0]?.byline ?? null;
-}
-/**
-* Build a `data.seo` object from the joined `_emdash_seo` columns on a row.
-*
-* Returns `null` when no SEO row exists (LEFT JOIN miss → `seo_no_index` is
-* NULL, since the column is `NOT NULL DEFAULT 0` whenever a row is present).
-* Returning null keeps the `seo` key off entries that have none, so
-* `getSeoMeta()` falls back to its defaults exactly as before.
-*/
-function extractSeo(row) {
-	const noIndex = row[SEO_COLUMN_ALIASES.seo_no_index];
-	if (noIndex === null || noIndex === void 0) return null;
-	const title = row[SEO_COLUMN_ALIASES.seo_title];
-	const description = row[SEO_COLUMN_ALIASES.seo_description];
-	const image = row[SEO_COLUMN_ALIASES.seo_image];
-	const canonical = row[SEO_COLUMN_ALIASES.seo_canonical];
-	return {
-		title: typeof title === "string" ? title : null,
-		description: typeof description === "string" ? description : null,
-		image: typeof image === "string" ? image : null,
-		canonical: typeof canonical === "string" ? canonical : null,
-		noIndex: noIndex === 1
-	};
-}
-/**
-* Get the table name for a collection type
-*/
-function getTableName(type) {
-	validateIdentifier(type, "collection type");
-	return `ec_${type}`;
-}
-const TAXONOMY_NAMES_CACHE_KEY = Symbol.for("emdash:taxonomy-names");
-const taxonomyNamesStore = globalThis;
-const taxonomyNamesHolder = taxonomyNamesStore[TAXONOMY_NAMES_CACHE_KEY] ?? (() => {
-	const holder = { cache: null };
-	taxonomyNamesStore[TAXONOMY_NAMES_CACHE_KEY] = holder;
-	return holder;
-})();
-function setTaxonomyNamesCache(cache) {
-	taxonomyNamesHolder.cache = cache;
-}
-/**
-* Get taxonomy names attached to a collection (cached for the primary DB,
-* bypassed only when the per-request DB is an isolated instance — playground /
-* DO preview). Plain D1 Sessions routing shares schema with the singleton, so
-* the isolate-wide cache stays valid.
-*/
-async function getTaxonomyNames(db, collection) {
-	const hasIsolatedDb = getRequestContext()?.dbIsIsolated === true;
-	if (!hasIsolatedDb && taxonomyNamesHolder.cache) return taxonomyNamesHolder.cache.get(collection) ?? /* @__PURE__ */ new Set();
-	try {
-		const defs = await selectTaxonomyDefs(db).execute();
-		const namesByCollection = /* @__PURE__ */ new Map();
-		for (const def of defs) {
-			let collections;
-			try {
-				collections = JSON.parse(def.collections ?? "[]");
-			} catch {
-				continue;
-			}
-			if (!Array.isArray(collections)) continue;
-			for (const attachedCollection of collections) {
-				if (typeof attachedCollection !== "string") continue;
-				const names = namesByCollection.get(attachedCollection) ?? /* @__PURE__ */ new Set();
-				names.add(def.name);
-				namesByCollection.set(attachedCollection, names);
-			}
-		}
-		if (!hasIsolatedDb) setTaxonomyNamesCache(namesByCollection);
-		return namesByCollection.get(collection) ?? /* @__PURE__ */ new Set();
-	} catch (error) {
-		if (!isMissingTableError(error) && !isMissingColumnError(error)) throw error;
-		const empty = /* @__PURE__ */ new Set();
-		if (!hasIsolatedDb) setTaxonomyNamesCache(/* @__PURE__ */ new Map());
-		return empty;
-	}
-}
-/**
-* Reset the isolate-wide taxonomy-names cache.
-*
-* Called from `invalidateTaxonomyDefsCache()` so that creating or seeding a
-* taxonomy definition is reflected within the current isolate instead of
-* waiting for the isolate to recycle. Keeps this cache consistent with the
-* isolate-wide taxonomy-defs cache in `taxonomies/index.ts`.
-*/
-function resetTaxonomyNamesCache() {
-	setTaxonomyNamesCache(null);
-}
-/**
-* System columns to include in data (mapped to camelCase where needed)
-*/
-const INCLUDE_IN_DATA = {
-	id: "id",
-	status: "status",
-	author_id: "authorId",
-	primary_byline_id: "primaryBylineId",
-	created_at: "createdAt",
-	updated_at: "updatedAt",
-	published_at: "publishedAt",
-	scheduled_at: "scheduledAt",
-	draft_revision_id: "draftRevisionId",
-	live_revision_id: "liveRevisionId",
-	locale: "locale",
-	translation_group: "translationGroup"
-};
-/** System date columns that should be converted to Date objects */
-const DATE_COLUMNS = new Set([
-	"created_at",
-	"updated_at",
-	"published_at",
-	"scheduled_at"
-]);
-/**
-* Hidden, symbol-keyed property on each mapped data record carrying raw DB
-* values: the string of every date column and, in a collection load, the
-* primary sort column's value. Lets cursor encoders downstream reproduce the
-* loader's exact `nextCursor` from an entry, whose `data` leaves some columns
-* out, parses text that looks like JSON, and holds dates as `Date` objects,
-* which lose precision for stored values that aren't already
-* ISO-with-milliseconds (e.g. `2026-01-01T00:00:00Z` becomes
-* `2026-01-01T00:00:00.000Z`).
-*/
-const CURSOR_RAW_VALUES = Symbol("emdash:cursorRawValues");
-const LOCAL_MEDIA_FILE_PREFIX = "/_emdash/api/media/file/";
-const URL_SCHEME_PATTERN = /^[a-zA-Z][a-zA-Z\d+\-.]*:/;
-/** Safely extract a string value from a record, returning fallback if not a string */
-function rowStr(row, key, fallback = "") {
-	const val = row[key];
-	return typeof val === "string" ? val : fallback;
-}
-function isRecord(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isBareMediaKey(src) {
-	return !src.startsWith("/") && !URL_SCHEME_PATTERN.test(src);
-}
-function normalizeLocalMediaValue(value) {
-	if (Array.isArray(value)) return value.map(normalizeLocalMediaValue);
-	if (!isRecord(value)) return value;
-	const normalized = {};
-	for (const [key, child] of Object.entries(value)) normalized[key] = normalizeLocalMediaValue(child);
-	if (normalized.provider === "local" && typeof normalized.src === "string" && normalized.src.length > 0) {
-		const src = normalized.src;
-		if (src.startsWith(LOCAL_MEDIA_FILE_PREFIX)) {
-			const id = src.slice(24);
-			if (!normalized.id && id) normalized.id = id;
-		} else if (isBareMediaKey(src)) {
-			if (!normalized.id) normalized.id = src;
-			normalized.src = `${LOCAL_MEDIA_FILE_PREFIX}${src}`;
-		}
-	}
-	return normalized;
-}
-/**
-* Map a database row to entry data
-* Extracts content fields (non-system columns) and parses JSON where needed.
-* System columns needed for templates (id, status, dates) are included with camelCase names.
-*/
-function mapRowToData(row, booleanFields, sortColumn) {
-	const data = {};
-	const rawValues = {};
-	for (const [key, value] of Object.entries(row)) {
-		if (key in INCLUDE_IN_DATA) {
-			if (DATE_COLUMNS.has(key)) if (typeof value === "string") {
-				rawValues[key] = value;
-				data[INCLUDE_IN_DATA[key]] = new Date(value);
-			} else data[INCLUDE_IN_DATA[key]] = null;
-			else data[INCLUDE_IN_DATA[key]] = value;
-			continue;
-		}
-		if (SYSTEM_COLUMNS.has(key)) continue;
-		if (booleanFields.has(key) && (typeof value === "boolean" || value === 0 || value === 1)) {
-			data[key] = Boolean(value);
-			continue;
-		}
-		if (typeof value === "string") try {
-			if (value.startsWith("{") || value.startsWith("[")) data[key] = normalizeLocalMediaValue(JSON.parse(value));
-			else data[key] = value;
-		} catch {
-			data[key] = value;
-		}
-		else data[key] = value;
-	}
-	stashSortValue(data, row, sortColumn, rawValues);
-	return data;
-}
-/**
-* Keep the row's raw sort value on `data` (non-enumerable) so the next-page
-* cursor is encoded from the same value the keyset query compares against.
-*/
-function stashSortValue(data, row, sortColumn, rawValues = {}) {
-	if (sortColumn !== void 0 && sortColumn in row) rawValues[sortColumn] = sortCursorValue(row[sortColumn]);
-	Object.defineProperty(data, CURSOR_RAW_VALUES, {
-		value: rawValues,
-		enumerable: false,
-		configurable: false,
-		writable: false
-	});
-}
-/**
-* Fetch the draft revision snapshots for the rows a collection read should
-* serve as drafts, keyed by content row ID. One query per `SQL_BATCH_SIZE`
-* revisions; nothing runs unless `scope` is set.
-*/
-async function loadDraftRevisions(db, rows, scope) {
-	const drafts = /* @__PURE__ */ new Map();
-	if (!scope) return drafts;
-	const wanted = /* @__PURE__ */ new Map();
-	for (const row of rows) {
-		const draftId = rowStr(row, "draft_revision_id");
-		if (!draftId) continue;
-		if (scope !== "all" && scope.id !== rowStr(row, "id") && scope.id !== rowStr(row, "slug") && scope.id !== entryIdForRow(row)) continue;
-		wanted.set(draftId, rowStr(row, "id"));
-	}
-	for (const ids of chunks([...wanted.keys()], SQL_BATCH_SIZE)) {
-		const result = await sql`
-			SELECT id, data FROM revisions WHERE id IN (${sql.join(ids)})
-		`.execute(db);
-		for (const revision of result.rows) {
-			const rowId = wanted.get(revision.id);
-			if (rowId) drafts.set(rowId, JSON.parse(revision.data));
-		}
-	}
-	return drafts;
-}
-/**
-* Build an entry whose content fields come from a revision snapshot, keeping
-* the system metadata of the content table row.
-*/
-function revisionEntry(row, parsed, booleanFields, sortColumn) {
-	const systemData = {};
-	for (const [key, mappedKey] of Object.entries(INCLUDE_IN_DATA)) if (key in row) if (DATE_COLUMNS.has(key)) systemData[mappedKey] = typeof row[key] === "string" ? new Date(row[key]) : null;
-	else systemData[mappedKey] = row[key];
-	const slug = typeof parsed._slug === "string" ? parsed._slug : rowStr(row, "slug");
-	const revSlug = slug || rowStr(row, "id");
-	const i18nConfig = virtualConfig?.i18n;
-	const i18nEnabled = i18nConfig && i18nConfig.locales.length > 1;
-	const revLocale = rowStr(row, "locale");
-	const shouldPrefixRev = i18nEnabled && revLocale !== "" && (revLocale !== i18nConfig.defaultLocale || i18nConfig.prefixDefaultLocale);
-	const data = {
-		...systemData,
-		slug,
-		...mapRevisionData(parsed, booleanFields)
-	};
-	stashSortValue(data, row, sortColumn);
-	return {
-		id: shouldPrefixRev ? `${revLocale}/${revSlug}` : revSlug,
-		slug,
-		status: rowStr(row, "status", "draft"),
-		data,
-		cacheHint: {
-			tags: [rowStr(row, "id")],
-			lastModified: row.updated_at ? new Date(rowStr(row, "updated_at")) : void 0
-		}
-	};
-}
-/**
-* The entry id Astro addresses a row by: its slug, prefixed with the locale
-* whenever i18n routing would prefix the URL. Shared by every path that builds
-* a loader entry so a referenced entry carries the same id it would have been
-* loaded under directly.
-*/
-function entryIdForRow(row) {
-	const i18nConfig = virtualConfig?.i18n;
-	const slug = rowStr(row, "slug") || rowStr(row, "id");
-	const locale = rowStr(row, "locale");
-	return i18nConfig && i18nConfig.locales.length > 1 && locale !== "" && (locale !== i18nConfig.defaultLocale || i18nConfig.prefixDefaultLocale) ? `${locale}/${slug}` : slug;
-}
-/**
-* Load one locale variant of each translation group, in one query per
-* `SQL_BATCH_SIZE` chunk of groups.
-*
-* A group's variant is the first of `localeChain` it has, or else its lowest
-* locale code: a reference names a translation group, so a target that exists
-* only outside the chain is still a real reference. Groups with no surviving
-* variant are absent from the result.
-*
-* The rows go through the same {@link mapRowToData} as a direct entry load, so
-* a referenced entry's `data` carries the same dates, booleans and normalized
-* media values a caller would get from `getEmDashEntry`. Bylines and taxonomy
-* terms are not hydrated; each would cost a correlated subquery per row.
-*/
-async function loadEntriesByGroups(type, translationGroups, options = {}) {
-	if (translationGroups.length === 0) return [];
-	const db = await getDb();
-	const tableName = getTableName(type);
-	const statusFilter = options.publishedOnly ? sql`AND status = ${"published"}` : sql``;
-	const booleanFieldsSelect = foldedBooleanFieldsSelect(db, type);
-	const localeChain = options.localeChain ?? [];
-	const chainPosition = localeChain.length > 0 ? sql`CASE locale ${sql.join(localeChain.map((locale, index) => sql`WHEN ${locale} THEN ${sql.lit(index)}`), sql` `)} ELSE ${sql.lit(localeChain.length)} END,` : sql``;
-	const entries = [];
-	try {
-		for (const chunk of chunks(translationGroups, SQL_BATCH_SIZE)) {
-			const result = await sql`
-				SELECT * FROM (
-					SELECT *, ${booleanFieldsSelect},
-						ROW_NUMBER() OVER (
-							PARTITION BY translation_group ORDER BY ${chainPosition} locale ASC
-						) AS ${sql.ref(VARIANT_RANK_COLUMN)}
-					FROM ${sql.ref(tableName)}
-					WHERE translation_group IN (${sql.join(chunk.map((group) => sql`${group}`))})
-					AND deleted_at IS NULL
-					${statusFilter}
-				) AS variants
-				WHERE ${sql.ref(VARIANT_RANK_COLUMN)} = 1
-				ORDER BY translation_group ASC
-			`.execute(db);
-			const booleanFields = parseFoldedBooleanFields(result.rows[0]);
-			for (const row of result.rows) entries.push({
-				id: entryIdForRow(row),
-				slug: rowStr(row, "slug"),
-				status: rowStr(row, "status", "draft"),
-				data: mapRowToData(row, booleanFields),
-				cacheHint: {
-					tags: [rowStr(row, "id")],
-					lastModified: row.updated_at ? new Date(rowStr(row, "updated_at")) : void 0
-				}
-			});
-		}
-	} catch (error) {
-		if (isMissingTableError(error)) return [];
-		throw error;
-	}
-	return entries;
-}
-function parseFoldedBooleanFields(row) {
-	const raw = row?.[BOOLEAN_FIELDS_FOLDED_COLUMN];
-	let values;
-	if (typeof raw === "string") try {
-		values = JSON.parse(raw);
-	} catch {
-		return /* @__PURE__ */ new Set();
-	}
-	else values = raw;
-	if (!Array.isArray(values)) return /* @__PURE__ */ new Set();
-	return new Set(values.filter((value) => typeof value === "string"));
-}
-/**
-* Map revision data (already-parsed JSON object) to entry data.
-* Strips _-prefixed metadata keys (e.g. _slug) used internally by revisions.
-*/
-function mapRevisionData(data, booleanFields) {
-	const result = {};
-	for (const [key, value] of Object.entries(data)) {
-		if (key.startsWith("_")) continue;
-		if (booleanFields.has(key) && (typeof value === "boolean" || value === 0 || value === 1)) {
-			result[key] = Boolean(value);
-			continue;
-		}
-		result[key] = normalizeLocalMediaValue(value);
-	}
-	return result;
-}
-let virtualConfig;
-let virtualCreateDialect;
-async function loadVirtualConfig() {
-	if (virtualConfig === void 0) virtualConfig = (await import("virtual:emdash/config")).default;
-}
-async function loadVirtualModules() {
-	await loadVirtualConfig();
-	if (virtualCreateDialect === void 0) virtualCreateDialect = (await import("virtual:emdash/dialect")).createDialect;
-}
-/**
-* Get the primary sort field from an orderBy spec (first valid field, or default).
-*/
-function getPrimarySort(orderBy, tablePrefix) {
-	if (orderBy) {
-		for (const [field, direction] of Object.entries(orderBy)) if (FIELD_NAME_PATTERN.test(field)) return {
-			field: tablePrefix ? `${tablePrefix}.${field}` : field,
-			direction
-		};
-	}
-	return {
-		field: tablePrefix ? `${tablePrefix}.created_at` : "created_at",
-		direction: "desc"
-	};
-}
-/**
-* Build ORDER BY clause from orderBy spec
-* Validates field names to prevent SQL injection (alphanumeric + underscore only)
-* Supports multiple sort fields in object key order
-*/
-function buildOrderByClause(orderBy, tablePrefix) {
-	if (!orderBy || Object.keys(orderBy).length === 0) {
-		const field = tablePrefix ? `${tablePrefix}.created_at` : "created_at";
-		return sql`ORDER BY ${sql.ref(field)} DESC, ${sql.ref(tablePrefix ? `${tablePrefix}.id` : "id")} DESC`;
-	}
-	const sortParts = [];
-	for (const [field, direction] of Object.entries(orderBy)) {
-		if (!FIELD_NAME_PATTERN.test(field)) continue;
-		const fullField = tablePrefix ? `${tablePrefix}.${field}` : field;
-		const dir = direction === "asc" ? sql`ASC` : sql`DESC`;
-		sortParts.push(sql`${sql.ref(fullField)} ${dir}`);
-	}
-	if (sortParts.length === 0) {
-		const defaultField = tablePrefix ? `${tablePrefix}.created_at` : "created_at";
-		return sql`ORDER BY ${sql.ref(defaultField)} DESC, ${sql.ref(tablePrefix ? `${tablePrefix}.id` : "id")} DESC`;
-	}
-	const primary = getPrimarySort(orderBy, tablePrefix);
-	const idField = tablePrefix ? `${tablePrefix}.id` : "id";
-	const idDir = primary.direction === "asc" ? sql`ASC` : sql`DESC`;
-	sortParts.push(sql`${sql.ref(idField)} ${idDir}`);
-	return sql`ORDER BY ${sql.join(sortParts, sql`, `)}`;
-}
-/**
-* Sort columns every row has a value for. Their cursors keep the plain
-* `{ orderValue, id }` shape; any other sort column can hold NULL.
-*/
-const NON_NULL_SORT_COLUMNS = new Set([
-	"id",
-	"created_at",
-	"updated_at",
-	"status",
-	"locale"
-]);
-function sortCursorValue(value) {
-	if (typeof value === "string" || typeof value === "number") return value;
-	if (typeof value === "boolean") return value ? 1 : 0;
-	if (value instanceof Date) return value.toISOString();
-	return null;
-}
-/**
-* Encode the cursor for the page after the row whose primary sort column
-* `field` holds `value`.
-*
-* @internal shared with query.ts, which re-encodes cursors from entries.
-*/
-function encodeSortCursor(field, value, id) {
-	const cursorValue = sortCursorValue(value);
-	if (NON_NULL_SORT_COLUMNS.has(field)) return encodeCursor(cursorValue === null ? "" : String(cursorValue), id);
-	const payload = {
-		version: 1,
-		field,
-		value: cursorValue
-	};
-	return encodeCursor(JSON.stringify(payload), id);
-}
-function decodeSortCursor(cursor, field) {
-	const { orderValue, id } = decodeCursor(cursor);
-	if (NON_NULL_SORT_COLUMNS.has(field)) return {
-		value: orderValue,
-		id
-	};
-	let payload;
-	try {
-		payload = JSON.parse(orderValue);
-	} catch {
-		payload = void 0;
-	}
-	if (payload === null || typeof payload !== "object") return {
-		value: orderValue === "" ? null : orderValue,
-		id
-	};
-	const candidate = payload;
-	const { value } = candidate;
-	if (candidate.version !== 1 || candidate.field !== field || value !== null && typeof value !== "string" && typeof value !== "number") throw new InvalidCursorError(cursor);
-	return {
-		value,
-		id
-	};
-}
-/**
-* Keyset condition for the rows after `cursor`, ordered by `sort` then `id`
-* in `direction`. The ORDER BY keeps each dialect's own NULL position, lowest
-* on SQLite and highest on Postgres, so the condition follows it.
-*
-* Throws `InvalidCursorError` if the cursor is malformed; callers should
-* let this propagate so users see a real error rather than silently
-* falling back to the first page.
-*/
-function sortCursorCondition(db, cursor, column, direction, sort, id) {
-	const { value, id: cursorId } = decodeSortCursor(cursor, column);
-	const cmp = direction === "asc" ? sql.raw(">") : sql.raw("<");
-	const nullsFirst = direction === "asc" !== isPostgres(db);
-	if (value === null) return nullsFirst ? sql`(${sort} IS NOT NULL OR ${id} ${cmp} ${cursorId})` : sql`(${sort} IS NULL AND ${id} ${cmp} ${cursorId})`;
-	const past = sql`${sort} ${cmp} ${value} OR (${sort} = ${value} AND ${id} ${cmp} ${cursorId})`;
-	return nullsFirst || NON_NULL_SORT_COLUMNS.has(column) ? sql`(${past})` : sql`(${past} OR ${sort} IS NULL)`;
-}
-/**
-* Build a cursor WHERE condition for keyset pagination.
-* Uses the primary sort field + id as tiebreaker for stable ordering.
-*/
-function buildCursorCondition(db, cursor, orderBy, tablePrefix) {
-	const primary = getPrimarySort(orderBy);
-	const ref = (column) => sql.ref(tablePrefix ? `${tablePrefix}.${column}` : column);
-	return sortCursorCondition(db, cursor, primary.field, primary.direction, ref(primary.field), ref("id"));
-}
-/** Type guard: is the where value a range object (not a string or array)? */
-function isWhereRange(value) {
-	return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-/**
-* Keys a `where` or `orderBy` can name that belong to the table rather than to
-* a field. `slug` is one of them; {@link SYSTEM_COLUMNS} leaves it out because
-* it is kept in `entry.data` for templates.
-*/
-const SYSTEM_QUERY_KEYS = new Set([...SYSTEM_COLUMNS, "slug"]);
-/**
-* The first of `keys` that names a reference field bound to a relation, or
-* undefined.
-*
-* Such a field has no column: a `WHERE` on it fails with "no such column", which
-* the catch below reads as an empty collection, and a field bound after its
-* column existed answers from values it stopped writing. Both read to a template
-* as "nothing matched", so the key has to be caught before the query is built.
-*
-* System columns are answered without a lookup, and the lookup itself is cached
-* per request and in the schema object-cache namespace, so a render that filters
-* by an ordinary field pays for this at most once between schema changes, and a
-* render that filters by nothing never pays at all.
-*/
-async function findStoragelessQueryKey(collection, keys) {
-	const candidates = keys.filter((key) => !SYSTEM_QUERY_KEYS.has(key));
-	if (candidates.length === 0) return void 0;
-	const { getReferenceFieldMap } = await import("./field-map-Bft9LKak.mjs").then((n) => n.t);
-	const bound = await getReferenceFieldMap(collection);
-	return candidates.find((key) => bound.has(key));
-}
-/**
-* A boolean field owns an INTEGER column (`FIELD_TYPE_TO_COLUMN`) and its
-* values are written as 0/1, so binding a native `true` against one is a type
-* error on PostgreSQL. SQLite accepts the boolean and compares it as 1, which
-* is why filtering by a boolean field only ever broke on one dialect.
-*/
-function bindableFilterValue(value) {
-	return typeof value === "boolean" ? value ? 1 : 0 : value;
-}
-/**
-* Build AND conditions for non-taxonomy field filters.
-* Returns an array of sql fragments; empty if no field filters apply.
-* Field names are validated against FIELD_NAME_PATTERN to prevent injection.
-*
-* D1 allows 100 bound parameters per statement, and an array filter binds one
-* per value. So when the arrays in `fields` hold more than `SQL_BATCH_SIZE`
-* values between them, the longest arrays are bound as a single JSON parameter
-* each (`IN (SELECT value FROM json_each(?))`, or `jsonb_array_elements_text`
-* on PostgreSQL) until the rest fit. The statement stays one query, so
-* ordering, cursors, limit and offset stay in the database. Values bound that
-* way compare as text.
-*/
-function buildFieldConditions(db, fields, tablePrefix) {
-	const conditions = [];
-	const arrayLengths = Object.entries(fields).filter((entry) => Array.isArray(entry[1])).map(([key, value]) => [key, value.length]).toSorted((a, b) => b[1] - a[1]);
-	let inlineValues = arrayLengths.reduce((sum, [, length]) => sum + length, 0);
-	const asJson = /* @__PURE__ */ new Set();
-	for (const [key, length] of arrayLengths) {
-		if (inlineValues <= SQL_BATCH_SIZE) break;
-		asJson.add(key);
-		inlineValues -= length;
-	}
-	for (const [key, value] of Object.entries(fields)) {
-		if (!FIELD_NAME_PATTERN.test(key)) {
-			console.warn(`[emdash] where filter: invalid field name "${key}" ignored`);
-			continue;
-		}
-		if (value == null) continue;
-		const ref = tablePrefix ? sql.ref(`${tablePrefix}.${key}`) : sql.ref(key);
-		if (isWhereRange(value)) {
-			const { gt, gte, lt, lte } = value;
-			if (gt === void 0 && gte === void 0 && lt === void 0 && lte === void 0) {
-				console.warn(`[emdash] where filter: "${key}" is an object with none of gt/gte/lt/lte and was ignored (use an array for IN)`);
-				continue;
-			}
-			if (gt !== void 0) conditions.push(sql`${ref} > ${bindableFilterValue(gt)}`);
-			if (gte !== void 0) conditions.push(sql`${ref} >= ${bindableFilterValue(gte)}`);
-			if (lt !== void 0) conditions.push(sql`${ref} < ${bindableFilterValue(lt)}`);
-			if (lte !== void 0) conditions.push(sql`${ref} <= ${bindableFilterValue(lte)}`);
-		} else if (Array.isArray(value)) {
-			if (value.length === 0) continue;
-			if (asJson.has(key)) {
-				const values = value.map((v) => String(bindableFilterValue(v)));
-				conditions.push(sql`${ref} IN (${jsonTextValues(db, values)})`);
-			} else conditions.push(sql`${ref} IN (${sql.join(value.map((v) => sql`${bindableFilterValue(v)}`))})`);
-		} else conditions.push(sql`${ref} = ${bindableFilterValue(value)}`);
-	}
-	return conditions;
-}
-/**
-* Pivot rows from which a term counts as large. Seeking the pivot reads every
-* assignment of the term; walking `ec_*` in sort order reads about
-* `collection size / term size` rows per match. The walk wins only for large
-* terms, and the size probe reads at most this many pivot index entries.
-*
-* The walk estimate assumes the term's entries are spread over the sort order
-* and the requested locale. A term clustered in time, a deep page or a narrow
-* byline filter makes the walk read up to the whole collection; the seek would
-* still read every assignment of the term.
-*/
-const LARGE_TERM_ASSIGNMENTS = 200;
-/** A single `published_at`/`created_at` sort, which an `ec_*` index serves in order. */
-function isIndexedPivotSort(orderBy) {
-	const validSortKeys = orderBy ? Object.keys(orderBy).filter((k) => FIELD_NAME_PATTERN.test(k)) : [];
-	const primary = getPrimarySort(orderBy);
-	return validSortKeys.length <= 1 && (primary.field === "published_at" || primary.field === "created_at");
-}
-/**
-* Resolve a taxonomy filter (`name` + one or more `slug`s, optionally scoped to
-* `locale`) to the set of `translation_group`s the pivot stores in
-* `content_taxonomies.taxonomy_id`. Exact terms only — no subtree expansion.
-*
-* Mirrors the meaning of the old EXISTS join (`t.name = ? AND t.slug IN (?)
-* [AND t.locale = ?]`): a pivot row matches when its group has a term with that
-* name/slug in the active locale. Resolving to explicit values (rather than an
-* `IN (subquery)`) keeps the single-term case a plain equality on the pivot
-* index, which is what gives the clean early-`LIMIT` seek.
-*
-* With `probeCollection`, `large` reports whether a resolved term has at least
-* {@link LARGE_TERM_ASSIGNMENTS} pivot rows in that collection. The capped
-* probe rides in this query; a query of its own would add a round trip to
-* every listing.
-*/
-async function resolveTermGroups(db, name, slugs, locale, probeCollection) {
-	let query = db.selectFrom("taxonomies").select("translation_group").distinct().where("name", "=", name).where("slug", "in", slugs).$if(probeCollection !== void 0, (qb) => qb.select((eb) => eb.selectFrom("content_taxonomies").select(sql`1`.as("hit")).where("content_taxonomies.collection", "=", probeCollection).whereRef("content_taxonomies.taxonomy_id", "=", "taxonomies.translation_group").limit(1).offset(LARGE_TERM_ASSIGNMENTS - 1).as("large")));
-	if (locale) query = query.where("locale", "=", locale);
-	const rows = await query.execute();
-	const groups = /* @__PURE__ */ new Set();
-	let large = false;
-	for (const row of rows) {
-		if (row.translation_group) groups.add(row.translation_group);
-		if (row.large != null) large = true;
-	}
-	return {
-		groups: [...groups],
-		large
-	};
-}
-/** Equality (single) or `IN` (multiple) condition on a pivot group column. */
-function pivotGroupCondition(ref, groups) {
-	if (groups.length === 1) return sql`${sql.ref(ref)} = ${groups[0]}`;
-	return sql`${sql.ref(ref)} IN (${sql.join(groups.map((g) => sql`${g}`))})`;
-}
-/** LIMIT/OFFSET fragment matching the loader's single-table variant. */
-function buildPivotLimitOffset(db, fetchLimit, offset) {
-	if (fetchLimit != null && offset != null) return sql`LIMIT ${fetchLimit} OFFSET ${offset}`;
-	if (fetchLimit != null) return sql`LIMIT ${fetchLimit}`;
-	if (offset != null) return isPostgres(db) ? sql`OFFSET ${offset}` : sql`LIMIT -1 OFFSET ${offset}`;
-	return sql``;
-}
-/**
-* Build the pivot-driven taxonomy listing query (#1834).
-*
-* Joins the term pivot to content translations through their shared
-* translation_group. Content columns remain authoritative for locale,
-* visibility, sorting, and cursor predicates.
-*
-* Two shapes:
-* - **Indexed sort** (`published_at`/`created_at`, single sort field): the
-*   `LIMIT` lives in `picked`, which either sorts the term's candidates or,
-*   with `driveFromContent`, walks the `ec_*` sort index and stops at `LIMIT`.
-* - **Temp-sort** (`updated_at` or any other field, or multi-field sort): no
-*   pivot sort index applies, so `picked` collects the tagged candidate set and
-*   the outer query sorts the joined rows. Bounded to tagged rows — no
-*   `ec_*` full scan — but no early-`LIMIT`.
-*/
-function buildTaxonomyPivotQuery(opts) {
-	const { db, collection, tableName, groupSets, orderBy, cursor, locale, status, deletedIsNull, bylineGroups, fetchLimit, offset, driveFromContent = false } = opts;
-	const primary = getPrimarySort(orderBy);
-	const isIndexedSort = isIndexedPivotSort(orderBy);
-	const dir = primary.direction === "asc" ? sql`ASC` : sql`DESC`;
-	const firstGroups = groupSets[0] ?? [];
-	const restGroups = groupSets.slice(1);
-	const multiGroup = firstGroups.length > 1;
-	const residual = restGroups.length > 0 ? sql`${sql.join(restGroups.map((g) => sql`AND EXISTS (
-						SELECT 1 FROM content_taxonomies ct2
-						WHERE ct2.collection = ${collection}
-							AND ct2.entry_id = ct.entry_id
-							AND ${pivotGroupCondition("ct2.taxonomy_id", g)}
-					)`), sql` `)}` : sql``;
-	const bylineCt = bylineGroups ? sql`AND EXISTS (
-				SELECT 1 FROM _emdash_content_bylines cb
-				WHERE cb.collection_slug = ${collection}
-					AND cb.content_id = r.id
-					AND cb.byline_id IN (${sql.join(bylineGroups.map((g) => sql`${g}`))})
-			)` : sql``;
-	const firstGroupCond = pivotGroupCondition("ct.taxonomy_id", firstGroups);
-	const pivotContentJoin = isPostgres(db) || driveFromContent ? sql`JOIN` : sql`CROSS JOIN`;
-	const { terms: termsSelect, bylines: bylinesSelect, bylinesExist: bylinesExistSelect } = foldedHydrationSelects(db, collection, "r");
-	const booleanFieldsSelect = foldedBooleanFieldsSelect(db, collection);
-	const deletedR = deletedIsNull ? sql`r.deleted_at IS NULL` : sql`r.deleted_at IS NOT NULL`;
-	const statusR = status !== void 0 ? sql`AND ${buildStatusCondition(db, status, "r")}` : sql``;
-	const localeR = locale ? sql`AND r.locale = ${locale}` : sql``;
-	if (isIndexedSort) {
-		const sortRef = sql.ref(`r.${primary.field}`);
-		const sortval = multiGroup ? sql`MAX(${sortRef})` : sortRef;
-		const groupByClause = multiGroup ? sql`GROUP BY r.id` : sql``;
-		let cursorClause = sql``;
-		let havingClause = sql``;
-		if (cursor) {
-			const cond = sortCursorCondition(db, cursor, primary.field, primary.direction, sortval, sql.ref("r.id"));
-			if (multiGroup) havingClause = sql`HAVING ${cond}`;
-			else cursorClause = sql`AND ${cond}`;
-		}
-		const limitClause = buildPivotLimitOffset(db, fetchLimit, offset);
-		return sql`
-			WITH picked AS (
-				SELECT r.id AS entry_id, ${sortval} AS sortval
-				FROM content_taxonomies ct
-				${pivotContentJoin} ${sql.ref(tableName)} AS r ON r.translation_group = ct.entry_id
-				WHERE ct.collection = ${collection}
-					AND ${firstGroupCond}
-					AND ${deletedR}
-					${statusR}
-					${localeR}
-					${residual}
-					${bylineCt}
-					${cursorClause}
-				${groupByClause}
-				${havingClause}
-				ORDER BY sortval ${dir}, r.id ${dir}
-				${limitClause}
-			)
-			SELECT r.*, ${termsSelect}, ${bylinesSelect}, ${bylinesExistSelect}, ${booleanFieldsSelect}
-			FROM picked JOIN ${sql.ref(tableName)} AS r ON r.id = picked.entry_id
-			WHERE ${deletedR} ${statusR} ${localeR}
-			ORDER BY picked.sortval ${dir}, picked.entry_id ${dir}
-		`;
-	}
-	const orderByClause = buildOrderByClause(orderBy, "r");
-	const cursorCond = cursor ? sql`AND ${buildCursorCondition(db, cursor, orderBy, "r")}` : sql``;
-	const limitClause = buildPivotLimitOffset(db, fetchLimit, offset);
-	return sql`
-		WITH picked AS (
-			SELECT DISTINCT r.id AS entry_id
-			FROM content_taxonomies ct
-			${pivotContentJoin} ${sql.ref(tableName)} AS r ON r.translation_group = ct.entry_id
-			WHERE ct.collection = ${collection}
-				AND ${firstGroupCond}
-				AND ${deletedR}
-				${statusR}
-				${localeR}
-				${residual}
-				${bylineCt}
-		)
-		SELECT r.*, ${termsSelect}, ${bylinesSelect}, ${bylinesExistSelect}, ${booleanFieldsSelect}
-		FROM picked JOIN ${sql.ref(tableName)} AS r ON r.id = picked.entry_id
-		WHERE ${deletedR} ${statusR} ${localeR}
-			${cursorCond}
-		${orderByClause}
-		${limitClause}
-	`;
-}
-let dbInstance = null;
-/**
-* Get the database instance. Used by query wrapper functions and middleware.
-*
-* Checks the ALS request context first — if a per-request DB override is set
-* (e.g. by DO preview middleware), it takes precedence over the module-level
-* cached instance. This allows preview mode to route queries to an isolated
-* Durable Object database without modifying any calling code.
-*
-* Initializes the default database on first call using config from virtual module.
-*/
-async function getDb() {
-	await loadVirtualConfig();
-	const ctx = getRequestContext();
-	if (ctx?.db) return ctx.db;
-	if (!dbInstance) {
-		await loadVirtualModules();
-		if (!virtualConfig?.database || typeof virtualCreateDialect !== "function") throw new Error("EmDash database not configured. Add database config to emdash() in astro.config.mjs");
-		dbInstance = new Kysely({
-			dialect: virtualCreateDialect(virtualConfig.database.config),
-			log: kyselyLogOption()
-		});
-	}
-	return dbInstance;
-}
-/**
-* Create an EmDash Live Collections loader
-*
-* This loader handles ALL content types in a single Astro collection.
-* Use `getEmDashCollection()` and `getEmDashEntry()` to query
-* specific content types.
-*
-* Database is configured in astro.config.mjs via the emdash() integration.
-*
-* @example
-* ```ts
-* // src/live.config.ts
-* import { defineLiveCollection } from "astro:content";
-* import { emdashLoader } from "emdash";
-*
-* export const collections = {
-*   emdash: defineLiveCollection({
-*     loader: emdashLoader(),
-*   }),
-* };
-* ```
-*/
-function emdashLoader() {
-	return {
-		name: "emdash",
-		async loadCollection({ filter }) {
-			try {
-				const db = await getDb();
-				const type = filter?.type;
-				if (!type) return { error: /* @__PURE__ */ new Error("type filter is required. Use getEmDashCollection() instead of getLiveCollection() directly.") };
-				const tableName = getTableName(type);
-				const status = filter?.status || "published";
-				const limit = filter?.limit;
-				const cursor = filter?.cursor;
-				const where = filter?.where;
-				const orderBy = filter?.orderBy;
-				const locale = filter?.locale;
-				const fetchLimit = limit ? limit + 1 : void 0;
-				const rawOffset = cursor ? void 0 : filter?.offset;
-				const offset = typeof rawOffset === "number" && Number.isInteger(rawOffset) && rawOffset > 0 ? rawOffset : void 0;
-				const cursorCondition = cursor ? buildCursorCondition(db, cursor, orderBy) : null;
-				let result;
-				const taxonomyFilters = [];
-				let bylineFilter = null;
-				const fieldFilters = {};
-				if (where && Object.keys(where).length > 0) {
-					const taxNames = await getTaxonomyNames(db, type);
-					for (const [key, value] of Object.entries(where)) {
-						if (value == null) continue;
-						if (key === "byline") {
-							if (isWhereRange(value)) {
-								console.warn(`[emdash] where filter: range operators are not supported on "byline", ignored`);
-								continue;
-							}
-							bylineFilter = { groups: Array.isArray(value) ? value : [value] };
-						} else if (taxNames.has(key)) {
-							if (isWhereRange(value)) {
-								console.warn(`[emdash] where filter: range operators are not supported on taxonomy "${key}", ignored`);
-								continue;
-							}
-							const slugs = Array.isArray(value) ? value : [value];
-							taxonomyFilters.push({
-								name: key,
-								slugs
-							});
-						} else fieldFilters[key] = value;
-					}
-				}
-				const storagelessKey = await findStoragelessQueryKey(type, [...Object.keys(fieldFilters), ...Object.keys(orderBy ?? {})]);
-				if (storagelessKey) {
-					const message = `Cannot filter or sort "${type}" by "${storagelessKey}": it is a reference field bound to a relation, and its links are not stored on the entry. Read them with getEmDashEntry(..., { references }) or getEmDashReferences().`;
-					console.warn(`[emdash] where filter: ${message}`);
-					return { error: new Error(message) };
-				}
-				if (bylineFilter && bylineFilter.groups.length === 0 || taxonomyFilters.some((f) => f.slugs.length === 0)) return {
-					entries: [],
-					cacheHint: { tags: [type] }
-				};
-				if (taxonomyFilters.length > 0 && Object.keys(fieldFilters).length === 0) {
-					const groupSets = [];
-					const probeCollection = !isPostgres(db) && taxonomyFilters.length === 1 && taxonomyFilters[0]?.slugs.length === 1 && fetchLimit != null && isIndexedPivotSort(orderBy) ? type : void 0;
-					let driveFromContent = false;
-					for (const taxFilter of taxonomyFilters) {
-						const { groups, large } = await resolveTermGroups(db, taxFilter.name, taxFilter.slugs, locale, probeCollection);
-						if (groups.length === 0) return {
-							entries: [],
-							cacheHint: { tags: [type] }
-						};
-						groupSets.push(groups);
-						driveFromContent = large && groups.length === 1;
-					}
-					result = await buildTaxonomyPivotQuery({
-						db,
-						collection: type,
-						tableName,
-						groupSets,
-						orderBy,
-						cursor,
-						locale,
-						status,
-						deletedIsNull: true,
-						bylineGroups: bylineFilter ? bylineFilter.groups : null,
-						fetchLimit,
-						offset,
-						driveFromContent
-					}).execute(db);
-				} else {
-					const orderByClause = buildOrderByClause(orderBy);
-					const statusCondition = buildStatusCondition(db, status);
-					const localeFilter = locale ? sql`AND locale = ${locale}` : sql``;
-					const cursorCond = cursorCondition ? sql`AND ${cursorCondition}` : sql``;
-					const fieldConds = buildFieldConditions(db, fieldFilters);
-					const fieldCondsSQL = fieldConds.length > 0 ? sql`${sql.join(fieldConds, sql` AND `)}` : null;
-					const taxonomyCond = taxonomyFilters.length > 0 ? sql`${sql.join(taxonomyFilters.map((f) => sql`AND EXISTS (
-							SELECT 1 FROM content_taxonomies ct
-							INNER JOIN taxonomies t ON t.translation_group = ct.taxonomy_id
-							WHERE ct.collection = ${type}
-								AND ct.entry_id = ${sql.ref(tableName)}.translation_group
-								AND t.name = ${f.name}
-								AND t.slug IN (${sql.join(f.slugs.map((s) => sql`${s}`))})
-							${locale ? sql`AND t.locale = ${locale}` : sql``}
-						)`), sql` `)}` : sql``;
-					const bylineCond = bylineFilter ? sql`AND EXISTS (
-							SELECT 1 FROM _emdash_content_bylines cb
-							WHERE cb.collection_slug = ${type}
-								AND cb.content_id = ${sql.ref(tableName)}.id
-								AND cb.byline_id IN (${sql.join(bylineFilter.groups.map((g) => sql`${g}`))})
-						)` : sql``;
-					const { terms: termsSelect, bylines: bylinesSelect, bylinesExist: bylinesExistSelect } = foldedHydrationSelects(db, type, tableName);
-					const booleanFieldsSelect = foldedBooleanFieldsSelect(db, type);
-					let limitOffsetClause = sql``;
-					if (fetchLimit != null && offset != null) limitOffsetClause = sql`LIMIT ${fetchLimit} OFFSET ${offset}`;
-					else if (fetchLimit != null) limitOffsetClause = sql`LIMIT ${fetchLimit}`;
-					else if (offset != null) limitOffsetClause = isPostgres(db) ? sql`OFFSET ${offset}` : sql`LIMIT -1 OFFSET ${offset}`;
-					result = await sql`
-						SELECT *, ${termsSelect}, ${bylinesSelect}, ${bylinesExistSelect}, ${booleanFieldsSelect} FROM ${sql.ref(tableName)}
-						WHERE deleted_at IS NULL
-						AND ${statusCondition}
-						${localeFilter}
-						${cursorCond}
-						${taxonomyCond}
-						${bylineCond}
-						${fieldCondsSQL ? sql`AND ${fieldCondsSQL}` : sql``}
-						${orderByClause}
-						${limitOffsetClause}
-					`.execute(db);
-				}
-				const hasMore = limit ? result.rows.length > limit : false;
-				const rows = hasMore ? result.rows.slice(0, limit) : result.rows;
-				const primary = getPrimarySort(orderBy);
-				const sortColumn = primary.field.includes(".") ? primary.field.split(".").pop() : primary.field;
-				const booleanFields = parseFoldedBooleanFields(rows[0]);
-				const drafts = await loadDraftRevisions(db, rows, filter?.draftRevisions);
-				const entries = rows.map((row) => {
-					const draft = drafts.get(rowStr(row, "id"));
-					if (draft) {
-						const revEntry = revisionEntry(row, draft, booleanFields, sortColumn);
-						stashFolded(revEntry.data, row);
-						return revEntry;
-					}
-					const id = entryIdForRow(row);
-					const data = mapRowToData(row, booleanFields, sortColumn);
-					stashFolded(data, row);
-					return {
-						id,
-						slug: rowStr(row, "slug"),
-						status: rowStr(row, "status", "draft"),
-						data,
-						cacheHint: {
-							tags: [rowStr(row, "id")],
-							lastModified: row.updated_at ? new Date(rowStr(row, "updated_at")) : void 0
-						}
-					};
-				});
-				let nextCursor;
-				if (hasMore && rows.length > 0) {
-					const lastRow = rows.at(-1);
-					nextCursor = encodeSortCursor(sortColumn, lastRow[sortColumn], String(lastRow.id));
-				}
-				let collectionLastModified;
-				for (const row of rows) if (row.updated_at) {
-					const d = new Date(rowStr(row, "updated_at"));
-					if (!collectionLastModified || d > collectionLastModified) collectionLastModified = d;
-				}
-				return {
-					entries,
-					nextCursor,
-					cacheHint: {
-						tags: [type],
-						lastModified: collectionLastModified
-					}
-				};
-			} catch (error) {
-				const message = error instanceof Error ? error.message : String(error);
-				if (isMissingTableError(error) || isMissingColumnError(error)) {
-					if (isMissingColumnError(error)) console.warn(`[emdash] where filter: ${message}`);
-					return { entries: [] };
-				}
-				return { error: /* @__PURE__ */ new Error(`Failed to load collection: ${message}`) };
-			}
-		},
-		async loadEntry({ filter }) {
-			try {
-				const db = await getDb();
-				const type = filter?.type;
-				const id = filter?.id;
-				if (!type || !id) return { error: /* @__PURE__ */ new Error("type and id filters are required. Use getEmDashEntry() instead of getLiveEntry() directly.") };
-				const tableName = getTableName(type);
-				const locale = filter?.locale;
-				const { terms: termsSelect, bylines: bylinesSelect, bylinesExist: bylinesExistSelect } = foldedHydrationSelects(db, type, "c");
-				const seoSelect = foldedSeoSelect(db, type, "c");
-				const booleanFieldsSelect = foldedBooleanFieldsSelect(db, type);
-				const metadataSelect = sql`(
-					SELECT ${isPostgres(db) ? sql`json_build_object` : sql`json_object`}(
-						'bylinesExist', _emdash_bylines_exist,
-						'booleanFields', _emdash_boolean_fields
-					)
-					FROM (SELECT ${bylinesExistSelect}, ${booleanFieldsSelect}) AS metadata
-				) AS _emdash_entry_metadata`;
-				const row = (locale ? await sql`
-							SELECT c.*, ${seoSelect}, ${termsSelect}, ${bylinesSelect}, ${metadataSelect}
-							FROM ${sql.ref(tableName)} AS c
-							WHERE c.deleted_at IS NULL
-							AND ((c.slug = ${id} AND c.locale = ${locale}) OR c.id = ${id})
-							LIMIT 1
-						`.execute(db) : await sql`
-							SELECT c.*, ${seoSelect}, ${termsSelect}, ${bylinesSelect}, ${metadataSelect}
-							FROM ${sql.ref(tableName)} AS c
-							WHERE c.deleted_at IS NULL
-							AND (c.slug = ${id} OR c.id = ${id})
-							LIMIT 1
-						`.execute(db)).rows[0];
-				if (!row) return;
-				const rawMetadata = row._emdash_entry_metadata;
-				const metadata = typeof rawMetadata === "string" ? JSON.parse(rawMetadata) : rawMetadata;
-				delete row._emdash_entry_metadata;
-				if (isPlainObject(metadata)) {
-					row._emdash_bylines_exist = metadata.bylinesExist;
-					row[BOOLEAN_FIELDS_FOLDED_COLUMN] = metadata.booleanFields;
-				}
-				expandFoldedSeo(row);
-				const entryId = entryIdForRow(row);
-				const revisionId = filter?.revisionId;
-				if (revisionId) {
-					const revData = (await sql`
-						SELECT data FROM revisions
-						WHERE id = ${revisionId}
-						LIMIT 1
-					`.execute(db)).rows[0];
-					if (revData) {
-						const revEntry = revisionEntry(row, JSON.parse(revData.data), parseFoldedBooleanFields(row));
-						const revSeo = extractSeo(row);
-						if (revSeo) {
-							revEntry.data.seo = revSeo;
-							primeSeoPanel(type, rowStr(row, "id"), revSeo);
-						}
-						stashFolded(revEntry.data, row);
-						return revEntry;
-					}
-				}
-				const entryData = mapRowToData(row, parseFoldedBooleanFields(row));
-				const entrySeo = extractSeo(row);
-				if (entrySeo) {
-					entryData.seo = entrySeo;
-					primeSeoPanel(type, rowStr(row, "id"), entrySeo);
-				}
-				stashFolded(entryData, row);
-				return {
-					id: entryId,
-					slug: rowStr(row, "slug"),
-					status: rowStr(row, "status", "draft"),
-					data: entryData,
-					cacheHint: {
-						tags: [rowStr(row, "id")],
-						lastModified: row.updated_at ? new Date(rowStr(row, "updated_at")) : void 0
-					}
-				};
-			} catch (error) {
-				if (isMissingTableError(error)) return;
-				const message = error instanceof Error ? error.message : String(error);
-				return { error: /* @__PURE__ */ new Error(`Failed to load entry: ${message}`) };
-			}
-		}
-	};
-}
-
-//#endregion
-export { creditsFromFoldedBylines as a, getDb as c, resetTaxonomyNamesCache as d, primeSeoPanel as f, selectTaxonomyDefs as g, saveTaxonomyStructure as h, FOLDED_TERMS as i, loadEntriesByGroups as l, parseTaxonomyCollections as m, FOLDED_BYLINES as n, emdashLoader as o, findTaxonomyStructure as p, FOLDED_BYLINES_EXIST as r, encodeSortCursor as s, CURSOR_RAW_VALUES as t, loader_exports as u };
-//# sourceMappingURL=loader-CswroUbe.mjs.map