emdash 0.40.1 → 0.42.0

package/dist/loader-BzqeR1ZN.mjs

@@ -1,1086 +0,0 @@
-import { u as __exportAll } from "./runner-1y4J9fJB.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 { o as decodeCursor, s as encodeCursor } from "./types-BkUg2yHx.mjs";
-import { i as setRequestCacheEntry } from "./request-cache-DzLYKm_x.mjs";
-import { kyselyLogOption } from "./database/instrumentation.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,
-	buildTaxonomyPivotQuery: () => buildTaxonomyPivotQuery,
-	creditsFromFoldedBylines: () => creditsFromFoldedBylines,
-	emdashLoader: () => emdashLoader,
-	getDb: () => getDb,
-	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";
-/**
-* 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
-]);
-/** 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 the raw
-* DB string for every date column. Lets cursor encoders downstream reproduce
-* the loader's exact `nextCursor` format without round-tripping through
-* `new Date()`, which loses 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) {
-	const data = {};
-	const rawDateValues = {};
-	for (const [key, value] of Object.entries(row)) {
-		if (key in INCLUDE_IN_DATA) {
-			if (DATE_COLUMNS.has(key)) if (typeof value === "string") {
-				rawDateValues[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;
-	}
-	Object.defineProperty(data, CURSOR_RAW_VALUES, {
-		value: rawDateValues,
-		enumerable: false,
-		configurable: false,
-		writable: false
-	});
-	return data;
-}
-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 loadVirtualModules() {
-	if (virtualConfig === void 0) virtualConfig = (await import("virtual:emdash/config")).default;
-	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`, `)}`;
-}
-/**
-* Build a cursor WHERE condition for keyset pagination.
-* Uses the primary sort field + id as tiebreaker for stable ordering.
-*
-* 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 buildCursorCondition(cursor, orderBy, tablePrefix) {
-	const { orderValue, id: cursorId } = decodeCursor(cursor);
-	const primary = getPrimarySort(orderBy, tablePrefix);
-	const idField = tablePrefix ? `${tablePrefix}.id` : "id";
-	if (primary.direction === "desc") return sql`(${sql.ref(primary.field)} < ${orderValue} OR (${sql.ref(primary.field)} = ${orderValue} AND ${sql.ref(idField)} < ${cursorId}))`;
-	return sql`(${sql.ref(primary.field)} > ${orderValue} OR (${sql.ref(primary.field)} = ${orderValue} AND ${sql.ref(idField)} > ${cursorId}))`;
-}
-/** 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);
-}
-/**
-* 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.
-*/
-function buildFieldConditions(fields, tablePrefix) {
-	const conditions = [];
-	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)) {
-			if (value.gt !== void 0) conditions.push(sql`${ref} > ${value.gt}`);
-			if (value.gte !== void 0) conditions.push(sql`${ref} >= ${value.gte}`);
-			if (value.lt !== void 0) conditions.push(sql`${ref} < ${value.lt}`);
-			if (value.lte !== void 0) conditions.push(sql`${ref} <= ${value.lte}`);
-		} else if (Array.isArray(value)) {
-			if (value.length > 0) conditions.push(sql`${ref} IN (${sql.join(value.map((v) => sql`${v}`))})`);
-		} else conditions.push(sql`${ref} = ${value}`);
-	}
-	return conditions;
-}
-/**
-* 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.
-*/
-async function resolveTermGroups(db, name, slugs, locale) {
-	let query = db.selectFrom("taxonomies").select("translation_group").distinct().where("name", "=", name).where("slug", "in", slugs);
-	if (locale) query = query.where("locale", "=", locale);
-	const rows = await query.execute();
-	const groups = /* @__PURE__ */ new Set();
-	for (const row of rows) if (row.translation_group) groups.add(row.translation_group);
-	return [...groups];
-}
-/** 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).
-*
-* Drives from the term pivot and joins 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`.
-* - **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 } = opts;
-	const primary = getPrimarySort(orderBy);
-	const isIndexedSort = (orderBy ? Object.keys(orderBy).filter((k) => FIELD_NAME_PATTERN.test(k)) : []).length <= 1 && (primary.field === "published_at" || primary.field === "created_at");
-	const dir = primary.direction === "asc" ? sql`ASC` : sql`DESC`;
-	const cmp = primary.direction === "asc" ? sql.raw(">") : sql.raw("<");
-	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 = sql`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 { orderValue, id } = decodeCursor(cursor);
-			const cond = sql`(${sortval} ${cmp} ${orderValue} OR (${sortval} = ${orderValue} AND r.id ${cmp} ${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(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() {
-	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(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;
-					}
-				}
-				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 = [];
-					for (const taxFilter of taxonomyFilters) {
-						const groups = await resolveTermGroups(db, taxFilter.name, taxFilter.slugs, locale);
-						if (groups.length === 0) return {
-							entries: [],
-							cacheHint: { tags: [type] }
-						};
-						groupSets.push(groups);
-					}
-					result = await buildTaxonomyPivotQuery({
-						db,
-						collection: type,
-						tableName,
-						groupSets,
-						orderBy,
-						cursor,
-						locale,
-						status,
-						deletedIsNull: true,
-						bylineGroups: bylineFilter ? bylineFilter.groups : null,
-						fetchLimit,
-						offset
-					}).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(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 i18nConfig = virtualConfig?.i18n;
-				const i18nEnabled = i18nConfig && i18nConfig.locales.length > 1;
-				const booleanFields = parseFoldedBooleanFields(rows[0]);
-				const entries = rows.map((row) => {
-					const slug = rowStr(row, "slug") || rowStr(row, "id");
-					const rowLocale = rowStr(row, "locale");
-					const id = i18nEnabled && rowLocale !== "" && (rowLocale !== i18nConfig.defaultLocale || i18nConfig.prefixDefaultLocale) ? `${rowLocale}/${slug}` : slug;
-					const data = mapRowToData(row, booleanFields);
-					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);
-					const primary = getPrimarySort(orderBy);
-					const lastOrderValue = lastRow[primary.field.includes(".") ? primary.field.split(".").pop() : primary.field];
-					nextCursor = encodeCursor(typeof lastOrderValue === "string" || typeof lastOrderValue === "number" ? String(lastOrderValue) : "", 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 i18nConfig = virtualConfig?.i18n;
-				const i18nEnabled = i18nConfig && i18nConfig.locales.length > 1;
-				const entrySlug = rowStr(row, "slug") || rowStr(row, "id");
-				const entryLocale = rowStr(row, "locale");
-				const entryId = i18nEnabled && entryLocale !== "" && (entryLocale !== i18nConfig.defaultLocale || i18nConfig.prefixDefaultLocale) ? `${entryLocale}/${entrySlug}` : entrySlug;
-				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 parsed = JSON.parse(revData.data);
-						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 revLocale = rowStr(row, "locale");
-						const revId = i18nEnabled && revLocale !== "" && (revLocale !== i18nConfig.defaultLocale || i18nConfig.prefixDefaultLocale) ? `${revLocale}/${revSlug}` : revSlug;
-						const revEntryData = {
-							...systemData,
-							slug,
-							...mapRevisionData(parsed, parseFoldedBooleanFields(row))
-						};
-						const revSeo = extractSeo(row);
-						if (revSeo) {
-							revEntryData.seo = revSeo;
-							primeSeoPanel(type, rowStr(row, "id"), revSeo);
-						}
-						stashFolded(revEntryData, row);
-						return {
-							id: revId,
-							slug,
-							status: rowStr(row, "status", "draft"),
-							data: revEntryData,
-							cacheHint: {
-								tags: [rowStr(row, "id")],
-								lastModified: row.updated_at ? new Date(rowStr(row, "updated_at")) : void 0
-							}
-						};
-					}
-				}
-				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, loader_exports as c, findTaxonomyStructure as d, parseTaxonomyCollections as f, FOLDED_TERMS as i, resetTaxonomyNamesCache as l, selectTaxonomyDefs as m, FOLDED_BYLINES as n, emdashLoader as o, saveTaxonomyStructure as p, FOLDED_BYLINES_EXIST as r, getDb as s, CURSOR_RAW_VALUES as t, primeSeoPanel as u };
-//# sourceMappingURL=loader-BzqeR1ZN.mjs.map