emdash 0.33.0 → 0.35.0

package/src/client/index.ts

@@ -19,6 +19,7 @@
 
 import mime from "mime/lite";
 
+import type { ContentFieldFilters } from "../content-list-query.js";
 import type { FieldSchema } from "./portable-text.js";
 import { convertDataForRead, convertDataForWrite } from "./portable-text.js";
 import type { Interceptor } from "./transport.js";
@@ -228,6 +229,74 @@ export interface MediaUsageRepairResponse {
 	collections: MediaUsageRepairCollectionSummary[];
 }
 
+/** Durable media usage entry-work state */
+export type MediaUsageWorkState = "pending" | "retry" | "leased" | "failed";
+
+/** Redacted operator view of one durable media usage job */
+export interface MediaUsageWorkItem {
+	collectionId: string;
+	collectionSlug: string;
+	contentId: string;
+	state: MediaUsageWorkState;
+	attemptCount: number;
+	nextAttemptAt: string;
+	leaseExpiresAt: string | null;
+	lastAttemptedAt: string | null;
+	lastErrorCode: string | null;
+	updatedAt: string;
+}
+
+/** Filters and pagination for durable media usage work */
+export interface MediaUsageWorkListOptions {
+	collection: string;
+	state?: MediaUsageWorkState;
+	limit?: number;
+	cursor?: string;
+}
+
+/** One bounded page of durable media usage work */
+export interface MediaUsageWorkListResponse {
+	items: MediaUsageWorkItem[];
+	nextCursor?: string;
+}
+
+/** Identity for explicitly retrying one durable media usage job */
+export interface MediaUsageWorkRetryInput {
+	collectionId: string;
+	contentId: string;
+}
+
+/** Result of explicitly retrying one durable media usage job */
+export interface MediaUsageWorkRetryResponse {
+	changed: boolean;
+	item: MediaUsageWorkItem;
+}
+
+export type MediaUsageCollectionDeletionState = "pending" | "retry" | "leased" | "failed";
+export type MediaUsageCollectionDeletionPhase =
+	| "fence"
+	| "registry"
+	| "table"
+	| "work"
+	| "sources"
+	| "status"
+	| "finalize";
+export interface MediaUsageCollectionDeletionItem {
+	collectionId: string;
+	collectionSlug: string;
+	state: MediaUsageCollectionDeletionState;
+	phase: MediaUsageCollectionDeletionPhase;
+	attemptCount: number;
+	nextAttemptAt: string;
+	leaseExpiresAt: string | null;
+	lastErrorCode: string | null;
+	updatedAt: string;
+}
+export interface MediaUsageCollectionDeletionListResponse {
+	items: MediaUsageCollectionDeletionItem[];
+	nextCursor?: string;
+}
+
 /** Search result */
 export interface SearchResult {
 	id: string;
@@ -497,6 +566,8 @@ export class EmDashClient {
 			orderBy?: string;
 			order?: "asc" | "desc";
 			locale?: string;
+			/** AND-combined filters over custom fields explicitly marked as indexed. */
+			fieldFilters?: ContentFieldFilters;
 		},
 	): Promise<ListResult<ContentItem>> {
 		const params = new URLSearchParams();
@@ -506,6 +577,9 @@ export class EmDashClient {
 		if (options?.orderBy) params.set("orderBy", options.orderBy);
 		if (options?.order) params.set("order", options.order);
 		if (options?.locale) params.set("locale", options.locale);
+		if (options?.fieldFilters && Object.keys(options.fieldFilters).length > 0) {
+			params.set("fieldFilters", JSON.stringify(options.fieldFilters));
+		}
 
 		const qs = params.toString();
 		const path = `/content/${encodeURIComponent(collection)}${qs ? `?${qs}` : ""}`;
@@ -521,6 +595,8 @@ export class EmDashClient {
 			orderBy?: string;
 			order?: "asc" | "desc";
 			locale?: string;
+			/** AND-combined filters over custom fields explicitly marked as indexed. */
+			fieldFilters?: ContentFieldFilters;
 		},
 	): AsyncGenerator<ContentItem> {
 		let cursor: string | undefined;
@@ -818,6 +894,49 @@ export class EmDashClient {
 		return this.request<MediaUsageRepairResponse>("POST", "/admin/media-usage/repair", input);
 	}
 
+	/** List a bounded page of durable media usage entry work */
+	async mediaListUsageWork(
+		options: MediaUsageWorkListOptions,
+	): Promise<MediaUsageWorkListResponse> {
+		const params = new URLSearchParams({ collection: options.collection });
+		if (options.state) params.set("state", options.state);
+		if (options.limit !== undefined) params.set("limit", String(options.limit));
+		if (options.cursor) params.set("cursor", options.cursor);
+		return this.request<MediaUsageWorkListResponse>("GET", `/admin/media-usage/work?${params}`);
+	}
+
+	/** Explicitly retry one durable media usage entry job */
+	async mediaRetryUsageWork(input: MediaUsageWorkRetryInput): Promise<MediaUsageWorkRetryResponse> {
+		return this.request<MediaUsageWorkRetryResponse>(
+			"POST",
+			"/admin/media-usage/work/retry",
+			input,
+		);
+	}
+
+	async mediaListCollectionDeletions(
+		options: {
+			state?: MediaUsageCollectionDeletionState;
+			limit?: number;
+			cursor?: string;
+		} = {},
+	): Promise<MediaUsageCollectionDeletionListResponse> {
+		const params = new URLSearchParams();
+		if (options.state) params.set("state", options.state);
+		if (options.limit !== undefined) params.set("limit", String(options.limit));
+		if (options.cursor) params.set("cursor", options.cursor);
+		return this.request("GET", `/admin/media-usage/collection-deletions?${params}`);
+	}
+
+	async mediaRetryCollectionDeletion(collectionId: string): Promise<{
+		changed: boolean;
+		item: MediaUsageCollectionDeletionItem;
+	}> {
+		return this.request("POST", "/admin/media-usage/collection-deletions/retry", {
+			collectionId,
+		});
+	}
+
 	// -----------------------------------------------------------------------
 	// Search
 	// -----------------------------------------------------------------------

package/src/components/Block.astro

@@ -69,3 +69,15 @@ const alignClass = textAlignClassName(node.textAlign);
 		</p>
 	)
 }
