emdash 0.35.0 → 0.36.0

package/src/api/errors.ts

@@ -28,6 +28,8 @@ export const ErrorCode = {
 	// Content
 	CONTENT_CREATE_ERROR: "CONTENT_CREATE_ERROR",
 	CONTENT_UPDATE_ERROR: "CONTENT_UPDATE_ERROR",
+	SAVE_REJECTED: "SAVE_REJECTED",
+	CONTENT_HOOK_ERROR: "CONTENT_HOOK_ERROR",
 	CONTENT_DELETE_ERROR: "CONTENT_DELETE_ERROR",
 	CONTENT_LIST_ERROR: "CONTENT_LIST_ERROR",
 	CONTENT_GET_ERROR: "CONTENT_GET_ERROR",
@@ -86,12 +88,25 @@ export const ErrorCode = {
 	MEDIA_CREATE_ERROR: "MEDIA_CREATE_ERROR",
 	MEDIA_UPDATE_ERROR: "MEDIA_UPDATE_ERROR",
 	MEDIA_DELETE_ERROR: "MEDIA_DELETE_ERROR",
+	MEDIA_FOLDER_LIST_ERROR: "MEDIA_FOLDER_LIST_ERROR",
+	MEDIA_FOLDER_GET_ERROR: "MEDIA_FOLDER_GET_ERROR",
+	MEDIA_FOLDER_CREATE_ERROR: "MEDIA_FOLDER_CREATE_ERROR",
+	MEDIA_FOLDER_UPDATE_ERROR: "MEDIA_FOLDER_UPDATE_ERROR",
+	MEDIA_FOLDER_DELETE_ERROR: "MEDIA_FOLDER_DELETE_ERROR",
 	MEDIA_USAGE_READ_ERROR: "MEDIA_USAGE_READ_ERROR",
 	MEDIA_USAGE_REPAIR_ERROR: "MEDIA_USAGE_REPAIR_ERROR",
+	MEDIA_USAGE_PROGRESS_READ_ERROR: "MEDIA_USAGE_PROGRESS_READ_ERROR",
+	MEDIA_USAGE_PROGRESS_ADVANCE_ERROR: "MEDIA_USAGE_PROGRESS_ADVANCE_ERROR",
+	MEDIA_USAGE_PROGRESS_NOT_ACTIVE: "MEDIA_USAGE_PROGRESS_NOT_ACTIVE",
 	MEDIA_USAGE_WORK_LIST_ERROR: "MEDIA_USAGE_WORK_LIST_ERROR",
 	MEDIA_USAGE_WORK_RETRY_ERROR: "MEDIA_USAGE_WORK_RETRY_ERROR",
 	MEDIA_USAGE_COLLECTION_DELETION_LIST_ERROR: "MEDIA_USAGE_COLLECTION_DELETION_LIST_ERROR",
 	MEDIA_USAGE_COLLECTION_DELETION_RETRY_ERROR: "MEDIA_USAGE_COLLECTION_DELETION_RETRY_ERROR",
+	MEDIA_USAGE_ACTIVATION_VERSION_MISMATCH: "MEDIA_USAGE_ACTIVATION_VERSION_MISMATCH",
+	MEDIA_USAGE_ACTIVATION_READ_ERROR: "MEDIA_USAGE_ACTIVATION_READ_ERROR",
+	MEDIA_USAGE_ACTIVATION_BUSY: "MEDIA_USAGE_ACTIVATION_BUSY",
+	MEDIA_USAGE_ACTIVATION_CONFLICT: "MEDIA_USAGE_ACTIVATION_CONFLICT",
+	MEDIA_USAGE_ACTIVATION_ADVANCE_ERROR: "MEDIA_USAGE_ACTIVATION_ADVANCE_ERROR",
 	WORK_LEASE_ACTIVE: "WORK_LEASE_ACTIVE",
 	WORK_CHANGED: "WORK_CHANGED",
 	NO_STORAGE: "NO_STORAGE",
@@ -461,6 +476,10 @@ export function mapErrorStatus(code: string | undefined): number {
 		case ErrorCode.ENV_INCOMPATIBLE:
 		case ErrorCode.WORK_LEASE_ACTIVE:
 		case ErrorCode.WORK_CHANGED:
+		case ErrorCode.MEDIA_USAGE_ACTIVATION_VERSION_MISMATCH:
+		case ErrorCode.MEDIA_USAGE_ACTIVATION_BUSY:
+		case ErrorCode.MEDIA_USAGE_ACTIVATION_CONFLICT:
+		case ErrorCode.MEDIA_USAGE_PROGRESS_NOT_ACTIVE:
 			return 409;
 
 		// 410 Gone
@@ -468,6 +487,7 @@ export function mapErrorStatus(code: string | undefined): number {
 			return 410;
 
 		// 422 Unprocessable Entity
+		case ErrorCode.SAVE_REJECTED:
 		case ErrorCode.CHECKSUM_MISMATCH:
 		case ErrorCode.INVALID_BUNDLE:
 		case ErrorCode.BUNDLE_EXTRACT_FAILED:

package/src/api/handlers/index.ts

@@ -60,10 +60,19 @@ export {
 	type MediaListResponse,
 	type MediaResponse,
 } from "./media.js";
+export {
+	handleMediaFolderList,
+	handleMediaFolderGet,
+	handleMediaFolderCreate,
+	handleMediaFolderUpdate,
+	handleMediaFolderDelete,
+} from "./media-folders.js";
 
 export {
 	aggregateMediaUsageCoverageStatus,
 	handleMediaUsageDetails,
+	handleMediaUsageProgress,
+	handleMediaUsageProgressAdvance,
 	handleMediaUsageSummaries,
 	handleMediaUsageRepair,
 	toMediaUsageRepairResponse,
@@ -72,11 +81,18 @@ export {
 	type MediaUsageDetailsResponse,
 	type MediaUsageEntryDetail,
 	type MediaUsageOccurrenceDetail,
+	type MediaUsageProgress,
+	type MediaUsageProgressAdvanceResponse,
 	type MediaUsageRepairResponse,
 	type MediaUsageSourceDetail,
 	type MediaUsageSummary,
 } from "./media-usage.js";
 
+export {
+	handleMediaUsageActivationAdvance,
+	handleMediaUsageActivationStatus,
+} from "./media-usage-activation.js";
+
 export {
 	handleMediaUsageWorkList,
 	handleMediaUsageWorkRetry,
@@ -99,6 +115,7 @@ export {
 	handleSchemaFieldCreate,
 	handleSchemaFieldUpdate,
 	handleSchemaFieldDelete,
+	handleSchemaCollectionReorder,
 	handleSchemaFieldReorder,
 	handleOrphanedTableList,
 	handleOrphanedTableRegister,

package/src/api/handlers/media-allowlist.ts

@@ -21,6 +21,7 @@ export const GLOBAL_UPLOAD_ALLOWLIST: readonly string[] = [
 	"image/jpeg",
 	"image/gif",
 	"image/webp",
+	"image/avif",
 	"video/",
 	"audio/",
 	"application/pdf",

package/src/api/handlers/media-folders.ts

@@ -0,0 +1,130 @@
+import type { Kysely } from "kysely";
+
+import {
+	MediaFolderRepository,
+	type MediaFolder,
+} from "../../database/repositories/media-folders.js";
+import { EmDashValidationError, InvalidCursorError } from "../../database/repositories/types.js";
+import type { Database } from "../../database/types.js";
+import type { ApiResult } from "../types.js";
+
+const UNIQUE_VIOLATION_RE =
+	/unique constraint failed|duplicate key value violates unique constraint/i;
+
+export async function handleMediaFolderList(
+	db: Kysely<Database>,
+	options: { limit?: number; cursor?: string; q?: string } = {},
+): Promise<ApiResult<{ items: MediaFolder[]; nextCursor?: string }>> {
+	try {
+		const result = await new MediaFolderRepository(db).findMany(options);
+		return { success: true, data: result };
+	} catch (error) {
+		if (error instanceof InvalidCursorError) {
+			return { success: false, error: { code: "INVALID_CURSOR", message: error.message } };
+		}
+		return {
+			success: false,
+			error: { code: "MEDIA_FOLDER_LIST_ERROR", message: "Failed to list media folders" },
+		};
+	}
+}
+
+export async function handleMediaFolderGet(
+	db: Kysely<Database>,
+	id: string,
+): Promise<ApiResult<{ item: MediaFolder }>> {
+	try {
+		const item = await new MediaFolderRepository(db).findById(id);
+		if (!item) {
+			return { success: false, error: { code: "NOT_FOUND", message: "Media folder not found" } };
+		}
+		return { success: true, data: { item } };
+	} catch {
+		return {
+			success: false,
+			error: { code: "MEDIA_FOLDER_GET_ERROR", message: "Failed to get media folder" },
+		};
+	}
+}
+
+export async function handleMediaFolderCreate(
+	db: Kysely<Database>,
+	input: { name: string },
+): Promise<ApiResult<{ item: MediaFolder }>> {
+	try {
+		const item = await new MediaFolderRepository(db).create(input.name);
+		return { success: true, data: { item } };
+	} catch (error) {
+		return mediaFolderWriteError(
+			error,
+			"MEDIA_FOLDER_CREATE_ERROR",
+			"Failed to create media folder",
+		);
+	}
+}
+
+export async function handleMediaFolderUpdate(
+	db: Kysely<Database>,
+	id: string,
+	input: { name: string },
+): Promise<ApiResult<{ item: MediaFolder }>> {
+	try {
+		const item = await new MediaFolderRepository(db).update(id, input.name);
+		if (!item) {
+			return { success: false, error: { code: "NOT_FOUND", message: "Media folder not found" } };
+		}
+		return { success: true, data: { item } };
+	} catch (error) {
+		return mediaFolderWriteError(
+			error,
+			"MEDIA_FOLDER_UPDATE_ERROR",
+			"Failed to update media folder",
+		);
+	}
+}
+
+export async function handleMediaFolderDelete(
+	db: Kysely<Database>,
+	id: string,
+): Promise<ApiResult<{ deleted: true }>> {
+	try {
+		const deleted = await new MediaFolderRepository(db).delete(id);
+		if (!deleted) {
+			return { success: false, error: { code: "NOT_FOUND", message: "Media folder not found" } };
+		}
+		return { success: true, data: { deleted: true } };
+	} catch {
+		return {
+			success: false,
+			error: { code: "MEDIA_FOLDER_DELETE_ERROR", message: "Failed to delete media folder" },
+		};
+	}
+}
+
+function mediaFolderWriteError(
+	error: unknown,
+	code: "MEDIA_FOLDER_CREATE_ERROR" | "MEDIA_FOLDER_UPDATE_ERROR",
+	message: string,
+): ApiResult<never> {
+	if (error instanceof EmDashValidationError) {
+		return { success: false, error: { code: "VALIDATION_ERROR", message: error.message } };
+	}
+	if (isUniqueViolation(error)) {
+		return {
+			success: false,
+			error: { code: "CONFLICT", message: "A media folder with this name already exists" },
+		};
+	}
+	return { success: false, error: { code, message } };
+}
+
+function isUniqueViolation(error: unknown): boolean {
+	if (error && typeof error === "object") {
+		if ("code" in error && error.code === "23505") return true;
+	}
+	const message = error instanceof Error ? error.message : "";
+	if (UNIQUE_VIOLATION_RE.test(message)) return true;
+	return Boolean(
+		error && typeof error === "object" && "cause" in error && isUniqueViolation(error.cause),
+	);
+}

package/src/api/handlers/media-usage-activation.ts

@@ -0,0 +1,102 @@
+import type { Kysely } from "kysely";
+
+import type { Database } from "../../database/types.js";
+import {
+	activateMediaUsageCapture,
+	getMediaUsageActivationStatus,
+	MediaUsageActivationVersionMismatchError,
+} from "../../media/usage/activation.js";
+import { ErrorCode } from "../errors.js";
+import type {
+	MediaUsageActivationAdvanceRequest,
+	MediaUsageActivationAdvanceResponse,
+	MediaUsageActivationStatus,
+} from "../schemas/media-usage.js";
+import type { ApiResult } from "../types.js";
+
+export async function handleMediaUsageActivationStatus(
+	db: Kysely<Database>,
+): Promise<ApiResult<MediaUsageActivationStatus>> {
+	try {
+		return { success: true, data: await getMediaUsageActivationStatus(db) };
+	} catch (error) {
+		if (error instanceof MediaUsageActivationVersionMismatchError) {
+			return {
+				success: false,
+				error: {
+					code: ErrorCode.MEDIA_USAGE_ACTIVATION_VERSION_MISMATCH,
+					message: "Media usage activation version is incompatible with this runtime",
+				},
+			};
+		}
+		console.error("[media-usage:activation] status read failed:", error);
+		return {
+			success: false,
+			error: {
+				code: ErrorCode.MEDIA_USAGE_ACTIVATION_READ_ERROR,
+				message: "Failed to read media usage activation status",
+			},
+		};
+	}
+}
+
+export async function handleMediaUsageActivationAdvance(
+	db: Kysely<Database>,
+	input: MediaUsageActivationAdvanceRequest,
+): Promise<ApiResult<MediaUsageActivationAdvanceResponse>> {
+	try {
+		const result = await activateMediaUsageCapture(db, {
+			writersDrained: input.writersDrained,
+		});
+		if (result.outcome === "lease_active") {
+			return {
+				success: false,
+				error: {
+					code: ErrorCode.MEDIA_USAGE_ACTIVATION_BUSY,
+					message: "Media usage activation is already in progress",
+					details: { leaseExpiresAt: result.leaseExpiresAt },
+				},
+			};
+		}
+		if (result.outcome === "conflict") {
+			return {
+				success: false,
+				error: {
+					code: ErrorCode.MEDIA_USAGE_ACTIVATION_CONFLICT,
+					message: "Media usage activation ownership changed",
+				},
+			};
+		}
+
+		const activation = await getMediaUsageActivationStatus(db);
+		if (activation.state === "expanded") {
+			throw new Error("Media usage activation did not advance");
+		}
+		return {
+			success: true,
+			data: {
+				outcome: activation.state,
+				processedCollections: result.processedCollections,
+				activation,
+			},
+		};
+	} catch (error) {
+		if (error instanceof MediaUsageActivationVersionMismatchError) {
+			return {
+				success: false,
+				error: {
+					code: ErrorCode.MEDIA_USAGE_ACTIVATION_VERSION_MISMATCH,
+					message: "Media usage activation version is incompatible with this runtime",
+				},
+			};
+		}
+		console.error("[media-usage:activation] advance failed:", error);
+		return {
+			success: false,
+			error: {
+				code: ErrorCode.MEDIA_USAGE_ACTIVATION_ADVANCE_ERROR,
+				message: "Failed to advance media usage activation",
+			},
+		};
+	}
+}

package/src/api/handlers/media-usage.ts

@@ -8,6 +8,10 @@ import {
 import { MediaRepository } from "../../database/repositories/media.js";
 import { InvalidCursorError } from "../../database/repositories/types.js";
 import type { Database } from "../../database/types.js";
+import {
+	getMediaUsageActivationStatus,
+	MediaUsageActivationVersionMismatchError,
+} from "../../media/usage/activation.js";
 import {
 	CONTENT_MEDIA_USAGE_ADAPTER_ID,
 	CONTENT_MEDIA_USAGE_COLLECTION_SCOPE,
@@ -19,6 +23,10 @@ import {
 	type ContentMediaUsageRepairCollectionResult,
 } from "../../media/usage/content-repair.js";
 import { CONTENT_SOURCE_SCHEMA_VERSION } from "../../media/usage/content-snapshots.js";
+import {
+	runMediaUsageMaintenanceStep,
+	type MediaUsageMaintenanceContinuation,
+} from "../../media/usage/maintenance-engine.js";
 import { ErrorCode } from "../errors.js";
 import type {
 	MediaUsageCoverage,
@@ -26,6 +34,8 @@ import type {
 	MediaUsageDetailsResponse,
 	MediaUsageEntryDetail,
 	MediaUsageOccurrenceDetail,
+	MediaUsageProgress,
+	MediaUsageProgressAdvanceResponse,
 	MediaUsageRepairRequest,
 	MediaUsageRepairResponse,
 	MediaUsageSummary,
@@ -38,6 +48,8 @@ export type {
 	MediaUsageDetailsResponse,
 	MediaUsageEntryDetail,
 	MediaUsageOccurrenceDetail,
+	MediaUsageProgress,
+	MediaUsageProgressAdvanceResponse,
 	MediaUsageSourceDetail,
 	MediaUsageRepairRequest,
 	MediaUsageRepairResponse,
@@ -48,6 +60,102 @@ type ContentMediaUsageRepairResult =
 	| ContentMediaUsageRepairCollectionResult
 	| ContentMediaUsageRepairAllResult;
 
+export async function handleMediaUsageProgress(
+	db: Kysely<Database>,
+): Promise<ApiResult<MediaUsageProgress>> {
+	try {
+		const progress = await new MediaUsageRepository(db).findCollectionProgress();
+		if (!progress) {
+			return {
+				success: false,
+				error: {
+					code: ErrorCode.MEDIA_USAGE_PROGRESS_NOT_ACTIVE,
+					message: "Media Usage is not active",
+				},
+			};
+		}
+		return { success: true, data: progress };
+	} catch (error) {
+		if (error instanceof MediaUsageActivationVersionMismatchError) {
+			return {
+				success: false,
+				error: {
+					code: ErrorCode.MEDIA_USAGE_ACTIVATION_VERSION_MISMATCH,
+					message: "Media Usage activation version does not match this runtime",
+				},
+			};
+		}
+		console.error("[media-usage] progress read failed:", error);
+		return {
+			success: false,
+			error: {
+				code: ErrorCode.MEDIA_USAGE_PROGRESS_READ_ERROR,
+				message: "Failed to read media usage progress",
+			},
+		};
+	}
+}
+
+export async function handleMediaUsageProgressAdvance(
+	db: Kysely<Database>,
+): Promise<ApiResult<MediaUsageProgressAdvanceResponse>> {
+	try {
+		const step = await runMediaUsageMaintenanceStep(db);
+		const activation = await getMediaUsageActivationStatus(db);
+		if (activation.state === "expanded") {
+			return {
+				success: false,
+				error: {
+					code: ErrorCode.MEDIA_USAGE_PROGRESS_NOT_ACTIVE,
+					message: "Media Usage activation has not started",
+				},
+			};
+		}
+
+		const progress =
+			activation.state === "active"
+				? await new MediaUsageRepository(db).findCollectionProgress()
+				: null;
+		return {
+			success: true,
+			data: {
+				activation,
+				progress,
+				nextRequestInMs: continuationDelayMs(step.continuation, progress),
+			},
+		};
+	} catch (error) {
+		if (error instanceof MediaUsageActivationVersionMismatchError) {
+			return {
+				success: false,
+				error: {
+					code: ErrorCode.MEDIA_USAGE_ACTIVATION_VERSION_MISMATCH,
+					message: "Media Usage activation version does not match this runtime",
+				},
+			};
+		}
+		console.error("[media-usage] progress advance failed:", error);
+		return {
+			success: false,
+			error: {
+				code: ErrorCode.MEDIA_USAGE_PROGRESS_ADVANCE_ERROR,
+				message: "Failed to advance media usage progress",
+			},
+		};
+	}
+}
+
+function continuationDelayMs(
+	continuation: MediaUsageMaintenanceContinuation,
+	progress: MediaUsageProgress | null,
+): 0 | 30_000 | null {
+	if (progress?.status === "needs_attention") return null;
+	if (continuation.kind === "immediate") return 0;
+	if (continuation.kind === "delayed") return 30_000;
+	if (progress?.status === "indexing") return 0;
+	return null;
+}
+
 export function aggregateMediaUsageCoverageStatus(
 	scopes: readonly MediaUsageCollectionIndexStatusScope[],
 ): MediaUsageCoverageStatus {

package/src/api/handlers/media.ts

@@ -7,11 +7,15 @@ import type { Kysely } from "kysely";
 import { MediaRepository, type MediaItem } from "../../database/repositories/media.js";
 import { InvalidCursorError } from "../../database/repositories/types.js";
 import type { Database } from "../../database/types.js";
+import { isValidFocalPointUpdate, type FocalPointUpdate } from "../../media/focal-point.js";
 import type { ApiResult } from "../types.js";
 
+const FOREIGN_KEY_VIOLATION_RE = /foreign key constraint failed/i;
+
 export interface MediaListResponse {
 	items: MediaItem[];
 	nextCursor?: string;
+	totalCount?: number;
 }
 
 export interface MediaResponse {
@@ -25,18 +29,47 @@ export async function handleMediaList(
 	db: Kysely<Database>,
 	params: {
 		cursor?: string;
+		page?: number;
 		limit?: number;
 		mimeType?: string | readonly string[];
 		q?: string;
+		folderId?: string | null;
 	},
 ): Promise<ApiResult<MediaListResponse>> {
 	try {
+		if (params.page !== undefined) {
+			const limit = Math.min(params.limit || 50, 100);
+			const offset = (params.page - 1) * limit;
+			if (
+				params.cursor !== undefined ||
+				!Number.isSafeInteger(params.page) ||
+				params.page < 1 ||
+				!Number.isSafeInteger(offset)
+			) {
+				return {
+					success: false,
+					error: { code: "VALIDATION_ERROR", message: "Invalid media page" },
+				};
+			}
+
+			const repo = new MediaRepository(db);
+			const result = await repo.findPage({
+				page: params.page,
+				limit,
+				mimeType: params.mimeType,
+				q: params.q,
+				folderId: params.folderId,
+			});
+			return { success: true, data: result };
+		}
+
 		const repo = new MediaRepository(db);
 		const result = await repo.findMany({
 			cursor: params.cursor,
 			limit: Math.min(params.limit || 50, 100),
 			mimeType: params.mimeType,
 			q: params.q,
+			folderId: params.folderId,
 		});
 
 		return {
@@ -148,8 +181,18 @@ export async function handleMediaUpdate(
 		caption?: string;
 		width?: number;
 		height?: number;
-	},
+		folderId?: string | null;
+	} & FocalPointUpdate,
 ): Promise<ApiResult<MediaResponse>> {
+	if (!isValidFocalPointUpdate(input)) {
+		return {
+			success: false,
+			error: {
+				code: "VALIDATION_ERROR",
+				message: "focalX and focalY must both be valid numbers or both be null",
+			},
+		};
+	}
 	try {
 		const repo = new MediaRepository(db);
 		const item = await repo.update(id, input);
@@ -168,7 +211,13 @@ export async function handleMediaUpdate(
 			success: true,
 			data: { item },
 		};
-	} catch {
+	} catch (error) {
+		if (isForeignKeyViolation(error)) {
+			return {
+				success: false,
+				error: { code: "NOT_FOUND", message: "Media folder not found" },
+			};
+		}
 		return {
 			success: false,
 			error: {
@@ -179,6 +228,17 @@ export async function handleMediaUpdate(
 	}
 }
 
+function isForeignKeyViolation(error: unknown): boolean {
+	if (error && typeof error === "object") {
+		if ("code" in error && error.code === "23503") return true;
+	}
+	const message = error instanceof Error ? error.message : "";
+	if (FOREIGN_KEY_VIOLATION_RE.test(message)) return true;
+	return Boolean(
+		error && typeof error === "object" && "cause" in error && isForeignKeyViolation(error.cause),
+	);
+}
+
 /**
  * Delete media item
  */