emdash 0.31.0 → 0.32.0

package/src/astro/routes/api/taxonomies/[name]/terms/index.ts

@@ -11,7 +11,7 @@ import { requirePerm } from "#api/authorize.js";
 import { apiError, handleError, requireDb, unwrapResult } from "#api/error.js";
 import { handleTermCreate, handleTermList } from "#api/handlers/taxonomies.js";
 import { isParseError, parseBody, parseQuery } from "#api/parse.js";
-import { createTermBody, localeFilterQuery } from "#api/schemas.js";
+import { createTermBody, termListQuery } from "#api/schemas.js";
 
 export const prerender = false;
 
@@ -29,11 +29,14 @@ export const GET: APIRoute = async ({ params, request, locals }) => {
 	const denied = requirePerm(user, "taxonomies:read");
 	if (denied) return denied;
 
-	const query = parseQuery(new URL(request.url), localeFilterQuery);
+	const query = parseQuery(new URL(request.url), termListQuery);
 	if (isParseError(query)) return query;
 
 	try {
-		const result = await handleTermList(emdash.db, name, { locale: query.locale });
+		const result = await handleTermList(emdash.db, name, {
+			locale: query.locale,
+			includeCounts: query.includeCounts,
+		});
 		return unwrapResult(result);
 	} catch (error) {
 		return handleError(error, "Failed to list terms", "TERM_LIST_ERROR");

package/src/astro/types.ts

@@ -210,6 +210,7 @@ export interface EmDashManifest {
 export interface HandlerResponse<T = unknown> {
 	success: boolean;
 	data?: T;
+	liveContentChanged?: boolean;
 	error?: {
 		code: string;
 		message: string;

package/src/cleanup.ts

@@ -16,6 +16,7 @@ import { cleanupExpiredChallenges } from "./auth/challenge-store.js";
 import { MediaRepository } from "./database/repositories/media.js";
 import { RevisionRepository } from "./database/repositories/revision.js";
 import type { Database } from "./database/types.js";
+import { removeUploadAttempt } from "./media/upload-attempts.js";
 import type { Storage } from "./storage/types.js";
 
 /**
@@ -27,6 +28,7 @@ export interface CleanupResult {
 	expiredTokens: number;
 	pendingUploads: number;
 	pendingUploadFiles: number;
+	uploadAttempts: number;
 	revisionsPruned: number;
 }
 
@@ -56,6 +58,7 @@ export async function runSystemCleanup(
 		expiredTokens: -1,
 		pendingUploads: -1,
 		pendingUploadFiles: -1,
+		uploadAttempts: -1,
 		revisionsPruned: -1,
 	};
 
@@ -106,7 +109,27 @@ export async function runSystemCleanup(
 		console.error("[cleanup] Failed to clean pending uploads:", error);
 	}
 
-	// 4. Revision pruning -- trim entries with excessive revision counts
+	// 4. Uploaded objects that lost publication races or outlived their media row
+	try {
+		const mediaRepo = new MediaRepository(db);
+		const completedAttemptsDeleted = await mediaRepo.deleteCompletedUploadAttempts();
+		if (!storage) {
+			result.uploadAttempts = completedAttemptsDeleted;
+		} else {
+			const storageKeys = await mediaRepo.findUploadAttemptsForCleanup();
+			let attemptsDeleted = completedAttemptsDeleted;
+			for (const storageKey of storageKeys) {
+				if (await removeUploadAttempt(storage, mediaRepo, storageKey)) {
+					attemptsDeleted++;
+				}
+			}
+			result.uploadAttempts = attemptsDeleted;
+		}
+	} catch (error) {
+		console.error("[cleanup] Failed to clean media upload attempts:", error);
+	}
+
+	// 5. Revision pruning -- trim entries with excessive revision counts
 	try {
 		result.revisionsPruned = await pruneExcessiveRevisions(db);
 	} catch (error) {

package/src/components/InlinePortableTextEditor.tsx

@@ -26,6 +26,7 @@ import * as React from "react";
 import { createPortal } from "react-dom";
 
 import { computeThumbnailSize } from "../media/thumbnail.js";
+import { CodeMarkExtension } from "./code-mark.js";
 import { InlineCodeBlockExtension } from "./inline-code-block.js";
 
 // ── Portable Text types ────────────────────────────────────────────
@@ -1942,7 +1943,10 @@ export function InlinePortableTextEditor({
 				dropcursor: { color: "#3b82f6", width: 2 },
 				// Replaced with InlineCodeBlockExtension below (adds language picker).
 				codeBlock: false,
+				// Replaced with CodeMarkExtension so inline code can combine with link/etc.
+				code: false,
 			}),
+			CodeMarkExtension,
 			InlineCodeBlockExtension,
 			Image.extend({
 				addAttributes() {

package/src/components/code-mark.ts

@@ -0,0 +1,11 @@
+/**
+ * TipTap's default Code mark sets `excludes: '_'`, which drops every other
+ * mark on the same span. Portable Text allows decorator + annotation stacks
+ * (e.g. linked inline code), so override only that field.
+ */
+
+import Code from "@tiptap/extension-code";
+
+export const CodeMarkExtension = Code.extend({
+	excludes: "",
+});

package/src/components/widgets/Categories.astro

@@ -12,7 +12,7 @@ interface Props {
 
 const { showCount = true, hierarchical = true } = Astro.props;
 
-const categories = await getTaxonomyTerms("category");
+const categories = await getTaxonomyTerms("category", { includeCounts: showCount });
 ---
 
 <ul class="widget-categories">

package/src/components/widgets/Tags.astro

@@ -12,7 +12,7 @@ interface Props {
 
 const { showCount = false, limit = 20 } = Astro.props;
 
-const allTags = await getTaxonomyTerms("tag");
+const allTags = await getTaxonomyTerms("tag", { includeCounts: showCount });
 const tags = allTags.slice(0, limit);
 ---
 

package/src/database/dialect-helpers.ts

@@ -37,6 +37,44 @@ export function isPostgres(db: Kysely<any>): boolean {
 	return detectDialect(db) === "postgres";
 }
 
+/**
+ * Declared by an adapter whose backend caps the number of terms in a compound
+ * SELECT (`UNION ALL`, `INTERSECT`, `EXCEPT`). SQLite's own
+ * SQLITE_LIMIT_COMPOUND_SELECT default is 500 — high enough that no query
+ * EmDash builds approaches it — but Cloudflare D1 sets it to 5 and rejects
+ * anything larger with "too many terms in compound SELECT".
+ */
+export interface CompoundSelectLimitedAdapter {
+	/** Maximum terms per compound SELECT. Must be a positive integer. */
+	readonly compoundSelectLimit: number;
+}
+
+/**
+ * The backend's compound-SELECT ceiling, or null when it has none worth
+ * splitting statements for. Only the adapter knows: the limit is a property of
+ * the SQLite build behind the dialect, not of the SQL flavour, so two "sqlite"
+ * dialects can answer differently.
+ *
+ * A declared ceiling must be a positive integer — callers batch by it, and
+ * every other value silently misbehaves rather than failing: 0 and negatives
+ * never advance the batch cursor, fractions overlap batches and double-count,
+ * NaN yields an empty batch. A malformed declaration throws here, where the
+ * message can name the adapter.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- accepts any Kysely instance
+export function compoundSelectLimit(db: Kysely<any>): number | null {
+	const adapter: object = db.getExecutor().adapter;
+	if (!("compoundSelectLimit" in adapter)) return null;
+
+	const limit: unknown = adapter.compoundSelectLimit;
+	if (typeof limit !== "number" || !Number.isInteger(limit) || limit < 1) {
+		throw new Error(
+			`${adapter.constructor.name} declares compoundSelectLimit ${String(limit)}; it must be a positive integer.`,
+		);
+	}
+	return limit;
+}
+
 /**
  * Default timestamp expression for column defaults.
  * Wrapped in parens for use in CREATE TABLE ... DEFAULT (...).

package/src/database/migrations/054_media_upload_attempts.ts

@@ -0,0 +1,41 @@
+import type { Kysely } from "kysely";
+
+import { currentTimestamp } from "../dialect-helpers.js";
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+	await db.schema
+		.createTable("_emdash_media_upload_attempts")
+		.ifNotExists()
+		.addColumn("storage_key", "text", (col) => col.primaryKey())
+		.addColumn("media_id", "text", (col) => col.notNull())
+		.addColumn("status", "text", (col) => col.notNull().defaultTo("active"))
+		.addColumn("created_at", "text", (col) => col.notNull().defaultTo(currentTimestamp(db)))
+		.addColumn("updated_at", "text", (col) => col.notNull().defaultTo(currentTimestamp(db)))
+		.execute();
+
+	await db.schema
+		.createIndex("idx_media_upload_attempts_media_id")
+		.ifNotExists()
+		.on("_emdash_media_upload_attempts")
+		.column("media_id")
+		.execute();
+
+	await db.schema
+		.createIndex("idx_media_upload_attempts_status_created_at")
+		.ifNotExists()
+		.on("_emdash_media_upload_attempts")
+		.columns(["status", "created_at"])
+		.execute();
+
+	await db.schema
+		.createIndex("idx_media_storage_key")
+		.ifNotExists()
+		.on("media")
+		.column("storage_key")
+		.execute();
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+	await db.schema.dropIndex("idx_media_storage_key").ifExists().execute();
+	await db.schema.dropTable("_emdash_media_upload_attempts").ifExists().execute();
+}

package/src/database/migrations/runner.ts

@@ -56,6 +56,7 @@ import * as m050 from "./050_media_usage_index_status.js";
 import * as m051 from "./051_content_taxonomies_denorm.js";
 import * as m052 from "./052_media_usage_read_index.js";
 import * as m053 from "./053_plugin_mcp_tools.js";
+import * as m054 from "./054_media_upload_attempts.js";
 
 const MIGRATIONS: Readonly<Record<string, Migration>> = Object.freeze({
 	"001_initial": m001,
@@ -110,6 +111,7 @@ const MIGRATIONS: Readonly<Record<string, Migration>> = Object.freeze({
 	"051_content_taxonomies_denorm": m051,
 	"052_media_usage_read_index": m052,
 	"053_plugin_mcp_tools": m053,
+	"054_media_upload_attempts": m054,
 });
 
 /** Total number of registered migrations. Exported for use in tests. */

package/src/database/repositories/content.ts

@@ -322,6 +322,7 @@ export class ContentRepository {
 			data: newData,
 			status: "draft",
 			authorId: authorId || original.authorId || undefined,
+			locale: original.locale ?? undefined,
 		});
 	}
 
@@ -660,7 +661,7 @@ export class ContentRepository {
 			await this.restampEntryPivot(type, id);
 		}
 
-		invalidateCollectionCache(type);
+		if (hasColumnWrites) invalidateCollectionCache(type);
 
 		const updated = await this.findById(type, id);
 		if (!updated) {
@@ -1555,8 +1556,6 @@ export class ContentRepository {
 			WHERE id = ${id}
 			AND deleted_at IS NULL
 		`.execute(this.db);
-
-		invalidateCollectionCache(type);
 	}
 
 	/**
@@ -1588,8 +1587,6 @@ export class ContentRepository {
 			AND deleted_at IS NULL
 		`.execute(this.db);
 
-		invalidateCollectionCache(type);
-
 		const updated = await this.findById(type, id);
 		if (!updated) {
 			throw new Error("Content not found");

package/src/database/repositories/media.ts

@@ -85,6 +85,9 @@ export interface FindManyMediaOptions {
 	q?: string;
 }
 
+const UPLOAD_ATTEMPT_CLEANUP_AGE_MS = 60 * 60 * 1000;
+const UPLOAD_ATTEMPT_CLEANUP_BATCH_SIZE = 100;
+
 /**
  * Media repository for database operations
  */
@@ -138,6 +141,129 @@ export class MediaRepository {
 		});
 	}
 
+	async createUploadAttempt(mediaId: string, storageKey: string): Promise<void> {
+		const now = new Date().toISOString();
+		await this.db
+			.insertInto("_emdash_media_upload_attempts")
+			.values({
+				media_id: mediaId,
+				storage_key: storageKey,
+				status: "active",
+				created_at: now,
+				updated_at: now,
+			})
+			.execute();
+	}
+
+	async hasUploadAttempt(storageKey: string): Promise<boolean> {
+		const row = await this.db
+			.selectFrom("_emdash_media_upload_attempts")
+			.select("storage_key")
+			.where("storage_key", "=", storageKey)
+			.executeTakeFirst();
+		return row !== undefined;
+	}
+
+	async claimUploadAttemptForCleanup(storageKey: string): Promise<boolean> {
+		const result = await this.db
+			.updateTable("_emdash_media_upload_attempts")
+			.set({ status: "cleanup", updated_at: new Date().toISOString() })
+			.where("storage_key", "=", storageKey)
+			.where((eb) =>
+				eb.not(
+					eb.exists(
+						eb
+							.selectFrom("media")
+							.select("media.id")
+							.whereRef("media.storage_key", "=", "_emdash_media_upload_attempts.storage_key"),
+					),
+				),
+			)
+			.executeTakeFirst();
+
+		return Number(result.numUpdatedRows ?? 0) > 0;
+	}
+
+	async deleteUploadAttempt(storageKey: string): Promise<void> {
+		await this.db
+			.deleteFrom("_emdash_media_upload_attempts")
+			.where("storage_key", "=", storageKey)
+			.execute();
+	}
+
+	async deleteCompletedUploadAttempts(): Promise<number> {
+		const result = await this.db
+			.deleteFrom("_emdash_media_upload_attempts")
+			.where((eb) =>
+				eb.exists(
+					eb
+						.selectFrom("media")
+						.select("media.id")
+						.whereRef("media.id", "=", "_emdash_media_upload_attempts.media_id")
+						.whereRef("media.storage_key", "=", "_emdash_media_upload_attempts.storage_key")
+						.where("media.status", "=", "ready"),
+				),
+			)
+			.executeTakeFirst();
+		return Number(result.numDeletedRows ?? 0);
+	}
+
+	async findUploadAttemptsForCleanup(
+		maxAgeMs: number = UPLOAD_ATTEMPT_CLEANUP_AGE_MS,
+		limit: number = UPLOAD_ATTEMPT_CLEANUP_BATCH_SIZE,
+	): Promise<string[]> {
+		const cutoff = new Date(Date.now() - maxAgeMs).toISOString();
+		const rows = await this.db
+			.selectFrom("_emdash_media_upload_attempts")
+			.select("storage_key")
+			.where((eb) => eb.or([eb("status", "=", "cleanup"), eb("created_at", "<", cutoff)]))
+			.where((eb) =>
+				eb.not(
+					eb.exists(
+						eb
+							.selectFrom("media")
+							.select("media.id")
+							.whereRef("media.storage_key", "=", "_emdash_media_upload_attempts.storage_key"),
+					),
+				),
+			)
+			.orderBy("created_at", "asc")
+			.limit(limit)
+			.execute();
+
+		return rows.map((row) => row.storage_key);
+	}
+
+	async publishPendingStorageKey(
+		id: string,
+		expectedStorageKey: string,
+		storageKey: string,
+		contentHash?: string,
+	): Promise<boolean> {
+		const result = await this.db
+			.updateTable("media")
+			.set({
+				storage_key: storageKey,
+				...(contentHash !== undefined ? { content_hash: contentHash } : {}),
+			})
+			.where("id", "=", id)
+			.where("status", "=", "pending")
+			.where("storage_key", "=", expectedStorageKey)
+			.where((eb) =>
+				eb.exists(
+					eb
+						.selectFrom("_emdash_media_upload_attempts")
+						.select("storage_key")
+						.where("media_id", "=", id)
+						.where("storage_key", "=", storageKey)
+						.where("status", "=", "active"),
+				),
+			)
+			.executeTakeFirst();
+
+		return Number(result.numUpdatedRows ?? 0) > 0;
+	}
+
 	/**
 	 * Confirm upload (mark as ready)
 	 */
@@ -149,13 +275,10 @@ export class MediaRepository {
 			size?: number;
 			blurhash?: string;
 			dominantColor?: string;
+			contentHash?: string | null;
 		},
+		expectedStorageKey?: string,
 	): Promise<MediaItem | null> {
-		const existing = await this.findById(id);
-		if (!existing) {
-			return null;
-		}
-
 		const updates: Partial<MediaRow> = {
 			status: "ready",
 		};
@@ -164,24 +287,33 @@ export class MediaRepository {
 		if (metadata?.size !== undefined) updates.size = metadata.size;
 		if (metadata?.blurhash !== undefined) updates.blurhash = metadata.blurhash;
 		if (metadata?.dominantColor !== undefined) updates.dominant_color = metadata.dominantColor;
+		if (metadata?.contentHash !== undefined) updates.content_hash = metadata.contentHash;
 
-		await this.db.updateTable("media").set(updates).where("id", "=", id).execute();
+		let query = this.db
+			.updateTable("media")
+			.set(updates)
+			.where("id", "=", id)
+			.where("status", "=", "pending");
+		if (expectedStorageKey !== undefined) {
+			query = query.where("storage_key", "=", expectedStorageKey);
+		}
 
-		return this.findById(id);
+		const row = await query.returningAll().executeTakeFirst();
+
+		return row ? this.rowToItem(row) : null;
 	}
 
 	/**
 	 * Mark upload as failed
 	 */
-	async markFailed(id: string): Promise<MediaItem | null> {
-		const existing = await this.findById(id);
-		if (!existing) {
-			return null;
+	async markFailed(id: string, expectedStorageKey?: string): Promise<MediaItem | null> {
+		let query = this.db.updateTable("media").set({ status: "failed" }).where("id", "=", id);
+		if (expectedStorageKey !== undefined) {
+			query = query.where("status", "=", "pending").where("storage_key", "=", expectedStorageKey);
 		}
 
-		await this.db.updateTable("media").set({ status: "failed" }).where("id", "=", id).execute();
-
-		return this.findById(id);
+		const row = await query.returningAll().executeTakeFirst();
+		return row ? this.rowToItem(row) : null;
 	}
 
 	/**
@@ -319,10 +451,18 @@ export class MediaRepository {
 	/**
 	 * Delete media item
 	 */
-	async delete(id: string): Promise<boolean> {
-		const result = await this.db.deleteFrom("media").where("id", "=", id).executeTakeFirst();
+	async deleteWithStorageKey(id: string): Promise<string | null> {
+		const deleted = await this.db
+			.deleteFrom("media")
+			.where("id", "=", id)
+			.returning("storage_key")
+			.executeTakeFirst();
+		if (deleted) return deleted.storage_key;
+		return null;
+	}
 
-		return (result.numDeletedRows ?? 0) > 0;
+	async delete(id: string): Promise<boolean> {
+		return (await this.deleteWithStorageKey(id)) !== null;
 	}
 
 	/**
@@ -350,21 +490,11 @@ export class MediaRepository {
 	async cleanupPendingUploads(maxAgeMs: number = 60 * 60 * 1000): Promise<string[]> {
 		const cutoff = new Date(Date.now() - maxAgeMs).toISOString();
 
-		// Select the storage keys first -- SQLite doesn't support RETURNING
-		// on DELETE in all drivers, and Kysely's RETURNING isn't universal.
 		const rows = await this.db
-			.selectFrom("media")
-			.select("storage_key")
-			.where("status", "=", "pending")
-			.where("created_at", "<", cutoff)
-			.execute();
-
-		if (rows.length === 0) return [];
-
-		await this.db
 			.deleteFrom("media")
 			.where("status", "=", "pending")
 			.where("created_at", "<", cutoff)
+			.returning("storage_key")
 			.execute();
 
 		return rows.map((r) => r.storage_key);

package/src/database/types.ts

@@ -81,6 +81,15 @@ export interface MediaTable {
 	author_id: string | null;
 }
 
+export interface MediaUploadAttemptTable {
+	storage_key: string;
+	// No foreign key: this row must survive media deletion until storage cleanup succeeds.
+	media_id: string;
+	status: string; // 'active' | 'cleanup'
+	created_at: Generated<string>;
+	updated_at: Generated<string>;
+}
+
 export interface MediaUsageSourceTable {
 	source_key: string;
 	source_type: string;
@@ -495,6 +504,7 @@ export interface Database {
 	content_taxonomies: ContentTaxonomyTable;
 	_emdash_taxonomy_defs: TaxonomyDefTable;
 	media: MediaTable;
+	_emdash_media_upload_attempts: MediaUploadAttemptTable;
 	_emdash_media_usage_sources: MediaUsageSourceTable;
 	_emdash_media_usage: MediaUsageTable;
 	_emdash_media_usage_index_status: MediaUsageIndexStatusTable;

package/src/emdash-runtime.ts

@@ -225,6 +225,8 @@ const FIELD_TYPE_TO_KIND: Record<FieldType, string> = {
 	repeater: "repeater",
 };
 
+const DRAFT_ONLY_UPDATE_KEYS = new Set(["data", "slug", "locale", "skipRevision"]);
+
 /**
  * Sandboxed plugin entry from virtual module
  */
@@ -2909,6 +2911,14 @@ export class EmDashRuntime {
 			bylines: bodyWithoutRev.bylines,
 		});
 
+		// Public HTML comes from live columns / SEO / taxonomies, not draft revisions.
+		const liveMetaTouched = Object.entries(bodyWithoutRev).some(
+			([key, value]) => value !== undefined && !DRAFT_ONLY_UPDATE_KEYS.has(key),
+		);
+		const liveContentChanged = usesDraftRevisions
+			? liveMetaTouched
+			: Boolean(processedData || bodyWithoutRev.slug !== undefined || liveMetaTouched);
+
 		// Hydrate draft data BEFORE firing afterSave hooks so the hook sees
 		// the same effective data the response surfaces — for revision-
 		// supporting collections, that's the just-saved draft, not the live
@@ -2957,6 +2967,9 @@ export class EmDashRuntime {
 			this.runAfterSaveHooks(contentItemToRecord(hydrated.data.item), collection, false);
 		}
 
+		if (hydrated.success) {
+			return { ...hydrated, liveContentChanged };
+		}
 		return hydrated;
 	}
 

package/src/i18n/config.ts

@@ -12,14 +12,18 @@ export interface I18nConfig {
 	prefixDefaultLocale?: boolean;
 }
 
-let _config: I18nConfig | null | undefined;
+const I18N_CONFIG_KEY = Symbol.for("emdash:i18n-config");
+
+function configStore(): Record<symbol, I18nConfig | null | undefined> {
+	return globalThis;
+}
 
 /**
  * Initialize i18n config from virtual module data.
  * Called during runtime initialization.
  */
 export function setI18nConfig(config: I18nConfig | null): void {
-	_config = config;
+	configStore()[I18N_CONFIG_KEY] = config;
 }
 
 /**
@@ -27,13 +31,14 @@ export function setI18nConfig(config: I18nConfig | null): void {
  * Returns null if i18n is not configured.
  */
 export function getI18nConfig(): I18nConfig | null {
-	return _config ?? null;
+	return configStore()[I18N_CONFIG_KEY] ?? null;
 }
 
 /** Match a locale to the exact casing used by the site configuration. */
 export function resolveConfiguredLocale(locale: string): string {
+	const config = getI18nConfig();
 	return (
-		_config?.locales.find((configured) => configured.toLowerCase() === locale.toLowerCase()) ??
+		config?.locales.find((configured) => configured.toLowerCase() === locale.toLowerCase()) ??
 		locale
 	);
 }
@@ -43,7 +48,8 @@ export function resolveConfiguredLocale(locale: string): string {
  * Returns true when multiple locales are configured.
  */
 export function isI18nEnabled(): boolean {
-	return _config != null && _config.locales.length > 1;
+	const config = getI18nConfig();
+	return config != null && config.locales.length > 1;
 }
 
 /**
@@ -52,15 +58,16 @@ export function isI18nEnabled(): boolean {
  * Always ends with defaultLocale.
  */
 export function getFallbackChain(locale: string): string[] {
-	if (!_config) return [locale];
+	const config = getI18nConfig();
+	if (!config) return [locale];
 
 	const chain: string[] = [locale];
 	let current = locale;
 	const visited = new Set<string>([locale]);
 
-	while (_config.fallback?.[current]) {
+	while (config.fallback?.[current]) {
 		// eslint-disable-next-line typescript/no-unnecessary-type-assertion -- noUncheckedIndexedAccess
-		const next = _config.fallback[current]!;
+		const next = config.fallback[current]!;
 		if (visited.has(next)) break; // prevent cycles
 		chain.push(next);
 		visited.add(next);
@@ -68,8 +75,8 @@ export function getFallbackChain(locale: string): string[] {
 	}
 
 	// Always end with defaultLocale if not already in chain
-	if (!visited.has(_config.defaultLocale)) {
-		chain.push(_config.defaultLocale);
+	if (!visited.has(config.defaultLocale)) {
+		chain.push(config.defaultLocale);
 	}
 
 	return chain;

package/src/index.ts

@@ -28,6 +28,7 @@ export type {
 	FindManyResult,
 } from "./database/repositories/index.js";
 export type { MediaItem, CreateMediaInput } from "./database/repositories/media.js";
+export type { CompoundSelectLimitedAdapter } from "./database/dialect-helpers.js";
 
 // Fields
 export { portableText, image, file, reference } from "./fields/index.js";