+
+<style>
+	.has-text-align-center {
+		text-align: center;
+	}
+	.has-text-align-right {
+		text-align: right;
+	}
+	.has-text-align-justify {
+		text-align: justify;
+	}
+</style>

package/src/components/InlinePortableTextEditor.tsx

@@ -85,6 +85,48 @@ function k(): string {
 	return Math.random().toString(36).substring(2, 11);
 }
 
+function getUnsupportedFileGuidance(locale: string): string {
+	if (locale.toLowerCase().startsWith("ar")) {
+		return "لا يمكن إفلات الملفات أو لصقها هنا. اكتب /image لاختيار صورة من مكتبة الوسائط.";
+	}
+	return "Files can’t be dropped or pasted here. Type /image to choose an image from the media library.";
+}
+
+function hasTransferredFiles(transfer: DataTransfer | null): boolean {
+	if (!transfer) return false;
+	if (transfer.files.length > 0) return true;
+	for (let index = 0; index < transfer.items.length; index++) {
+		if (transfer.items[index]?.kind === "file") return true;
+	}
+	return false;
+}
+
+function createUnsupportedFileHandlers(showGuidance: () => void) {
+	const keepFileDragInEditor = (_view: unknown, event: DragEvent): boolean => {
+		if (!hasTransferredFiles(event.dataTransfer)) return false;
+		event.preventDefault();
+		return true;
+	};
+	return {
+		handleDOMEvents: {
+			dragenter: keepFileDragInEditor,
+			dragover: keepFileDragInEditor,
+			drop: (_view: unknown, event: DragEvent): boolean => {
+				if (!hasTransferredFiles(event.dataTransfer)) return false;
+				event.preventDefault();
+				showGuidance();
+				return true;
+			},
+			paste: (_view: unknown, event: ClipboardEvent): boolean => {
+				if (!hasTransferredFiles(event.clipboardData)) return false;
+				event.preventDefault();
+				showGuidance();
+				return true;
+			},
+		},
+	};
+}
+
 // ── ProseMirror → Portable Text ────────────────────────────────────
 
 type PMNode = {
@@ -1967,6 +2009,21 @@ export function InlinePortableTextEditor({
 
 	// Media picker state
 	const [mediaPickerOpen, setMediaPickerOpen] = React.useState(false);
+	const [unsupportedFileGuidance, setUnsupportedFileGuidance] = React.useState<{
+		message: string;
+		version: number;
+	} | null>(null);
+	const showUnsupportedFileGuidance = React.useCallback(() => {
+		const locale = document.documentElement.lang || navigator.language;
+		setUnsupportedFileGuidance((current) => ({
+			message: getUnsupportedFileGuidance(locale),
+			version: (current?.version ?? 0) + 1,
+		}));
+	}, []);
+	const unsupportedFileHandlers = React.useMemo(
+		() => createUnsupportedFileHandlers(showUnsupportedFileGuidance),
+		[showUnsupportedFileGuidance],
+	);
 
 	// Listen for the slash command's media picker event
 	React.useEffect(() => {
@@ -2132,6 +2189,7 @@ export function InlinePortableTextEditor({
 				class: "prose prose-sm sm:prose-base dark:prose-invert max-w-none emdash-inline-editor",
 				dir: "auto",
 			},
+			...unsupportedFileHandlers,
 		},
 		onUpdate: () => {
 			document.dispatchEvent(new CustomEvent("emdash:save", { detail: { state: "unsaved" } }));
@@ -2198,6 +2256,17 @@ export function InlinePortableTextEditor({
 		<div onBlur={handleBlur}>
 			<InlineBubbleMenu editor={editor} />
 			<EditorContent editor={editor} />
+			{unsupportedFileGuidance ? (
+				<div
+					key={unsupportedFileGuidance.version}
+					className="emdash-inline-editor-guidance"
+					role="status"
+					aria-live="polite"
+					dir="auto"
+				>
+					{unsupportedFileGuidance.message}
+				</div>
+			) : null}
 			<InlineSlashMenu
 				state={slashMenuState}
 				onCommand={handleSlashCommand}
@@ -2323,6 +2392,19 @@ export function InlinePortableTextEditor({
 				.emdash-inline-editor:focus {
 					outline: none;
 				}
+				.emdash-inline-editor-guidance {
+					margin-block-start: 0.75rem;
+					padding-block: 0.625rem;
+					padding-inline: 0.875rem;
+					border: 1px solid #bfdbfe;
+					border-radius: 0.5rem;
+					background: #eff6ff;
+					color: #1e3a8a;
+					font-size: 0.875rem;
+					font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
+					line-height: 1.4;
+					text-align: start;
+				}
 				.emdash-plugin-block-placeholder {
 					margin: 0.75rem 0;
 					padding: 0.625rem 0.875rem;
@@ -2335,6 +2417,11 @@ export function InlinePortableTextEditor({
 					user-select: none;
 				}
 				@media (prefers-color-scheme: dark) {
+					.emdash-inline-editor-guidance {
+						border-color: #1e40af;
+						background: #172554;
+						color: #dbeafe;
+					}
 					.emdash-plugin-block-placeholder {
 						border-color: #374151;
 						background: #111827;
@@ -2346,6 +2433,7 @@ export function InlinePortableTextEditor({
 	);
 }
 
-// Test-only exports for unit tests of the conversion functions.
+// Test-only exports for unit tests.
 export { pmToPortableText as _pmToPortableText };
 export { portableTextToPM as _portableTextToPM };
+export { createUnsupportedFileHandlers as _createUnsupportedFileHandlers };

package/src/content/converters/mark-safety.ts

@@ -0,0 +1,120 @@
+import type { PortableTextBlock, ProseMirrorDocument, ProseMirrorNode } from "./types.js";
+
+const SUPPORTED_PORTABLE_TEXT_DECORATORS = new Set([
+	"strong",
+	"em",
+	"underline",
+	"strike-through",
+	"subscript",
+	"superscript",
+	"code",
+]);
+
+const SUPPORTED_PROSEMIRROR_MARKS = new Set([
+	"bold",
+	"strong",
+	"italic",
+	"em",
+	"underline",
+	"strike",
+	"strikethrough",
+	"subscript",
+	"superscript",
+	"code",
+	"link",
+]);
+
+type UnknownRecord = Record<string, unknown>;
+
+function isRecord(value: unknown): value is UnknownRecord {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function collectPortableTextMarks(
+	value: unknown,
+	inheritedMarkDefs: ReadonlyMap<string, UnknownRecord>,
+	unsupported: Set<string>,
+): void {
+	if (Array.isArray(value)) {
+		for (const item of value) {
+			collectPortableTextMarks(item, inheritedMarkDefs, unsupported);
+		}
+		return;
+	}
+	if (!isRecord(value)) return;
+
+	let markDefs: ReadonlyMap<string, UnknownRecord> = inheritedMarkDefs;
+	if (Array.isArray(value.markDefs)) {
+		const localMarkDefs = new Map(inheritedMarkDefs);
+		for (const markDef of value.markDefs) {
+			if (isRecord(markDef) && typeof markDef._key === "string") {
+				localMarkDefs.set(markDef._key, markDef);
+			}
+		}
+		markDefs = localMarkDefs;
+	}
+
+	if (value._type === "span" && Array.isArray(value.marks)) {
+		for (const mark of value.marks) {
+			if (typeof mark !== "string" || SUPPORTED_PORTABLE_TEXT_DECORATORS.has(mark)) continue;
+			const markDef = markDefs.get(mark);
+			if (markDef?._type === "link") continue;
+			unsupported.add(typeof markDef?._type === "string" ? markDef._type : mark);
+		}
+	}
+
+	for (const [key, child] of Object.entries(value)) {
+		if (key !== "markDefs") {
+			collectPortableTextMarks(child, markDefs, unsupported);
+		}
+	}
+}
+
+function collectProseMirrorMarks(node: ProseMirrorNode, unsupported: Set<string>): void {
+	for (const mark of node.marks ?? []) {
+		if (!SUPPORTED_PROSEMIRROR_MARKS.has(mark.type)) {
+			unsupported.add(mark.type);
+		}
+	}
+	for (const child of node.content ?? []) {
+		collectProseMirrorMarks(child, unsupported);
+	}
+}
+
+export class UnsupportedPortableTextMarksError extends Error {
+	readonly marks: string[];
+
+	constructor(marks: Iterable<string>) {
+		const sortedMarks = [...new Set(marks)].toSorted();
+		super(`Unsupported Portable Text marks: ${sortedMarks.join(", ")}`);
+		this.name = "UnsupportedPortableTextMarksError";
+		this.marks = sortedMarks;
+	}
+}
+
+export function findUnsupportedPortableTextMarks(blocks: PortableTextBlock[]): string[] {
+	const unsupported = new Set<string>();
+	for (const block of blocks) {
+		if (block._type === "block" || block._type === "table") {
+			collectPortableTextMarks(block, new Map(), unsupported);
+		}
+	}
+	return [...unsupported].toSorted();
+}
+
+export function assertPortableTextMarksSupported(blocks: PortableTextBlock[]): void {
+	const unsupported = findUnsupportedPortableTextMarks(blocks);
+	if (unsupported.length > 0) {
+		throw new UnsupportedPortableTextMarksError(unsupported);
+	}
+}
+
+export function assertProseMirrorMarksSupported(document: ProseMirrorDocument): void {
+	const unsupported = new Set<string>();
+	for (const node of document.content) {
+		collectProseMirrorMarks(node, unsupported);
+	}
+	if (unsupported.size > 0) {
+		throw new UnsupportedPortableTextMarksError(unsupported);
+	}
+}

package/src/content/converters/portable-text-to-prosemirror.ts

@@ -5,6 +5,10 @@
  */
 
 import { sanitizeGalleryImages } from "./gallery.js";
+import {
+	UnsupportedPortableTextMarksError,
+	assertPortableTextMarksSupported,
+} from "./mark-safety.js";
 import {
 	deriveLegacyListId,
 	normalizeProseMirrorOrderedListJson,
@@ -34,6 +38,7 @@ export function portableTextToProsemirror(blocks: PortableTextBlock[]): ProseMir
 			content: [{ type: "paragraph" }],
 		};
 	}
+	assertPortableTextMarksSupported(blocks);
 
 	const content: ProseMirrorNode[] = [];
 	let i = 0;
@@ -466,6 +471,14 @@ function convertMarks(
 				pmMarks.push({ type: "strike" });
 				break;
 
+			case "subscript":
+				pmMarks.push({ type: "subscript" });
+				break;
+
+			case "superscript":
+				pmMarks.push({ type: "superscript" });
+				break;
+
 			case "code":
 				pmMarks.push({ type: "code" });
 				break;
@@ -473,22 +486,18 @@ function convertMarks(
 			default: {
 				// Check if it's a mark definition reference
 				const markDef = markDefs.get(mark);
-				if (markDef) {
-					if (markDef._type === "link") {
-						pmMarks.push({
-							type: "link",
-							attrs: {
-								href: markDef.href,
-								target: markDef.blank ? "_blank" : null,
-							},
-						});
-					} else {
-						// Unknown mark def type - preserve attrs
-						pmMarks.push({
-							type: markDef._type,
-							attrs: markDef,
-						});
-					}
+				if (markDef?._type === "link") {
+					pmMarks.push({
+						type: "link",
+						attrs: {
+							href: markDef.href,
+							target: markDef.blank ? "_blank" : null,
+						},
+					});
+				} else {
+					throw new UnsupportedPortableTextMarksError([
+						typeof markDef?._type === "string" ? markDef._type : mark,
+					]);
 				}
 				break;
 			}

package/src/content/converters/prosemirror-to-portable-text.ts

@@ -5,6 +5,10 @@
  */
 
 import { sanitizeGalleryImages } from "./gallery.js";
+import {
+	UnsupportedPortableTextMarksError,
+	assertProseMirrorMarksSupported,
+} from "./mark-safety.js";
 import { readOrderedListMetadata, type OrderedListMetadata } from "./numbered-list.js";
 import type {
 	ProseMirrorDocument,
@@ -34,6 +38,7 @@ export function prosemirrorToPortableText(doc: ProseMirrorDocument): PortableTex
 	if (!doc || doc.type !== "doc" || !doc.content) {
 		return [];
 	}
+	assertProseMirrorMarksSupported(doc);
 
 	const blocks: PortableTextBlock[] = [];
 
@@ -435,6 +440,12 @@ function convertMark(
 		case "strikethrough":
 			return "strike-through";
 
+		case "subscript":
+			return "subscript";
+
+		case "superscript":
+			return "superscript";
+
 		case "code":
 			return "code";
 
@@ -460,7 +471,6 @@ function convertMark(
 		}
 
 		default:
-			// Unknown mark - preserve as-is
-			return mark.type;
+			throw new UnsupportedPortableTextMarksError([mark.type]);
 	}
 }

package/src/content-list-query.ts

@@ -0,0 +1,29 @@
+/** Scalar values accepted by indexed content-field filters. */
+export type ContentFieldFilterScalar = string | number | boolean | null;
+
+/** Inclusive or exclusive bounds for an indexed scalar field. */
+export interface ContentFieldRangeFilter {
+	gt?: string | number;
+	gte?: string | number;
+	lt?: string | number;
+	lte?: string | number;
+}
+
+/** Match any one of the supplied values. */
+export interface ContentFieldInFilter {
+	in: Array<string | number | boolean>;
+}
+
+/** A single indexed content-field condition. */
+export type ContentFieldFilterValue =
+	| ContentFieldFilterScalar
+	| ContentFieldRangeFilter
+	| ContentFieldInFilter;
+
+/**
+ * Indexed custom-field filters, combined with AND semantics.
+ *
+ * A scalar performs an exact match, `null` matches missing values, `{ in: [...] }`
+ * performs membership matching, and range bounds can be combined.
+ */
+export type ContentFieldFilters = Record<string, ContentFieldFilterValue>;

package/src/database/index.ts

@@ -2,6 +2,12 @@
 // `connection.ts`, which statically imports `better-sqlite3`. See #947.
 export { EmDashDatabaseError } from "./errors.js";
 export type { DatabaseConfig } from "./connection.js";
-export { runMigrations, getMigrationStatus, rollbackMigration } from "./migrations/runner.js";
-export type { MigrationStatus } from "./migrations/runner.js";
+export {
+	runMigrations,
+	getMigrationStatus,
+	getExactMigrationStatus,
+	rollbackMigration,
+	MIGRATION_NAMES,
+} from "./migrations/runner.js";
+export type { MigrationStatus, ExactMigrationStatus } from "./migrations/runner.js";
 export type * from "./types.js";

package/src/database/migrations/060_collection_admin_config.ts

@@ -0,0 +1,16 @@
+import type { Kysely } from "kysely";
+
+import { columnExists } from "../dialect-helpers.js";
+
+/** Persist collection-level admin presentation options. */
+export async function up(db: Kysely<unknown>): Promise<void> {
+	if (!(await columnExists(db, "_emdash_collections", "admin_config"))) {
+		await db.schema.alterTable("_emdash_collections").addColumn("admin_config", "text").execute();
+	}
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+	if (await columnExists(db, "_emdash_collections", "admin_config")) {
+		await db.schema.alterTable("_emdash_collections").dropColumn("admin_config").execute();
+	}
+}

package/src/database/migrations/061_media_usage_cleanup.ts

@@ -0,0 +1,77 @@
+import { sql, type Kysely } from "kysely";
+
+import { currentTimestamp } from "../dialect-helpers.js";
+
+const CLEANUP_TASK_KEY = "projection_gc";
+const INITIAL_ELIGIBLE_AT = "1970-01-01T00:00:00.000Z";
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+	await db.schema
+		.createIndex("idx__emdash_media_usage_cleanup_scan")
+		.ifNotExists()
+		.on("_emdash_media_usage")
+		.columns(["created_at", "id", "source_key", "generation"])
+		.execute();
+
+	await db.schema
+		.createTable("_emdash_media_usage_cleanup")
+		.ifNotExists()
+		.addColumn("task_key", "text", (c) => c.primaryKey())
+		.addColumn("lease_token", "text")
+		.addColumn("lease_expires_at", "text")
+		.addColumn("next_eligible_at", "text", (c) => c.notNull())
+		.addColumn("cursor_created_at", "text")
+		.addColumn("cursor_id", "text")
+		.addColumn("scan_before_at", "text")
+		.addColumn("consecutive_failures", "integer", (c) => c.notNull().defaultTo(0))
+		.addColumn("last_started_at", "text")
+		.addColumn("last_completed_at", "text")
+		.addColumn("last_candidate_count", "integer", (c) => c.notNull().defaultTo(0))
+		.addColumn("last_deleted_orphans", "integer", (c) => c.notNull().defaultTo(0))
+		.addColumn("last_deleted_stale", "integer", (c) => c.notNull().defaultTo(0))
+		.addColumn("last_deleted_abandoned", "integer", (c) => c.notNull().defaultTo(0))
+		.addColumn("last_deleted_write_leases", "integer", (c) => c.notNull().defaultTo(0))
+		.addColumn("last_backlog_lower_bound", "integer", (c) => c.notNull().defaultTo(0))
+		.addColumn("last_scan_has_more", "integer", (c) => c.notNull().defaultTo(0))
+		.addColumn("last_duration_ms", "integer", (c) => c.notNull().defaultTo(0))
+		.addColumn("last_error_code", "text")
+		.addColumn("updated_at", "text", (c) => c.notNull().defaultTo(currentTimestamp(db)))
+		.execute();
+
+	await db.schema
+		.createTable("_emdash_media_usage_generation_writes")
+		.ifNotExists()
+		.addColumn("source_key", "text", (c) => c.notNull())
+		.addColumn("generation", "text", (c) => c.notNull())
+		.addColumn("lease_token", "text", (c) => c.primaryKey())
+		.addColumn("expires_at", "text", (c) => c.notNull())
+		.addColumn("created_at", "text", (c) => c.notNull().defaultTo(currentTimestamp(db)))
+		.addUniqueConstraint("_emdash_media_usage_generation_writes_source_generation", [
+			"source_key",
+			"generation",
+		])
+		.execute();
+
+	await db.schema
+		.createIndex("idx__emdash_media_usage_generation_writes_expiry")
+		.ifNotExists()
+		.on("_emdash_media_usage_generation_writes")
+		.columns(["expires_at", "lease_token"])
+		.execute();
+
+	await sql`
+		INSERT INTO _emdash_media_usage_cleanup (task_key, next_eligible_at)
+		VALUES (${CLEANUP_TASK_KEY}, ${INITIAL_ELIGIBLE_AT})
+		ON CONFLICT (task_key) DO NOTHING
+	`.execute(db);
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+	await db.schema
+		.dropIndex("idx__emdash_media_usage_generation_writes_expiry")
+		.ifExists()
+		.execute();
+	await db.schema.dropTable("_emdash_media_usage_generation_writes").ifExists().execute();
+	await db.schema.dropTable("_emdash_media_usage_cleanup").ifExists().execute();
+	await db.schema.dropIndex("idx__emdash_media_usage_cleanup_scan").ifExists().execute();
+}