emdash 0.36.0 → 0.38.0

package/src/api/errors.ts

@@ -16,6 +16,8 @@ export const ErrorCode = {
 	CONFLICT: "CONFLICT",
 	SLUG_CONFLICT: "SLUG_CONFLICT",
 	NOT_CONFIGURED: "NOT_CONFIGURED",
+	BINDING_NOT_FOUND: "BINDING_NOT_FOUND",
+	CONFIGURATION_ERROR: "CONFIGURATION_ERROR",
 	UNAUTHORIZED: "UNAUTHORIZED",
 	FORBIDDEN: "FORBIDDEN",
 	RATE_LIMITED: "RATE_LIMITED",
@@ -87,6 +89,8 @@ export const ErrorCode = {
 	MEDIA_GET_ERROR: "MEDIA_GET_ERROR",
 	MEDIA_CREATE_ERROR: "MEDIA_CREATE_ERROR",
 	MEDIA_UPDATE_ERROR: "MEDIA_UPDATE_ERROR",
+	MEDIA_REPLACE_ERROR: "MEDIA_REPLACE_ERROR",
+	MEDIA_REPLACE_METADATA_ERROR: "MEDIA_REPLACE_METADATA_ERROR",
 	MEDIA_DELETE_ERROR: "MEDIA_DELETE_ERROR",
 	MEDIA_FOLDER_LIST_ERROR: "MEDIA_FOLDER_LIST_ERROR",
 	MEDIA_FOLDER_GET_ERROR: "MEDIA_FOLDER_GET_ERROR",
@@ -109,6 +113,8 @@ export const ErrorCode = {
 	MEDIA_USAGE_ACTIVATION_ADVANCE_ERROR: "MEDIA_USAGE_ACTIVATION_ADVANCE_ERROR",
 	WORK_LEASE_ACTIVE: "WORK_LEASE_ACTIVE",
 	WORK_CHANGED: "WORK_CHANGED",
+	ENTRY_LOCKED: "ENTRY_LOCKED",
+	ENTRY_LOCK_ERROR: "ENTRY_LOCK_ERROR",
 	NO_STORAGE: "NO_STORAGE",
 	NO_FILE: "NO_FILE",
 	INVALID_TYPE: "INVALID_TYPE",
@@ -476,6 +482,7 @@ export function mapErrorStatus(code: string | undefined): number {
 		case ErrorCode.ENV_INCOMPATIBLE:
 		case ErrorCode.WORK_LEASE_ACTIVE:
 		case ErrorCode.WORK_CHANGED:
+		case ErrorCode.ENTRY_LOCKED:
 		case ErrorCode.MEDIA_USAGE_ACTIVATION_VERSION_MISMATCH:
 		case ErrorCode.MEDIA_USAGE_ACTIVATION_BUSY:
 		case ErrorCode.MEDIA_USAGE_ACTIVATION_CONFLICT:
@@ -499,6 +506,8 @@ export function mapErrorStatus(code: string | undefined): number {
 
 		// 500 Internal Server Error
 		case ErrorCode.NOT_CONFIGURED:
+		case ErrorCode.BINDING_NOT_FOUND:
+		case ErrorCode.CONFIGURATION_ERROR:
 		case ErrorCode.NO_STORAGE:
 		case ErrorCode.NO_DB:
 		case ErrorCode.STORAGE_NOT_CONFIGURED:

package/src/api/handlers/content.ts

@@ -10,7 +10,12 @@ import { isSqlite } from "../../database/dialect-helpers.js";
 import { BylineRepository } from "../../database/repositories/byline.js";
 import type { ContentBylineInput } from "../../database/repositories/byline.js";
 import { CommentRepository } from "../../database/repositories/comment.js";
-import { ContentRepository, isSystemOrderField } from "../../database/repositories/content.js";
+import {
+	ContentRepository,
+	isSystemOrderField,
+	type ContentRevisionPrecondition,
+} from "../../database/repositories/content.js";
+import { EntryLockRepository } from "../../database/repositories/entry-locks.js";
 import { RedirectRepository } from "../../database/repositories/redirect.js";
 import { RevisionRepository } from "../../database/repositories/revision.js";
 import { SeoRepository } from "../../database/repositories/seo.js";
@@ -39,7 +44,7 @@ import { invalidateRedirectCache } from "../../redirects/cache.js";
 import { FTSManager } from "../../search/fts-manager.js";
 import { invalidateTermCache } from "../../taxonomies/index.js";
 import { isMissingColumnError, isMissingTableError } from "../../utils/db-errors.js";
-import { encodeRev, validateRev } from "../rev.js";
+import { decodeRev, encodeRev, validateRev } from "../rev.js";
 import type { ApiResult, ContentListResponse, ContentResponse } from "../types.js";
 import { validateMediaFields } from "./validate-media-fields.js";
 
@@ -59,6 +64,15 @@ function hasApiError(error: unknown): error is Error & { apiError: { code: strin
 	);
 }
 
+function decodeRevisionPrecondition(
+	rev: string | undefined,
+): ContentRevisionPrecondition | undefined {
+	if (rev === undefined) return undefined;
+	const decoded = decodeRev(rev);
+	if (!decoded) throw new ContentMutationConflictError("Revision precondition did not match");
+	return decoded;
+}
+
 /**
  * Extract a slug source (title or name) from content data.
  * Returns null if no suitable string field is found.
@@ -329,6 +343,8 @@ export interface TrashedContentItem {
 	type: string;
 	slug: string | null;
 	status: string;
+	locale: string | null;
+	translationGroup: string | null;
 	data: Record<string, unknown>;
 	authorId: string | null;
 	createdAt: string;
@@ -410,6 +426,8 @@ async function createSlugChangeRedirect(
 	oldSlug: string,
 	newSlug: string,
 	contentId: string,
+	oldPublishedAt: string | null,
+	newPublishedAt: string | null,
 ): Promise<void> {
 	// A URL pattern has no locale token, so every locale variant of an entry
 	// generates the same URL, and slugs are unique per (slug, locale) — a
@@ -433,6 +451,8 @@ async function createSlugChangeRedirect(
 		newSlug,
 		contentId,
 		collectionRow?.url_pattern ?? null,
+		oldPublishedAt,
+		newPublishedAt,
 	);
 	invalidateRedirectCache();
 }
@@ -1080,17 +1100,27 @@ export async function handleContentUpdate(
 				updated.primaryBylineId = credits[0]?.byline.translationGroup ?? null;
 			}
 
-			// Create auto-redirect when slug changes
+			// Create auto-redirect when slug changes. Date tokens in the URL
+			// pattern resolve from the publish date, so the old URL uses the
+			// pre-update date (the URL that was actually live) and the new URL
+			// the post-update one.
 			if (oldSlug && body.slug) {
-				await createSlugChangeRedirect(trx, collection, oldSlug, body.slug, resolvedId);
+				await createSlugChangeRedirect(
+					trx,
+					collection,
+					oldSlug,
+					body.slug,
+					resolvedId,
+					existing?.publishedAt ?? null,
+					updated.publishedAt ?? null,
+				);
 			}
 
 			// Sync non-translatable fields to sibling locales in the same
 			// translation group. Only runs when i18n is enabled, data was updated,
 			// and the item belongs to a translation group with siblings.
 			if (isI18nEnabled() && body.data && updated.translationGroup) {
-				await syncNonTranslatableFields(
-					trx,
+				await trxRepo.syncNonTranslatableFields(
 					collection,
 					updated.id,
 					updated.translationGroup,
@@ -1268,10 +1298,11 @@ export async function handleContentDelete(
 		const result = await withTransaction(db, async (trx) => {
 			const repo = new ContentRepository(trx);
 			const resolvedId = (await resolveId(repo, collection, id)) ?? id;
-			return {
-				id: resolvedId,
-				deleted: await repo.delete(collection, resolvedId),
-			};
+			const deleted = await repo.delete(collection, resolvedId);
+			if (deleted) {
+				await new EntryLockRepository(trx).releaseEntry(collection, resolvedId);
+			}
+			return { id: resolvedId, deleted };
 		});
 
 		if (!result.deleted) {
@@ -1357,6 +1388,7 @@ export async function handleContentPermanentDelete(
 		// Wrap content delete + SEO/comment cleanup in a transaction
 		const deleted = await withTransaction(db, async (trx) => {
 			const trxRepo = new ContentRepository(trx);
+			const item = await trxRepo.findByIdIncludingTrashed(collection, resolvedId);
 			const wasDeleted = await trxRepo.permanentDelete(collection, resolvedId);
 
 			if (wasDeleted) {
@@ -1369,6 +1401,22 @@ export async function handleContentPermanentDelete(
 				// Clean up revisions for permanently deleted content
 				const revisionRepo = new RevisionRepository(trx);
 				await revisionRepo.deleteByEntry(collection, resolvedId);
+				await new EntryLockRepository(trx).releaseEntry(collection, resolvedId);
+				// Term assignments are keyed by translation_group, so they belong to the
+				// group rather than to this row. They go only once no row of the group is
+				// left, trashed ones included, since a trashed row can still be restored.
+				if (item?.translationGroup) {
+					const groupSurvives = await trxRepo.hasTranslationsIncludingTrashed(
+						collection,
+						item.translationGroup,
+					);
+					if (!groupSurvives) {
+						await new TaxonomyRepository(trx).clearEntryGroupTerms(
+							collection,
+							item.translationGroup,
+						);
+					}
+				}
 			}
 
 			return wasDeleted;
@@ -1406,13 +1454,14 @@ export async function handleContentPermanentDelete(
 export async function handleContentListTrashed(
 	db: Kysely<Database>,
 	collection: string,
-	options: { limit?: number; cursor?: string } = {},
+	options: { limit?: number; cursor?: string; locale?: string } = {},
 ): Promise<ApiResult<{ items: TrashedContentItem[]; nextCursor?: string }>> {
 	try {
 		const repo = new ContentRepository(db);
 		const result = await repo.findTrashed(collection, {
 			limit: options.limit,
 			cursor: options.cursor,
+			where: { locale: options.locale },
 		});
 
 		return {
@@ -1423,6 +1472,8 @@ export async function handleContentListTrashed(
 					type: item.type,
 					slug: item.slug,
 					status: item.status,
+					locale: item.locale,
+					translationGroup: item.translationGroup,
 					data: item.data,
 					authorId: item.authorId,
 					createdAt: item.createdAt,
@@ -1457,10 +1508,11 @@ export async function handleContentListTrashed(
 export async function handleContentCountTrashed(
 	db: Kysely<Database>,
 	collection: string,
+	options: { locale?: string } = {},
 ): Promise<ApiResult<{ count: number }>> {
 	try {
 		const repo = new ContentRepository(db);
-		const count = await repo.countTrashed(collection);
+		const count = await repo.countTrashed(collection, { locale: options.locale });
 
 		return {
 			success: true,
@@ -1504,7 +1556,7 @@ export async function handleContentSchedule(
 
 		return {
 			success: true,
-			data: { item },
+			data: { item, _rev: encodeRev(item) },
 		};
 	} catch (error) {
 		if (error instanceof EmDashValidationError) {
@@ -1547,7 +1599,7 @@ export async function handleContentUnschedule(
 
 		return {
 			success: true,
-			data: { item },
+			data: { item, _rev: encodeRev(item) },
 		};
 	} catch (error) {
 		if (error instanceof EmDashValidationError) {
@@ -1574,7 +1626,7 @@ export async function handleContentUnschedule(
  * Publish content immediately.
  *
  * Publication is one atomic content-row statement. On databases that support
- * transactions, the existing slug-redirect side write remains grouped with it.
+ * transactions, the slug redirect and the locale sync stay grouped with it.
  */
 export async function handleContentPublish(
 	db: Kysely<Database>,
@@ -1584,9 +1636,11 @@ export async function handleContentPublish(
 		publishedAt?: string;
 		requireScheduledDue?: boolean;
 		expectedScheduledAt?: string;
+		_rev?: string;
 	} = {},
 ): Promise<ApiResult<ContentResponse>> {
 	try {
+		const expectedRevision = decodeRevisionPrecondition(options._rev);
 		const item = await withTransaction(db, async (trx) => {
 			const repo = new ContentRepository(trx);
 			const resolvedId = (await resolveId(repo, collection, id)) ?? id;
@@ -1607,8 +1661,24 @@ export async function handleContentPublish(
 				options.expectedScheduledAt,
 				publishConfig.supportsRevisions,
 				publishConfig.routable,
+				expectedRevision,
 			);
 
+			if (
+				existing &&
+				isI18nEnabled() &&
+				publishConfig.supportsRevisions &&
+				published.translationGroup
+			) {
+				await repo.syncNonTranslatableFields(
+					collection,
+					published.id,
+					published.translationGroup,
+					published.data,
+					{ previous: existing.data },
+				);
+			}
+
 			// Leave a 301 behind when publishing changed the slug of an entry that
 			// was already published — its old URL was live and may be indexed or
 			// linked. A first publish is excluded: a draft's URL was never public.
@@ -1618,7 +1688,15 @@ export async function handleContentPublish(
 				published.slug &&
 				existing.slug !== published.slug
 			) {
-				await createSlugChangeRedirect(trx, collection, existing.slug, published.slug, resolvedId);
+				await createSlugChangeRedirect(
+					trx,
+					collection,
+					existing.slug,
+					published.slug,
+					resolvedId,
+					existing.publishedAt ?? null,
+					published.publishedAt ?? null,
+				);
 			}
 
 			return published;
@@ -1629,7 +1707,7 @@ export async function handleContentPublish(
 
 		return {
 			success: true,
-			data: { item },
+			data: { item, _rev: encodeRev(item) },
 		};
 	} catch (error) {
 		if (error instanceof ContentMutationConflictError) {
@@ -1707,12 +1785,14 @@ export async function handleContentUnpublish(
 	db: Kysely<Database>,
 	collection: string,
 	id: string,
+	options: { _rev?: string } = {},
 ): Promise<ApiResult<ContentResponse>> {
 	try {
+		const expectedRevision = decodeRevisionPrecondition(options._rev);
 		const item = await withTransaction(db, async (trx) => {
 			const repo = new ContentRepository(trx);
 			const resolvedId = (await resolveId(repo, collection, id)) ?? id;
-			return repo.unpublish(collection, resolvedId);
+			return repo.unpublish(collection, resolvedId, expectedRevision);
 		});
 
 		const hasSeo = await collectionHasSeo(db, collection);
@@ -1720,9 +1800,15 @@ export async function handleContentUnpublish(
 
 		return {
 			success: true,
-			data: { item },
+			data: { item, _rev: encodeRev(item) },
 		};
 	} catch (error) {
+		if (error instanceof ContentMutationConflictError) {
+			return {
+				success: false,
+				error: { code: "CONFLICT", message: error.message },
+			};
+		}
 		if (error instanceof EmDashValidationError) {
 			return {
 				success: false,
@@ -1777,12 +1863,14 @@ export async function handleContentDiscardDraft(
 	db: Kysely<Database>,
 	collection: string,
 	id: string,
+	options: { _rev?: string } = {},
 ): Promise<ApiResult<ContentResponse>> {
 	try {
+		const expectedRevision = decodeRevisionPrecondition(options._rev);
 		const item = await withTransaction(db, async (trx) => {
 			const repo = new ContentRepository(trx);
 			const resolvedId = (await resolveId(repo, collection, id)) ?? id;
-			return repo.discardDraft(collection, resolvedId);
+			return repo.discardDraft(collection, resolvedId, expectedRevision);
 		});
 
 		const hasSeo = await collectionHasSeo(db, collection);
@@ -1790,9 +1878,15 @@ export async function handleContentDiscardDraft(
 
 		return {
 			success: true,
-			data: { item },
+			data: { item, _rev: encodeRev(item) },
 		};
 	} catch (error) {
+		if (error instanceof ContentMutationConflictError) {
+			return {
+				success: false,
+				error: { code: "CONFLICT", message: error.message },
+			};
+		}
 		if (error instanceof EmDashValidationError) {
 			return {
 				success: false,
@@ -1948,75 +2042,6 @@ export async function handleContentTranslations(
 	}
 }
 
-// ---------------------------------------------------------------------------
-// Non-translatable field sync
-// ---------------------------------------------------------------------------
-
-/**
- * Sync non-translatable fields to sibling locales.
- *
- * When a content item is updated and it belongs to a translation group,
- * any non-translatable fields in the update data are written to all other
- * rows in the same translation group within the same transaction.
- *
- * Non-translatable fields are **copied, not linked** — each row owns its
- * own data. This keeps queries simple and avoids cross-row joins.
- */
-async function syncNonTranslatableFields(
-	trx: Kysely<Database>,
-	collectionSlug: string,
-	updatedItemId: string,
-	translationGroup: string,
-	data: Record<string, unknown>,
-): Promise<void> {
-	// Get the collection to find its fields
-	const collection = await trx
-		.selectFrom("_emdash_collections")
-		.select("id")
-		.where("slug", "=", collectionSlug)
-		.executeTakeFirst();
-
-	if (!collection) return;
-
-	// Find non-translatable fields that are present in the update data
-	const fields = await trx
-		.selectFrom("_emdash_fields")
-		.select("slug")
-		.where("collection_id", "=", collection.id)
-		.where("translatable", "=", 0)
-		.execute();
-
-	const nonTranslatableSlugs = fields.map((f) => f.slug);
-	if (nonTranslatableSlugs.length === 0) return;
-
-	// Filter to only the non-translatable fields present in this update
-	const syncData: Record<string, unknown> = {};
-	for (const slug of nonTranslatableSlugs) {
-		if (slug in data) {
-			syncData[slug] = data[slug];
-		}
-	}
-	if (Object.keys(syncData).length === 0) return;
-
-	// Build the SET clause for sibling rows
-	validateIdentifier(collectionSlug, "collection slug");
-	const tableName = `ec_${collectionSlug}`;
-
-	// Update all sibling rows (same translation_group, different id)
-	const setClauses = Object.entries(syncData).map(([key, value]) => {
-		validateIdentifier(key, "field slug");
-		const serialized = typeof value === "object" && value !== null ? JSON.stringify(value) : value;
-		return sql`${sql.ref(key)} = ${serialized}`;
-	});
-
-	await sql`
-		UPDATE ${sql.ref(tableName)}
-		SET ${sql.join(setClauses, sql`, `)}
-		WHERE translation_group = ${translationGroup}
-		AND id != ${updatedItemId}
-	`.execute(trx);
-}
-
 /**
  * Resolve a `{ taxonomyName: [slug, ...] }` map to term IDs and replace the
  * entry's assignments for each named taxonomy.

package/src/api/handlers/entry-lock.ts

@@ -0,0 +1,206 @@
+import type { Kysely } from "kysely";
+import { ulid } from "ulidx";
+
+import { EntryLockRepository, type EntryLock } from "../../database/repositories/entry-locks.js";
+import type { Database } from "../../database/types.js";
+import { ErrorCode } from "../errors.js";
+import type { ApiResult } from "../types.js";
+
+/**
+ * How long an entry stays locked without a heartbeat or save. Long enough to
+ * survive a pause in typing, short enough that a closed tab frees the entry
+ * within a coffee break.
+ */
+export const ENTRY_LOCK_LEASE_MS = 7 * 60 * 1000;
+
+const ENTRY_LOCK_LEASE_SECONDS = ENTRY_LOCK_LEASE_MS / 1000;
+
+export interface EntryLockHolder {
+	userId: string;
+	userName: string | null;
+	acquiredAt: string;
+	expiresAt: string;
+}
+
+export interface EntryLockStatus {
+	/** Whether the collection takes edit locks at all. */
+	enabled: boolean;
+	/** The live lease, whoever holds it. */
+	holder: EntryLockHolder | null;
+	/** Whether `holder` is the caller. */
+	heldByCaller: boolean;
+}
+
+export interface EntryLockRefusal {
+	code: typeof ErrorCode.ENTRY_LOCKED;
+	message: string;
+	details: EntryLockHolder;
+}
+
+function toHolder(lock: EntryLock): EntryLockHolder {
+	return {
+		userId: lock.userId,
+		userName: lock.userName,
+		acquiredAt: lock.acquiredAt,
+		expiresAt: lock.expiresAt,
+	};
+}
+
+function holderLabel(holder: EntryLockHolder): string {
+	return holder.userName?.trim() ? holder.userName : "Another editor";
+}
+
+async function isLockingEnabled(db: Kysely<Database>, collection: string): Promise<boolean | null> {
+	const row = await db
+		.selectFrom("_emdash_collections")
+		.select("edit_locking")
+		.where("slug", "=", collection)
+		.executeTakeFirst();
+	if (!row) return null;
+	return row.edit_locking !== 0;
+}
+
+function collectionNotFound(collection: string): ApiResult<never> {
+	return {
+		success: false,
+		error: {
+			code: ErrorCode.COLLECTION_NOT_FOUND,
+			message: `Collection '${collection}' not found`,
+		},
+	};
+}
+
+/**
+ * Takes the entry's lock for `userId`, or reports who is holding it. A
+ * take-over is only granted when the caller asks for one.
+ */
+export async function handleEntryLockAcquire(
+	db: Kysely<Database>,
+	collection: string,
+	entryId: string,
+	userId: string,
+	options: { takeover?: boolean; token?: string } = {},
+): Promise<ApiResult<EntryLockStatus>> {
+	try {
+		const enabled = await isLockingEnabled(db, collection);
+		if (enabled === null) return collectionNotFound(collection);
+		if (!enabled) {
+			return { success: true, data: { enabled: false, holder: null, heldByCaller: false } };
+		}
+
+		const claim = await new EntryLockRepository(db).acquire({
+			collection,
+			entryId,
+			userId,
+			token: options.token ?? ulid(),
+			leaseSeconds: ENTRY_LOCK_LEASE_SECONDS,
+			takeover: options.takeover,
+		});
+
+		return {
+			success: true,
+			data: {
+				enabled: true,
+				holder: toHolder(claim.lock),
+				heldByCaller: claim.outcome === "acquired",
+			},
+		};
+	} catch (error) {
+		console.error("[entry-lock] acquire failed:", error);
+		return {
+			success: false,
+			error: { code: ErrorCode.ENTRY_LOCK_ERROR, message: "Failed to acquire the entry lock" },
+		};
+	}
+}
+
+export async function handleEntryLockRead(
+	db: Kysely<Database>,
+	collection: string,
+	entryId: string,
+	userId: string,
+): Promise<ApiResult<EntryLockStatus>> {
+	try {
+		const enabled = await isLockingEnabled(db, collection);
+		if (enabled === null) return collectionNotFound(collection);
+		if (!enabled) {
+			return { success: true, data: { enabled: false, holder: null, heldByCaller: false } };
+		}
+
+		const lock = await new EntryLockRepository(db).findLive(collection, entryId);
+		return {
+			success: true,
+			data: {
+				enabled: true,
+				holder: lock ? toHolder(lock) : null,
+				heldByCaller: lock?.userId === userId,
+			},
+		};
+	} catch (error) {
+		console.error("[entry-lock] read failed:", error);
+		return {
+			success: false,
+			error: { code: ErrorCode.ENTRY_LOCK_ERROR, message: "Failed to read the entry lock" },
+		};
+	}
+}
+
+export async function handleEntryLockRelease(
+	db: Kysely<Database>,
+	collection: string,
+	entryId: string,
+	userId: string,
+	options: { token?: string } = {},
+): Promise<ApiResult<{ released: boolean }>> {
+	try {
+		const released = await new EntryLockRepository(db).release({
+			collection,
+			entryId,
+			userId,
+			token: options.token,
+		});
+		return { success: true, data: { released } };
+	} catch (error) {
+		console.error("[entry-lock] release failed:", error);
+		return {
+			success: false,
+			error: { code: ErrorCode.ENTRY_LOCK_ERROR, message: "Failed to release the entry lock" },
+		};
+	}
+}
+
+/**
+ * Decides whether a write may proceed, and keeps the caller's own lease alive
+ * while it does. Resolves to `null` when the write is allowed.
+ *
+ * A write never takes a lock it was not given, so a CLI or API caller writing
+ * an unlocked entry leaves it unlocked.
+ */
+export async function claimEntryLockForWrite(
+	db: Kysely<Database>,
+	collection: string,
+	entryId: string,
+	userId: string,
+	options: { override?: boolean } = {},
+): Promise<EntryLockRefusal | null> {
+	if (options.override === true) return null;
+
+	const repo = new EntryLockRepository(db);
+	const heldByCaller = await repo.refreshHeld({
+		collection,
+		entryId,
+		userId,
+		leaseSeconds: ENTRY_LOCK_LEASE_SECONDS,
+	});
+	if (heldByCaller) return null;
+
+	const holder = await repo.findEnforceable(collection, entryId);
+	if (!holder) return null;
+
+	const details = toHolder(holder);
+	return {
+		code: ErrorCode.ENTRY_LOCKED,
+		message: `${holderLabel(details)} is holding this entry`,
+		details,
+	};
+}

package/src/api/handlers/index.ts

@@ -56,6 +56,7 @@ export {
 	handleMediaGet,
 	handleMediaCreate,
 	handleMediaUpdate,
+	handleMediaReplaceMetadata,
 	handleMediaDelete,
 	type MediaListResponse,
 	type MediaResponse,