dineway 0.1.8 → 0.1.11

package/dist/api-Cmy8Rjk5.mjs

@@ -0,0 +1,2704 @@
+import { r as validatePluginIdentifier, t as validateIdentifier } from "./validate-VPnKoIzW.mjs";
+import { r as RevisionRepository, t as ContentRepository } from "./content-CyLkb-qH.mjs";
+import { r as encodeBase64, t as decodeBase64 } from "./base64-Cz-aU0X1.mjs";
+import { t as DinewayValidationError } from "./types-Bs6lTBBW.mjs";
+import { t as MediaRepository } from "./media-_7Fxdu45.mjs";
+import { t as CommentRepository } from "./comment-DFO-gWDH.mjs";
+import { t as withTransaction } from "./transaction-x2tJQ-A1.mjs";
+import { t as RedirectRepository } from "./redirect-CGl64yOX.mjs";
+import { t as BylineRepository } from "./byline-naZxOPSa.mjs";
+import { t as SeoRepository } from "./seo-CUQctrog.mjs";
+import { r as isI18nEnabled } from "./config-CAMFxGaV.mjs";
+import { i as invalidateRedirectCache } from "./cache-DEbQ13c9.mjs";
+import { u as PluginStateRepository } from "./briefing-BrXCuMEE.mjs";
+import { n as SchemaRegistry, t as SchemaError } from "./registry-C-_hxLqa.mjs";
+import { n as hashString } from "./hash-CDX7M0ze.mjs";
+import { n as VERSION, t as COMMIT } from "./version-DH53KCQd.mjs";
+import { i as pluginManifestSchema, r as normalizeManifestRoute } from "./manifest-schema-DYoCQ5np.mjs";
+import { t as DinewayStorageError } from "./types-B9gKVOHk.mjs";
+import { sql } from "kysely";
+import { createGzipDecoder, unpackTar } from "modern-tar";
+
+//#region src/api/rev.ts
+/**
+* Generate a _rev token from a content item's version and updatedAt.
+*/
+function encodeRev(item) {
+	return encodeBase64(`${item.version}:${item.updatedAt}`);
+}
+/**
+* Decode a _rev token into its components.
+* Returns null if the token is malformed.
+*/
+function decodeRev(rev) {
+	try {
+		const decoded = decodeBase64(rev);
+		const colonIdx = decoded.indexOf(":");
+		if (colonIdx === -1) return null;
+		const version = parseInt(decoded.slice(0, colonIdx), 10);
+		const updatedAt = decoded.slice(colonIdx + 1);
+		if (isNaN(version) || !updatedAt) return null;
+		return {
+			version,
+			updatedAt
+		};
+	} catch {
+		return null;
+	}
+}
+/**
+* Validate a _rev token against a content item.
+* Returns null if valid (or if no _rev provided), or an error message if invalid.
+*/
+function validateRev(rev, item) {
+	if (!rev) return { valid: true };
+	const decoded = decodeRev(rev);
+	if (!decoded) return {
+		valid: false,
+		message: "Malformed _rev token"
+	};
+	if (decoded.version !== item.version || decoded.updatedAt !== item.updatedAt) return {
+		valid: false,
+		message: "Content has been modified since last read (version conflict)"
+	};
+	return { valid: true };
+}
+
+//#endregion
+//#region src/api/handlers/content.ts
+/**
+* Extract a slug source (title or name) from content data.
+* Returns null if no suitable string field is found.
+*/
+function getSlugSource(data) {
+	if (typeof data.title === "string" && data.title.length > 0) return data.title;
+	if (typeof data.name === "string" && data.name.length > 0) return data.name;
+	return null;
+}
+/** Default SEO values for content without an explicit SEO row */
+const SEO_DEFAULTS = {
+	title: null,
+	description: null,
+	image: null,
+	canonical: null,
+	noIndex: false
+};
+var ContentUpdateApiError = class extends Error {
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+		this.name = "ContentUpdateApiError";
+	}
+};
+/**
+* Check if a collection has SEO enabled.
+*/
+async function collectionHasSeo(db, collection) {
+	return (await db.selectFrom("_dineway_collections").select("has_seo").where("slug", "=", collection).executeTakeFirst())?.has_seo === 1;
+}
+/**
+* Hydrate SEO data on a single content item if the collection has SEO enabled.
+*/
+async function hydrateSeo(db, collection, item, hasSeo) {
+	if (!hasSeo) return;
+	item.seo = await new SeoRepository(db).get(collection, item.id);
+}
+/**
+* Hydrate SEO data on multiple content items using a single batch query.
+*/
+async function hydrateSeoMany(db, collection, items, hasSeo) {
+	if (!hasSeo || items.length === 0) return;
+	const seoMap = await new SeoRepository(db).getMany(collection, items.map((i) => i.id));
+	for (const item of items) item.seo = seoMap.get(item.id) ?? { ...SEO_DEFAULTS };
+}
+async function hydrateBylines(db, collection, item) {
+	const bylineRepo = new BylineRepository(db);
+	const bylines = await bylineRepo.getContentBylines(collection, item.id);
+	if (bylines.length > 0) {
+		item.bylines = bylines.map((c) => ({
+			...c,
+			source: "explicit"
+		}));
+		item.byline = bylines[0]?.byline ?? null;
+		return;
+	}
+	if (item.primaryBylineId) item.primaryBylineId = null;
+	if (item.authorId) {
+		const fallback = await bylineRepo.findByUserId(item.authorId);
+		if (fallback) {
+			item.bylines = [{
+				byline: fallback,
+				sortOrder: 0,
+				roleLabel: null,
+				source: "inferred"
+			}];
+			item.byline = fallback;
+			return;
+		}
+	}
+	item.bylines = [];
+	item.byline = null;
+}
+/**
+* Batch-hydrate bylines for multiple items using two bulk queries instead of N+1.
+*/
+async function hydrateBylinesMany(db, collection, items) {
+	if (items.length === 0) return;
+	const bylineRepo = new BylineRepository(db);
+	const contentIds = items.map((i) => i.id);
+	const bylinesMap = await bylineRepo.getContentBylinesMany(collection, contentIds);
+	const fallbackAuthorIds = [];
+	for (const item of items) if (!bylinesMap.has(item.id) && item.authorId) fallbackAuthorIds.push(item.authorId);
+	const uniqueAuthorIds = [...new Set(fallbackAuthorIds)];
+	const authorBylineMap = await bylineRepo.findByUserIds(uniqueAuthorIds);
+	for (const item of items) {
+		const explicit = bylinesMap.get(item.id);
+		if (explicit && explicit.length > 0) {
+			item.bylines = explicit.map((c) => ({
+				...c,
+				source: "explicit"
+			}));
+			item.byline = explicit[0]?.byline ?? null;
+			continue;
+		}
+		if (item.primaryBylineId) item.primaryBylineId = null;
+		if (item.authorId) {
+			const fallback = authorBylineMap.get(item.authorId);
+			if (fallback) {
+				item.bylines = [{
+					byline: fallback,
+					sortOrder: 0,
+					roleLabel: null,
+					source: "inferred"
+				}];
+				item.byline = fallback;
+				continue;
+			}
+		}
+		item.bylines = [];
+		item.byline = null;
+	}
+}
+/**
+* Resolve an identifier (ID or slug) to a real content ID.
+* Returns the ID if found, null if not found.
+* When locale is provided, slug lookups are scoped to that locale.
+*/
+async function resolveId(repo, collection, identifier, locale) {
+	return (await repo.findByIdOrSlug(collection, identifier, locale))?.id ?? null;
+}
+/**
+* Resolve an identifier (ID or slug) to a real content ID,
+* including trashed (soft-deleted) items.
+*/
+async function resolveIdIncludingTrashed(repo, collection, identifier, locale) {
+	return (await repo.findByIdOrSlugIncludingTrashed(collection, identifier, locale))?.id ?? null;
+}
+/**
+* Create content list handler
+*/
+async function handleContentList(db, collection, params) {
+	try {
+		const repo = new ContentRepository(db);
+		const where = {};
+		if (params.status) where.status = params.status;
+		if (params.locale) where.locale = params.locale;
+		const result = await repo.findMany(collection, {
+			cursor: params.cursor,
+			limit: params.limit || 50,
+			where: Object.keys(where).length > 0 ? where : void 0,
+			orderBy: params.orderBy ? {
+				field: params.orderBy,
+				direction: params.order || "desc"
+			} : void 0
+		});
+		const hasSeo = await collectionHasSeo(db, collection);
+		await hydrateSeoMany(db, collection, result.items, hasSeo);
+		await hydrateBylinesMany(db, collection, result.items);
+		return {
+			success: true,
+			data: {
+				items: result.items,
+				nextCursor: result.nextCursor
+			}
+		};
+	} catch (error) {
+		console.error("Content list error:", error);
+		return {
+			success: false,
+			error: {
+				code: "CONTENT_LIST_ERROR",
+				message: "Failed to list content"
+			}
+		};
+	}
+}
+/**
+* Get single content item
+*/
+async function handleContentGet(db, collection, id, locale) {
+	try {
+		const item = await new ContentRepository(db).findByIdOrSlug(collection, id, locale);
+		if (!item) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: `Content item not found: ${id}`
+			}
+		};
+		await hydrateSeo(db, collection, item, await collectionHasSeo(db, collection));
+		await hydrateBylines(db, collection, item);
+		return {
+			success: true,
+			data: {
+				item,
+				_rev: encodeRev(item)
+			}
+		};
+	} catch (error) {
+		console.error("Content get error:", error);
+		return {
+			success: false,
+			error: {
+				code: "CONTENT_GET_ERROR",
+				message: "Failed to get content"
+			}
+		};
+	}
+}
+/**
+* Get a content item by id, including trashed items.
+* Used by restore endpoint for ownership checks on soft-deleted items.
+*/
+async function handleContentGetIncludingTrashed(db, collection, id, locale) {
+	try {
+		const item = await new ContentRepository(db).findByIdOrSlugIncludingTrashed(collection, id, locale);
+		if (!item) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: `Content item not found: ${id}`
+			}
+		};
+		await hydrateSeo(db, collection, item, await collectionHasSeo(db, collection));
+		await hydrateBylines(db, collection, item);
+		return {
+			success: true,
+			data: {
+				item,
+				_rev: encodeRev(item)
+			}
+		};
+	} catch (error) {
+		console.error("Content get error:", error);
+		return {
+			success: false,
+			error: {
+				code: "CONTENT_GET_ERROR",
+				message: "Failed to get content"
+			}
+		};
+	}
+}
+/**
+* Create content item.
+*
+* Content + SEO writes are wrapped in a transaction so either both succeed
+* or neither does. If `body.seo` is provided for a non-SEO collection, the
+* API returns a validation error rather than silently dropping it.
+*/
+async function handleContentCreate(db, collection, body) {
+	try {
+		const hasSeo = await collectionHasSeo(db, collection);
+		if (body.seo && !hasSeo) return {
+			success: false,
+			error: {
+				code: "VALIDATION_ERROR",
+				message: `Collection "${collection}" does not have SEO enabled. Remove the seo field or enable SEO on this collection.`
+			}
+		};
+		const item = await withTransaction(db, async (trx) => {
+			const repo = new ContentRepository(trx);
+			const bylineRepo = new BylineRepository(trx);
+			let slug = body.slug;
+			if (!slug) {
+				const slugSource = getSlugSource(body.data);
+				if (slugSource) slug = await repo.generateUniqueSlug(collection, slugSource, body.locale);
+			}
+			const created = await repo.create({
+				type: collection,
+				slug,
+				data: body.data,
+				status: body.status || "draft",
+				authorId: body.authorId,
+				locale: body.locale,
+				translationOf: body.translationOf,
+				createdAt: body.createdAt,
+				publishedAt: body.publishedAt
+			});
+			if (body.bylines !== void 0) {
+				await bylineRepo.setContentBylines(collection, created.id, body.bylines);
+				created.primaryBylineId = body.bylines[0]?.bylineId ?? null;
+			}
+			await hydrateBylines(trx, collection, created);
+			if (body.seo && hasSeo) created.seo = await new SeoRepository(trx).upsert(collection, created.id, body.seo);
+			else if (hasSeo) created.seo = { ...SEO_DEFAULTS };
+			return created;
+		});
+		return {
+			success: true,
+			data: {
+				item,
+				_rev: encodeRev(item)
+			}
+		};
+	} catch (error) {
+		console.error("Content create error:", error);
+		return {
+			success: false,
+			error: {
+				code: "CONTENT_CREATE_ERROR",
+				message: "Failed to create content"
+			}
+		};
+	}
+}
+/**
+* Update content item.
+* If `_rev` is provided, validates it against the current version before writing.
+* No `_rev` = blind write (backwards-compatible for admin UI).
+*
+* Content + SEO writes are wrapped in a transaction for atomicity.
+*/
+async function handleContentUpdate(db, collection, id, body) {
+	try {
+		const hasSeo = await collectionHasSeo(db, collection);
+		if (body.seo && !hasSeo) return {
+			success: false,
+			error: {
+				code: "VALIDATION_ERROR",
+				message: `Collection "${collection}" does not have SEO enabled. Remove the seo field or enable SEO on this collection.`
+			}
+		};
+		const resolvedId = await resolveId(new ContentRepository(db), collection, id) ?? id;
+		const item = await withTransaction(db, async (trx) => {
+			const trxRepo = new ContentRepository(trx);
+			const bylineRepo = new BylineRepository(trx);
+			const existing = body._rev || body.slug ? await trxRepo.findById(collection, resolvedId) : null;
+			if (body._rev) {
+				if (!existing) throw new ContentUpdateApiError("NOT_FOUND", `Content item not found: ${id}`);
+				const revCheck = validateRev(body._rev, existing);
+				if (!revCheck.valid) throw new ContentUpdateApiError("CONFLICT", revCheck.message);
+			}
+			let oldSlug;
+			if (body.slug && existing?.slug && existing.slug !== body.slug) oldSlug = existing.slug;
+			const updated = await trxRepo.update(collection, resolvedId, {
+				data: body.data,
+				slug: body.slug,
+				status: body.status,
+				authorId: body.authorId,
+				publishedAt: body.publishedAt
+			});
+			if (body.bylines !== void 0) {
+				await bylineRepo.setContentBylines(collection, resolvedId, body.bylines);
+				updated.primaryBylineId = body.bylines[0]?.bylineId ?? null;
+			}
+			if (oldSlug && body.slug) {
+				const collectionRow = await trx.selectFrom("_dineway_collections").select("url_pattern").where("slug", "=", collection).executeTakeFirst();
+				await new RedirectRepository(trx).createAutoRedirect(collection, oldSlug, body.slug, resolvedId, collectionRow?.url_pattern ?? null);
+				invalidateRedirectCache();
+			}
+			if (isI18nEnabled() && body.data && updated.translationGroup) await syncNonTranslatableFields(trx, collection, updated.id, updated.translationGroup, body.data);
+			if (body.seo && hasSeo) updated.seo = await new SeoRepository(trx).upsert(collection, resolvedId, body.seo);
+			else if (hasSeo) updated.seo = await new SeoRepository(trx).get(collection, resolvedId);
+			await hydrateBylines(trx, collection, updated);
+			return updated;
+		});
+		return {
+			success: true,
+			data: {
+				item,
+				_rev: encodeRev(item)
+			}
+		};
+	} catch (error) {
+		if (error instanceof ContentUpdateApiError) return {
+			success: false,
+			error: {
+				code: error.code,
+				message: error.message
+			}
+		};
+		console.error("Content update error:", error);
+		return {
+			success: false,
+			error: {
+				code: "CONTENT_UPDATE_ERROR",
+				message: "Failed to update content"
+			}
+		};
+	}
+}
+/**
+* Duplicate content item.
+*
+* Only copies SEO data if the collection has SEO enabled.
+* Always returns consistent `seo` shape for SEO-enabled collections.
+*/
+async function handleContentDuplicate(db, collection, id, authorId) {
+	try {
+		const hasSeo = await collectionHasSeo(db, collection);
+		return {
+			success: true,
+			data: { item: await withTransaction(db, async (trx) => {
+				const repo = new ContentRepository(trx);
+				const bylineRepo = new BylineRepository(trx);
+				const resolvedId = await resolveId(repo, collection, id) ?? id;
+				const dup = await repo.duplicate(collection, resolvedId, authorId);
+				const existingBylines = await bylineRepo.getContentBylines(collection, resolvedId);
+				if (existingBylines.length > 0) await bylineRepo.setContentBylines(collection, dup.id, existingBylines.map((entry) => ({
+					bylineId: entry.byline.id,
+					roleLabel: entry.roleLabel
+				})));
+				if (hasSeo) {
+					const seoRepo = new SeoRepository(trx);
+					await seoRepo.copyForDuplicate(collection, resolvedId, dup.id);
+					dup.seo = await seoRepo.get(collection, dup.id);
+				}
+				await hydrateBylines(trx, collection, dup);
+				return dup;
+			}) }
+		};
+	} catch (err) {
+		if (err instanceof DinewayValidationError) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: err.message
+			}
+		};
+		console.error("Content duplicate error:", err);
+		return {
+			success: false,
+			error: {
+				code: "CONTENT_DUPLICATE_ERROR",
+				message: "Failed to duplicate content"
+			}
+		};
+	}
+}
+/**
+* Delete content item (soft delete - moves to trash)
+*/
+async function handleContentDelete(db, collection, id) {
+	try {
+		if (!await withTransaction(db, async (trx) => {
+			const repo = new ContentRepository(trx);
+			const resolvedId = await resolveId(repo, collection, id) ?? id;
+			return repo.delete(collection, resolvedId);
+		})) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: `Content item not found: ${id}`
+			}
+		};
+		return {
+			success: true,
+			data: { deleted: true }
+		};
+	} catch (error) {
+		console.error("Content delete error:", error);
+		return {
+			success: false,
+			error: {
+				code: "CONTENT_DELETE_ERROR",
+				message: "Failed to delete content"
+			}
+		};
+	}
+}
+/**
+* Restore content item from trash
+*/
+async function handleContentRestore(db, collection, id) {
+	try {
+		if (!await withTransaction(db, async (trx) => {
+			const repo = new ContentRepository(trx);
+			const resolvedId = await resolveIdIncludingTrashed(repo, collection, id) ?? id;
+			return repo.restore(collection, resolvedId);
+		})) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: `Trashed content item not found: ${id}`
+			}
+		};
+		return {
+			success: true,
+			data: { restored: true }
+		};
+	} catch (error) {
+		console.error("Content restore error:", error);
+		return {
+			success: false,
+			error: {
+				code: "CONTENT_RESTORE_ERROR",
+				message: "Failed to restore content"
+			}
+		};
+	}
+}
+/**
+* Permanently delete content item (cannot be undone).
+* Also cleans up associated SEO data.
+*/
+async function handleContentPermanentDelete(db, collection, id) {
+	try {
+		const resolvedId = await resolveIdIncludingTrashed(new ContentRepository(db), collection, id) ?? id;
+		if (!await withTransaction(db, async (trx) => {
+			const wasDeleted = await new ContentRepository(trx).permanentDelete(collection, resolvedId);
+			if (wasDeleted) {
+				await new SeoRepository(trx).delete(collection, resolvedId);
+				await new CommentRepository(trx).deleteByContent(collection, resolvedId);
+				await new RevisionRepository(trx).deleteByEntry(collection, resolvedId);
+			}
+			return wasDeleted;
+		})) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: `Content item not found: ${id}`
+			}
+		};
+		return {
+			success: true,
+			data: { deleted: true }
+		};
+	} catch (error) {
+		console.error("Content permanent delete error:", error);
+		return {
+			success: false,
+			error: {
+				code: "CONTENT_DELETE_ERROR",
+				message: "Failed to permanently delete content"
+			}
+		};
+	}
+}
+/**
+* List trashed content items
+*/
+async function handleContentListTrashed(db, collection, options = {}) {
+	try {
+		const result = await new ContentRepository(db).findTrashed(collection, {
+			limit: options.limit,
+			cursor: options.cursor
+		});
+		return {
+			success: true,
+			data: {
+				items: result.items.map((item) => ({
+					id: item.id,
+					type: item.type,
+					slug: item.slug,
+					status: item.status,
+					data: item.data,
+					authorId: item.authorId,
+					createdAt: item.createdAt,
+					updatedAt: item.updatedAt,
+					publishedAt: item.publishedAt,
+					deletedAt: item.deletedAt
+				})),
+				nextCursor: result.nextCursor
+			}
+		};
+	} catch (error) {
+		console.error("Content list trashed error:", error);
+		return {
+			success: false,
+			error: {
+				code: "CONTENT_LIST_ERROR",
+				message: "Failed to list trashed content"
+			}
+		};
+	}
+}
+/**
+* Count trashed content items
+*/
+async function handleContentCountTrashed(db, collection) {
+	try {
+		return {
+			success: true,
+			data: { count: await new ContentRepository(db).countTrashed(collection) }
+		};
+	} catch (error) {
+		console.error("Content count trashed error:", error);
+		return {
+			success: false,
+			error: {
+				code: "CONTENT_COUNT_ERROR",
+				message: "Failed to count trashed content"
+			}
+		};
+	}
+}
+/**
+* Schedule content for future publishing
+*/
+async function handleContentSchedule(db, collection, id, scheduledAt) {
+	try {
+		const item = await withTransaction(db, async (trx) => {
+			const repo = new ContentRepository(trx);
+			const resolvedId = await resolveId(repo, collection, id) ?? id;
+			return repo.schedule(collection, resolvedId, scheduledAt);
+		});
+		await hydrateSeo(db, collection, item, await collectionHasSeo(db, collection));
+		return {
+			success: true,
+			data: { item }
+		};
+	} catch (error) {
+		if (error instanceof DinewayValidationError) return {
+			success: false,
+			error: {
+				code: "VALIDATION_ERROR",
+				message: error.message
+			}
+		};
+		console.error("Content schedule error:", error);
+		return {
+			success: false,
+			error: {
+				code: "CONTENT_SCHEDULE_ERROR",
+				message: "Failed to schedule content"
+			}
+		};
+	}
+}
+/**
+* Unschedule content (revert to draft)
+*/
+async function handleContentUnschedule(db, collection, id) {
+	try {
+		const item = await withTransaction(db, async (trx) => {
+			const repo = new ContentRepository(trx);
+			const resolvedId = await resolveId(repo, collection, id) ?? id;
+			return repo.unschedule(collection, resolvedId);
+		});
+		await hydrateSeo(db, collection, item, await collectionHasSeo(db, collection));
+		return {
+			success: true,
+			data: { item }
+		};
+	} catch (error) {
+		if (error instanceof DinewayValidationError) return {
+			success: false,
+			error: {
+				code: "VALIDATION_ERROR",
+				message: error.message
+			}
+		};
+		console.error("Content unschedule error:", error);
+		return {
+			success: false,
+			error: {
+				code: "CONTENT_UNSCHEDULE_ERROR",
+				message: "Failed to unschedule content"
+			}
+		};
+	}
+}
+/**
+* Publish content immediately.
+*
+* Wrapped in a transaction because publish performs multiple writes
+* (syncDataColumns, slug sync, status/revision update) that must
+* be atomic to prevent FTS shadow table corruption on crash.
+*/
+async function handleContentPublish(db, collection, id, options = {}) {
+	try {
+		const item = await withTransaction(db, async (trx) => {
+			const repo = new ContentRepository(trx);
+			const resolvedId = await resolveId(repo, collection, id) ?? id;
+			return repo.publish(collection, resolvedId, options.publishedAt);
+		});
+		await hydrateSeo(db, collection, item, await collectionHasSeo(db, collection));
+		return {
+			success: true,
+			data: { item }
+		};
+	} catch (error) {
+		if (error instanceof DinewayValidationError) return {
+			success: false,
+			error: {
+				code: "VALIDATION_ERROR",
+				message: error.message
+			}
+		};
+		console.error("Content publish error:", error);
+		return {
+			success: false,
+			error: {
+				code: "CONTENT_PUBLISH_ERROR",
+				message: "Failed to publish content"
+			}
+		};
+	}
+}
+/**
+* Unpublish content (revert to draft).
+*
+* Wrapped in a transaction — unpublish may create a draft revision
+* from the live version then update the status, which is multi-step.
+*/
+async function handleContentUnpublish(db, collection, id) {
+	try {
+		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);
+		});
+		await hydrateSeo(db, collection, item, await collectionHasSeo(db, collection));
+		return {
+			success: true,
+			data: { item }
+		};
+	} catch (error) {
+		if (error instanceof DinewayValidationError) return {
+			success: false,
+			error: {
+				code: "VALIDATION_ERROR",
+				message: error.message
+			}
+		};
+		console.error("Content unpublish error:", error);
+		return {
+			success: false,
+			error: {
+				code: "CONTENT_UNPUBLISH_ERROR",
+				message: "Failed to unpublish content"
+			}
+		};
+	}
+}
+/**
+* Count scheduled content items
+*/
+async function handleContentCountScheduled(db, collection) {
+	try {
+		return {
+			success: true,
+			data: { count: await new ContentRepository(db).countScheduled(collection) }
+		};
+	} catch (error) {
+		console.error("Content count scheduled error:", error);
+		return {
+			success: false,
+			error: {
+				code: "CONTENT_COUNT_ERROR",
+				message: "Failed to count scheduled content"
+			}
+		};
+	}
+}
+/**
+* Discard draft changes (revert to live version)
+*/
+async function handleContentDiscardDraft(db, collection, id) {
+	try {
+		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);
+		});
+		await hydrateSeo(db, collection, item, await collectionHasSeo(db, collection));
+		return {
+			success: true,
+			data: { item }
+		};
+	} catch (error) {
+		if (error instanceof DinewayValidationError) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: error.message
+			}
+		};
+		console.error("Content discard draft error:", error);
+		return {
+			success: false,
+			error: {
+				code: "CONTENT_DISCARD_DRAFT_ERROR",
+				message: "Failed to discard draft"
+			}
+		};
+	}
+}
+/**
+* Compare live and draft revisions
+*/
+async function handleContentCompare(db, collection, id) {
+	try {
+		const entry = await new ContentRepository(db).findByIdOrSlug(collection, id);
+		if (!entry) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: `Content item not found: ${id}`
+			}
+		};
+		const revisionRepo = new RevisionRepository(db);
+		const live = entry.liveRevisionId ? await revisionRepo.findById(entry.liveRevisionId) : null;
+		const draft = entry.draftRevisionId ? await revisionRepo.findById(entry.draftRevisionId) : null;
+		return {
+			success: true,
+			data: {
+				hasChanges: entry.draftRevisionId !== null && entry.draftRevisionId !== entry.liveRevisionId,
+				live: live?.data ?? null,
+				draft: draft?.data ?? null
+			}
+		};
+	} catch (error) {
+		console.error("Content compare error:", error);
+		return {
+			success: false,
+			error: {
+				code: "CONTENT_COMPARE_ERROR",
+				message: "Failed to compare revisions"
+			}
+		};
+	}
+}
+/**
+* Get all translations for a content item.
+* Returns the item's translation group members with locale and status info.
+*/
+async function handleContentTranslations(db, collection, id) {
+	try {
+		const repo = new ContentRepository(db);
+		const item = await repo.findByIdOrSlug(collection, id);
+		if (!item) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: `Content item not found: ${id}`
+			}
+		};
+		if (!item.translationGroup) return {
+			success: true,
+			data: {
+				translationGroup: item.id,
+				translations: [{
+					id: item.id,
+					locale: item.locale,
+					slug: item.slug,
+					status: item.status,
+					updatedAt: item.updatedAt
+				}]
+			}
+		};
+		const translations = await repo.findTranslations(collection, item.translationGroup);
+		return {
+			success: true,
+			data: {
+				translationGroup: item.translationGroup,
+				translations: translations.map((t) => ({
+					id: t.id,
+					locale: t.locale,
+					slug: t.slug,
+					status: t.status,
+					updatedAt: t.updatedAt
+				}))
+			}
+		};
+	} catch (error) {
+		if (error instanceof Error) console.error("Content translations error:", error);
+		return {
+			success: false,
+			error: {
+				code: "CONTENT_TRANSLATIONS_ERROR",
+				message: "Failed to get translations"
+			}
+		};
+	}
+}
+/**
+* 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, collectionSlug, updatedItemId, translationGroup, data) {
+	const collection = await trx.selectFrom("_dineway_collections").select("id").where("slug", "=", collectionSlug).executeTakeFirst();
+	if (!collection) return;
+	const nonTranslatableSlugs = (await trx.selectFrom("_dineway_fields").select("slug").where("collection_id", "=", collection.id).where("translatable", "=", 0).execute()).map((f) => f.slug);
+	if (nonTranslatableSlugs.length === 0) return;
+	const syncData = {};
+	for (const slug of nonTranslatableSlugs) if (slug in data) syncData[slug] = data[slug];
+	if (Object.keys(syncData).length === 0) return;
+	validateIdentifier(collectionSlug, "collection slug");
+	const tableName = `ec_${collectionSlug}`;
+	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);
+}
+
+//#endregion
+//#region src/api/handlers/manifest.ts
+/**
+* Manifest generation handlers
+*/
+/** Pattern to add spaces before capital letters */
+const CAMEL_CASE_PATTERN = /([A-Z])/g;
+const FIRST_CHAR_PATTERN = /^./;
+/**
+* Generate admin manifest from collections
+*/
+async function generateManifest(collections, plugins = {}) {
+	const manifestCollections = {};
+	for (const [name, definition] of Object.entries(collections)) {
+		const fields = extractFieldDescriptors(definition.schema);
+		manifestCollections[name] = {
+			label: definition.admin.label,
+			labelSingular: definition.admin.labelSingular || definition.admin.label,
+			supports: definition.admin.supports || [],
+			fields
+		};
+	}
+	return {
+		version: VERSION,
+		commit: COMMIT,
+		hash: await hashString(JSON.stringify(manifestCollections)),
+		collections: manifestCollections,
+		plugins
+	};
+}
+/**
+* Extract field descriptors from Zod schema
+* Note: This is a simplified implementation that handles common types
+*/
+function extractFieldDescriptors(schema) {
+	const fields = {};
+	const shape = typeof schema._def?.shape === "function" ? schema._def.shape() : schema.shape || {};
+	for (const [name, fieldSchema] of Object.entries(shape)) fields[name] = extractFieldType(name, fieldSchema);
+	return fields;
+}
+/**
+* Extract field type from Zod schema
+*/
+/** Type guard: check if a value is a non-null object */
+function isObject(value) {
+	return typeof value === "object" && value !== null;
+}
+function extractFieldType(name, schema) {
+	if (!isObject(schema)) return {
+		kind: "string",
+		label: formatLabel(name)
+	};
+	if (schema.isPortableText) return {
+		kind: "portableText",
+		label: formatLabel(name)
+	};
+	if (schema.isImage) return {
+		kind: "image",
+		label: formatLabel(name)
+	};
+	if (schema.isReference) return {
+		kind: "reference",
+		label: formatLabel(name)
+	};
+	const def = isObject(schema._def) ? schema._def : void 0;
+	switch (typeof def?.typeName === "string" ? def.typeName : void 0) {
+		case "ZodString": return {
+			kind: "string",
+			label: formatLabel(name)
+		};
+		case "ZodNumber": return {
+			kind: "number",
+			label: formatLabel(name)
+		};
+		case "ZodBoolean": return {
+			kind: "boolean",
+			label: formatLabel(name)
+		};
+		case "ZodDate": return {
+			kind: "datetime",
+			label: formatLabel(name)
+		};
+		case "ZodEnum": {
+			const values = Array.isArray(def?.values) ? def.values : [];
+			return {
+				kind: "select",
+				label: formatLabel(name),
+				options: values.filter((v) => typeof v === "string").map((v) => ({
+					value: v,
+					label: v.charAt(0).toUpperCase() + v.slice(1)
+				}))
+			};
+		}
+		case "ZodArray": return {
+			kind: "array",
+			label: formatLabel(name)
+		};
+		case "ZodObject": return {
+			kind: "object",
+			label: formatLabel(name)
+		};
+		case "ZodOptional":
+		case "ZodDefault":
+			if (def?.innerType) return extractFieldType(name, def.innerType);
+			return {
+				kind: "string",
+				label: formatLabel(name)
+			};
+		default: return {
+			kind: "string",
+			label: formatLabel(name)
+		};
+	}
+}
+/**
+* Format field name as label
+*/
+function formatLabel(name) {
+	return name.replace(CAMEL_CASE_PATTERN, " $1").replace(FIRST_CHAR_PATTERN, (str) => str.toUpperCase()).trim();
+}
+
+//#endregion
+//#region src/api/handlers/revision.ts
+/**
+* List revisions for a content entry
+*/
+async function handleRevisionList(db, collection, entryId, params = {}) {
+	try {
+		const repo = new RevisionRepository(db);
+		const [items, total] = await Promise.all([repo.findByEntry(collection, entryId, { limit: Math.min(params.limit || 50, 100) }), repo.countByEntry(collection, entryId)]);
+		return {
+			success: true,
+			data: {
+				items,
+				total
+			}
+		};
+	} catch {
+		return {
+			success: false,
+			error: {
+				code: "REVISION_LIST_ERROR",
+				message: "Failed to list revisions"
+			}
+		};
+	}
+}
+/**
+* Get a specific revision
+*/
+async function handleRevisionGet(db, revisionId) {
+	try {
+		const item = await new RevisionRepository(db).findById(revisionId);
+		if (!item) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: `Revision not found: ${revisionId}`
+			}
+		};
+		return {
+			success: true,
+			data: { item }
+		};
+	} catch {
+		return {
+			success: false,
+			error: {
+				code: "REVISION_GET_ERROR",
+				message: "Failed to get revision"
+			}
+		};
+	}
+}
+/**
+* Restore a revision (updates content to this revision's data and creates new revision)
+*/
+async function handleRevisionRestore(db, revisionId, callerUserId) {
+	try {
+		const revisionRepo = new RevisionRepository(db);
+		const revision = await revisionRepo.findById(revisionId);
+		if (!revision) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: `Revision not found: ${revisionId}`
+			}
+		};
+		const { _slug, ...fieldData } = revision.data;
+		const item = await withTransaction(db, async (trx) => {
+			const contentRepo = new ContentRepository(trx);
+			const txRevisionRepo = new RevisionRepository(trx);
+			const restored = await contentRepo.update(revision.collection, revision.entryId, {
+				data: fieldData,
+				slug: typeof _slug === "string" ? _slug : void 0
+			});
+			await txRevisionRepo.create({
+				collection: revision.collection,
+				entryId: revision.entryId,
+				data: revision.data,
+				authorId: callerUserId
+			});
+			return restored;
+		});
+		revisionRepo.pruneOldRevisions(revision.collection, revision.entryId, 50).catch(() => {});
+		return {
+			success: true,
+			data: { item }
+		};
+	} catch {
+		return {
+			success: false,
+			error: {
+				code: "REVISION_RESTORE_ERROR",
+				message: "Failed to restore revision"
+			}
+		};
+	}
+}
+
+//#endregion
+//#region src/api/handlers/media.ts
+/**
+* List media items
+*/
+async function handleMediaList(db, params) {
+	try {
+		const result = await new MediaRepository(db).findMany({
+			cursor: params.cursor,
+			limit: Math.min(params.limit || 50, 100),
+			mimeType: params.mimeType
+		});
+		return {
+			success: true,
+			data: {
+				items: result.items,
+				nextCursor: result.nextCursor
+			}
+		};
+	} catch {
+		return {
+			success: false,
+			error: {
+				code: "MEDIA_LIST_ERROR",
+				message: "Failed to list media"
+			}
+		};
+	}
+}
+/**
+* Get single media item
+*/
+async function handleMediaGet(db, id) {
+	try {
+		const item = await new MediaRepository(db).findById(id);
+		if (!item) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: `Media item not found: ${id}`
+			}
+		};
+		return {
+			success: true,
+			data: { item }
+		};
+	} catch {
+		return {
+			success: false,
+			error: {
+				code: "MEDIA_GET_ERROR",
+				message: "Failed to get media"
+			}
+		};
+	}
+}
+/**
+* Create media item (after file upload)
+*/
+async function handleMediaCreate(db, input) {
+	try {
+		return {
+			success: true,
+			data: { item: await new MediaRepository(db).create(input) }
+		};
+	} catch {
+		return {
+			success: false,
+			error: {
+				code: "MEDIA_CREATE_ERROR",
+				message: "Failed to create media"
+			}
+		};
+	}
+}
+/**
+* Update media metadata
+*/
+async function handleMediaUpdate(db, id, input) {
+	try {
+		const item = await new MediaRepository(db).update(id, input);
+		if (!item) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: `Media item not found: ${id}`
+			}
+		};
+		return {
+			success: true,
+			data: { item }
+		};
+	} catch {
+		return {
+			success: false,
+			error: {
+				code: "MEDIA_UPDATE_ERROR",
+				message: "Failed to update media"
+			}
+		};
+	}
+}
+/**
+* Delete media item
+*/
+async function handleMediaDelete(db, id) {
+	try {
+		if (!await new MediaRepository(db).delete(id)) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: `Media item not found: ${id}`
+			}
+		};
+		return {
+			success: true,
+			data: { deleted: true }
+		};
+	} catch {
+		return {
+			success: false,
+			error: {
+				code: "MEDIA_DELETE_ERROR",
+				message: "Failed to delete media"
+			}
+		};
+	}
+}
+
+//#endregion
+//#region src/api/handlers/schema.ts
+/**
+* List all collections
+*/
+async function handleSchemaCollectionList(db) {
+	try {
+		return {
+			success: true,
+			data: { items: await new SchemaRegistry(db).listCollections() }
+		};
+	} catch {
+		return {
+			success: false,
+			error: {
+				code: "SCHEMA_LIST_ERROR",
+				message: "Failed to list collections"
+			}
+		};
+	}
+}
+/**
+* Get a collection by slug
+*/
+async function handleSchemaCollectionGet(db, slug, options) {
+	try {
+		const registry = new SchemaRegistry(db);
+		if (options?.includeFields) {
+			const item = await registry.getCollectionWithFields(slug);
+			if (!item) return {
+				success: false,
+				error: {
+					code: "NOT_FOUND",
+					message: `Collection not found: ${slug}`
+				}
+			};
+			return {
+				success: true,
+				data: { item }
+			};
+		}
+		const item = await registry.getCollection(slug);
+		if (!item) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: `Collection not found: ${slug}`
+			}
+		};
+		return {
+			success: true,
+			data: { item }
+		};
+	} catch {
+		return {
+			success: false,
+			error: {
+				code: "SCHEMA_GET_ERROR",
+				message: "Failed to get collection"
+			}
+		};
+	}
+}
+/**
+* Create a collection
+*/
+async function handleSchemaCollectionCreate(db, input) {
+	try {
+		return {
+			success: true,
+			data: { item: await new SchemaRegistry(db).createCollection(input) }
+		};
+	} catch (error) {
+		if (error instanceof SchemaError) return {
+			success: false,
+			error: {
+				code: error.code,
+				message: error.message,
+				details: error.details
+			}
+		};
+		console.error("[dineway] Failed to create collection:", error);
+		return {
+			success: false,
+			error: {
+				code: "SCHEMA_CREATE_ERROR",
+				message: "Failed to create collection"
+			}
+		};
+	}
+}
+/**
+* Update a collection
+*/
+async function handleSchemaCollectionUpdate(db, slug, input) {
+	try {
+		return {
+			success: true,
+			data: { item: await new SchemaRegistry(db).updateCollection(slug, input) }
+		};
+	} catch (error) {
+		if (error instanceof SchemaError) return {
+			success: false,
+			error: {
+				code: error.code,
+				message: error.message,
+				details: error.details
+			}
+		};
+		return {
+			success: false,
+			error: {
+				code: "SCHEMA_UPDATE_ERROR",
+				message: "Failed to update collection"
+			}
+		};
+	}
+}
+/**
+* Delete a collection
+*/
+async function handleSchemaCollectionDelete(db, slug, options) {
+	try {
+		await new SchemaRegistry(db).deleteCollection(slug, options);
+		return {
+			success: true,
+			data: { success: true }
+		};
+	} catch (error) {
+		if (error instanceof SchemaError) return {
+			success: false,
+			error: {
+				code: error.code,
+				message: error.message,
+				details: error.details
+			}
+		};
+		return {
+			success: false,
+			error: {
+				code: "SCHEMA_DELETE_ERROR",
+				message: "Failed to delete collection"
+			}
+		};
+	}
+}
+/**
+* List fields for a collection
+*/
+async function handleSchemaFieldList(db, collectionSlug) {
+	try {
+		const registry = new SchemaRegistry(db);
+		const collection = await registry.getCollection(collectionSlug);
+		if (!collection) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: `Collection not found: ${collectionSlug}`
+			}
+		};
+		return {
+			success: true,
+			data: { items: await registry.listFields(collection.id) }
+		};
+	} catch {
+		return {
+			success: false,
+			error: {
+				code: "SCHEMA_FIELD_LIST_ERROR",
+				message: "Failed to list fields"
+			}
+		};
+	}
+}
+/**
+* Get a field
+*/
+async function handleSchemaFieldGet(db, collectionSlug, fieldSlug) {
+	try {
+		const item = await new SchemaRegistry(db).getField(collectionSlug, fieldSlug);
+		if (!item) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: `Field not found: ${fieldSlug} in collection ${collectionSlug}`
+			}
+		};
+		return {
+			success: true,
+			data: { item }
+		};
+	} catch {
+		return {
+			success: false,
+			error: {
+				code: "SCHEMA_FIELD_GET_ERROR",
+				message: "Failed to get field"
+			}
+		};
+	}
+}
+/**
+* Create a field
+*/
+async function handleSchemaFieldCreate(db, collectionSlug, input) {
+	try {
+		return {
+			success: true,
+			data: { item: await new SchemaRegistry(db).createField(collectionSlug, input) }
+		};
+	} catch (error) {
+		if (error instanceof SchemaError) return {
+			success: false,
+			error: {
+				code: error.code,
+				message: error.message,
+				details: error.details
+			}
+		};
+		return {
+			success: false,
+			error: {
+				code: "SCHEMA_FIELD_CREATE_ERROR",
+				message: "Failed to create field"
+			}
+		};
+	}
+}
+/**
+* Update a field
+*/
+async function handleSchemaFieldUpdate(db, collectionSlug, fieldSlug, input) {
+	try {
+		return {
+			success: true,
+			data: { item: await new SchemaRegistry(db).updateField(collectionSlug, fieldSlug, input) }
+		};
+	} catch (error) {
+		if (error instanceof SchemaError) return {
+			success: false,
+			error: {
+				code: error.code,
+				message: error.message,
+				details: error.details
+			}
+		};
+		return {
+			success: false,
+			error: {
+				code: "SCHEMA_FIELD_UPDATE_ERROR",
+				message: "Failed to update field"
+			}
+		};
+	}
+}
+/**
+* Delete a field
+*/
+async function handleSchemaFieldDelete(db, collectionSlug, fieldSlug) {
+	try {
+		await new SchemaRegistry(db).deleteField(collectionSlug, fieldSlug);
+		return {
+			success: true,
+			data: { success: true }
+		};
+	} catch (error) {
+		if (error instanceof SchemaError) return {
+			success: false,
+			error: {
+				code: error.code,
+				message: error.message,
+				details: error.details
+			}
+		};
+		return {
+			success: false,
+			error: {
+				code: "SCHEMA_FIELD_DELETE_ERROR",
+				message: "Failed to delete field"
+			}
+		};
+	}
+}
+/**
+* Reorder fields
+*/
+async function handleSchemaFieldReorder(db, collectionSlug, fieldSlugs) {
+	try {
+		await new SchemaRegistry(db).reorderFields(collectionSlug, fieldSlugs);
+		return {
+			success: true,
+			data: { success: true }
+		};
+	} catch (error) {
+		if (error instanceof SchemaError) return {
+			success: false,
+			error: {
+				code: error.code,
+				message: error.message,
+				details: error.details
+			}
+		};
+		return {
+			success: false,
+			error: {
+				code: "SCHEMA_FIELD_REORDER_ERROR",
+				message: "Failed to reorder fields"
+			}
+		};
+	}
+}
+/**
+* List orphaned content tables
+*/
+async function handleOrphanedTableList(db) {
+	try {
+		return {
+			success: true,
+			data: { items: await new SchemaRegistry(db).discoverOrphanedTables() }
+		};
+	} catch (error) {
+		console.error("[dineway] Failed to list orphaned tables:", error);
+		return {
+			success: false,
+			error: {
+				code: "ORPHAN_LIST_ERROR",
+				message: "Failed to list orphaned tables"
+			}
+		};
+	}
+}
+/**
+* Register an orphaned table as a collection
+*/
+async function handleOrphanedTableRegister(db, slug, options) {
+	try {
+		return {
+			success: true,
+			data: { item: await new SchemaRegistry(db).registerOrphanedTable(slug, options) }
+		};
+	} catch (error) {
+		if (error instanceof SchemaError) return {
+			success: false,
+			error: {
+				code: error.code,
+				message: error.message,
+				details: error.details
+			}
+		};
+		return {
+			success: false,
+			error: {
+				code: "ORPHAN_REGISTER_ERROR",
+				message: "Failed to register orphaned table"
+			}
+		};
+	}
+}
+
+//#endregion
+//#region src/plugins/bundle-store.ts
+const VERSION_PATTERN = /^[a-z0-9][a-z0-9._+-]*$/i;
+const MARKETPLACE_BUNDLE_PREFIX = "marketplace";
+const MANIFEST_FILENAME = "manifest.json";
+const BACKEND_FILENAME = "backend.js";
+const ADMIN_FILENAME = "admin.js";
+function validateVersion(version) {
+	if (version.includes("..")) throw new Error("Invalid version format");
+	if (!VERSION_PATTERN.test(version)) throw new Error("Invalid version format");
+}
+function getBundlePrefix(pluginId, version) {
+	validatePluginIdentifier(pluginId, "plugin ID");
+	validateVersion(version);
+	return `${MARKETPLACE_BUNDLE_PREFIX}/${pluginId}/${version}`;
+}
+async function streamToText(stream) {
+	return new Response(stream).text();
+}
+var StoragePluginBundleStore = class {
+	constructor(storage) {
+		this.storage = storage;
+	}
+	async write(pluginId, version, bundle) {
+		const prefix = getBundlePrefix(pluginId, version);
+		await this.storage.upload({
+			key: `${prefix}/${MANIFEST_FILENAME}`,
+			body: new TextEncoder().encode(JSON.stringify(bundle.manifest)),
+			contentType: "application/json"
+		});
+		await this.storage.upload({
+			key: `${prefix}/${BACKEND_FILENAME}`,
+			body: new TextEncoder().encode(bundle.backendCode),
+			contentType: "application/javascript"
+		});
+		if (bundle.adminCode) {
+			await this.storage.upload({
+				key: `${prefix}/${ADMIN_FILENAME}`,
+				body: new TextEncoder().encode(bundle.adminCode),
+				contentType: "application/javascript"
+			});
+			return;
+		}
+		try {
+			await this.storage.delete(`${prefix}/${ADMIN_FILENAME}`);
+		} catch {}
+	}
+	async read(pluginId, version) {
+		const prefix = getBundlePrefix(pluginId, version);
+		try {
+			const manifestResult = await this.storage.download(`${prefix}/${MANIFEST_FILENAME}`);
+			const backendResult = await this.storage.download(`${prefix}/${BACKEND_FILENAME}`);
+			const manifestText = await streamToText(manifestResult.body);
+			const backendCode = await streamToText(backendResult.body);
+			const parsed = JSON.parse(manifestText);
+			const result = pluginManifestSchema.safeParse(parsed);
+			if (!result.success) return null;
+			let adminCode;
+			try {
+				adminCode = await streamToText((await this.storage.download(`${prefix}/${ADMIN_FILENAME}`)).body);
+			} catch {}
+			return {
+				manifest: result.data,
+				backendCode,
+				adminCode
+			};
+		} catch {
+			return null;
+		}
+	}
+	async delete(pluginId, version) {
+		const prefix = getBundlePrefix(pluginId, version);
+		for (const filename of [
+			MANIFEST_FILENAME,
+			BACKEND_FILENAME,
+			ADMIN_FILENAME
+		]) try {
+			await this.storage.delete(`${prefix}/${filename}`);
+		} catch {}
+	}
+};
+function createPluginBundleStore(storage) {
+	return new StoragePluginBundleStore(storage);
+}
+
+//#endregion
+//#region src/plugins/marketplace.ts
+/**
+* MarketplaceClient — HTTP client for the Dineway Plugin Marketplace
+*
+* Used by the install/update/proxy endpoints in Dineway core to communicate
+* with the marketplace service. The marketplace is a distribution channel,
+* not a runtime dependency — bundles are copied to site-local bundle storage
+* at install time.
+*/
+const TRAILING_SLASHES = /\/+$/;
+const LEADING_DOT_SLASH = /^\.\//;
+var MarketplaceError = class extends Error {
+	constructor(message, status, code) {
+		super(message);
+		this.status = status;
+		this.code = code;
+		this.name = "MarketplaceError";
+	}
+};
+var MarketplaceUnavailableError = class extends MarketplaceError {
+	constructor(cause) {
+		super("Plugin marketplace is unavailable", void 0, "MARKETPLACE_UNAVAILABLE");
+		if (cause) this.cause = cause;
+	}
+};
+var MarketplaceClientImpl = class {
+	baseUrl;
+	siteOrigin;
+	constructor(baseUrl, siteOrigin) {
+		this.baseUrl = baseUrl.replace(TRAILING_SLASHES, "");
+		this.siteOrigin = siteOrigin;
+	}
+	async search(query, opts) {
+		const params = new URLSearchParams();
+		if (query) params.set("q", query);
+		if (opts?.category) params.set("category", opts.category);
+		if (opts?.capability) params.set("capability", opts.capability);
+		if (opts?.sort) params.set("sort", opts.sort);
+		if (opts?.cursor) params.set("cursor", opts.cursor);
+		if (opts?.limit) params.set("limit", String(opts.limit));
+		const qs = params.toString();
+		const url = `${this.baseUrl}/api/v1/plugins${qs ? `?${qs}` : ""}`;
+		return await this.fetchJson(url);
+	}
+	async getPlugin(id) {
+		const url = `${this.baseUrl}/api/v1/plugins/${encodeURIComponent(id)}`;
+		return this.fetchJson(url);
+	}
+	async getVersions(id) {
+		const url = `${this.baseUrl}/api/v1/plugins/${encodeURIComponent(id)}/versions`;
+		return (await this.fetchJson(url)).items;
+	}
+	async downloadBundle(id, version) {
+		const bundleUrl = `${this.baseUrl}/api/v1/plugins/${encodeURIComponent(id)}/versions/${encodeURIComponent(version)}/bundle`;
+		const marketplaceOrigin = new URL(this.baseUrl).origin;
+		const maxRedirects = 5;
+		let response;
+		try {
+			let currentUrl = bundleUrl;
+			response = await fetch(currentUrl, { redirect: "manual" });
+			for (let i = 0; i < maxRedirects; i++) {
+				if (response.status < 300 || response.status >= 400) break;
+				const location = response.headers.get("location");
+				if (!location) break;
+				const target = new URL(location, currentUrl);
+				if (target.origin !== marketplaceOrigin) throw new MarketplaceError(`Bundle download redirected to untrusted host: ${target.origin}`, response.status, "BUNDLE_REDIRECT_UNTRUSTED");
+				currentUrl = target.href;
+				response = await fetch(currentUrl, { redirect: "manual" });
+			}
+			if (response.status >= 300 && response.status < 400) throw new MarketplaceError(`Bundle download exceeded maximum redirects (${maxRedirects})`, response.status, "BUNDLE_TOO_MANY_REDIRECTS");
+		} catch (err) {
+			if (err instanceof MarketplaceError) throw err;
+			throw new MarketplaceUnavailableError(err);
+		}
+		if (!response.ok) throw new MarketplaceError(`Failed to download bundle: ${response.status} ${response.statusText}`, response.status, "BUNDLE_DOWNLOAD_FAILED");
+		const tarballBytes = new Uint8Array(await response.arrayBuffer());
+		try {
+			return await extractBundle(tarballBytes);
+		} catch (err) {
+			if (err instanceof MarketplaceError) throw err;
+			throw new MarketplaceError("Failed to extract plugin bundle", void 0, "BUNDLE_EXTRACT_FAILED");
+		}
+	}
+	async reportInstall(id, version) {
+		const siteHash = await generateSiteHash(this.siteOrigin);
+		const url = `${this.baseUrl}/api/v1/plugins/${encodeURIComponent(id)}/installs`;
+		try {
+			await fetch(url, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({
+					siteHash,
+					version
+				})
+			});
+		} catch {}
+	}
+	async searchThemes(query, opts) {
+		const params = new URLSearchParams();
+		if (query) params.set("q", query);
+		if (opts?.keyword) params.set("keyword", opts.keyword);
+		if (opts?.sort) params.set("sort", opts.sort);
+		if (opts?.cursor) params.set("cursor", opts.cursor);
+		if (opts?.limit) params.set("limit", String(opts.limit));
+		const qs = params.toString();
+		const url = `${this.baseUrl}/api/v1/themes${qs ? `?${qs}` : ""}`;
+		return this.fetchJson(url);
+	}
+	async getTheme(id) {
+		const url = `${this.baseUrl}/api/v1/themes/${encodeURIComponent(id)}`;
+		return this.fetchJson(url);
+	}
+	async fetchJson(url) {
+		let response;
+		try {
+			response = await fetch(url, { headers: { Accept: "application/json" } });
+		} catch (err) {
+			throw new MarketplaceUnavailableError(err);
+		}
+		if (!response.ok) {
+			let errorMessage = `Marketplace request failed: ${response.status}`;
+			try {
+				const body = await response.json();
+				if (body.error) errorMessage = body.error;
+			} catch {}
+			throw new MarketplaceError(errorMessage, response.status);
+		}
+		return await response.json();
+	}
+};
+/**
+* Extract manifest + code files from a tarball.
+*
+* The tarball is a gzipped tar archive containing:
+* - manifest.json
+* - backend.js
+* - admin.js (optional)
+*
+* We use a minimal tar parser since we only need to read a few small files.
+*/
+async function extractBundle(tarballBytes) {
+	const decompressedStream = new ReadableStream({ start(controller) {
+		controller.enqueue(tarballBytes);
+		controller.close();
+	} }).pipeThrough(createGzipDecoder());
+	const decompressedBuf = await new Response(decompressedStream).arrayBuffer();
+	const decompressedBytes = new Uint8Array(decompressedBuf);
+	const entries = await unpackTar(new ReadableStream({ start(controller) {
+		controller.enqueue(decompressedBytes);
+		controller.close();
+	} }));
+	const decoder = new TextDecoder();
+	const files = /* @__PURE__ */ new Map();
+	for (const entry of entries) if (entry.data && entry.header.type === "file") {
+		const name = entry.header.name.replace(LEADING_DOT_SLASH, "");
+		files.set(name, decoder.decode(entry.data));
+	}
+	const manifestJson = files.get("manifest.json");
+	const backendCode = files.get("backend.js");
+	if (!manifestJson) throw new MarketplaceError("Invalid bundle: missing manifest.json", void 0, "INVALID_BUNDLE");
+	if (!backendCode) throw new MarketplaceError("Invalid bundle: missing backend.js", void 0, "INVALID_BUNDLE");
+	let manifest;
+	try {
+		const parsed = JSON.parse(manifestJson);
+		const result = pluginManifestSchema.safeParse(parsed);
+		if (!result.success) throw new MarketplaceError("Invalid bundle: manifest.json failed validation", void 0, "INVALID_BUNDLE");
+		manifest = result.data;
+	} catch (err) {
+		if (err instanceof MarketplaceError) throw err;
+		throw new MarketplaceError("Invalid bundle: malformed manifest.json", void 0, "INVALID_BUNDLE");
+	}
+	const hashBuffer = await crypto.subtle.digest("SHA-256", tarballBytes);
+	const hashArray = new Uint8Array(hashBuffer);
+	const checksum = Array.from(hashArray, (b) => b.toString(16).padStart(2, "0")).join("");
+	return {
+		manifest,
+		backendCode,
+		adminCode: files.get("admin.js"),
+		checksum
+	};
+}
+/**
+* Generate a stable non-identifying site hash from the site origin.
+* The same origin always produces the same hash, so the marketplace
+* installs table deduplicates correctly per (plugin_id, site_hash).
+*/
+async function generateSiteHash(siteOrigin) {
+	const seed = siteOrigin ? `dineway-site:${siteOrigin}` : `dineway-anonymous`;
+	try {
+		const hash = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(seed));
+		const arr = new Uint8Array(hash);
+		return Array.from(arr.slice(0, 8), (b) => b.toString(16).padStart(2, "0")).join("");
+	} catch {
+		let h = 2166136261;
+		for (let i = 0; i < seed.length; i++) {
+			h ^= seed.charCodeAt(i);
+			h = Math.imul(h, 16777619);
+		}
+		const h2 = h ^ h >>> 16;
+		return (h >>> 0).toString(16).padStart(8, "0") + (h2 >>> 0).toString(16).padStart(8, "0");
+	}
+}
+/**
+* Create a MarketplaceClient for the given marketplace URL.
+*
+* @param baseUrl - The marketplace API base URL (e.g. "https://marketplace.example.com")
+* @param siteOrigin - The origin of the Dineway site (e.g. "https://myblog.example.com").
+*   Used to generate a stable, non-identifying site hash for install deduplication.
+*/
+function createMarketplaceClient(baseUrl, siteOrigin) {
+	return new MarketplaceClientImpl(baseUrl, siteOrigin);
+}
+
+//#endregion
+//#region src/api/handlers/marketplace.ts
+function getClient(marketplaceUrl, siteOrigin) {
+	if (!marketplaceUrl) return null;
+	return createMarketplaceClient(marketplaceUrl, siteOrigin);
+}
+function diffCapabilities(oldCaps, newCaps) {
+	const oldSet = new Set(oldCaps);
+	const newSet = new Set(newCaps);
+	return {
+		added: newCaps.filter((c) => !oldSet.has(c)),
+		removed: oldCaps.filter((c) => !newSet.has(c))
+	};
+}
+/**
+* Diff route visibility between two manifests.
+* Returns routes that changed from private to public (newly exposed).
+*/
+function diffRouteVisibility(oldManifest, newManifest) {
+	const oldPublicRoutes = /* @__PURE__ */ new Set();
+	if (oldManifest) for (const entry of oldManifest.routes) {
+		const normalized = normalizeManifestRoute(entry);
+		if (normalized.public === true) oldPublicRoutes.add(normalized.name);
+	}
+	const newlyPublic = [];
+	for (const entry of newManifest.routes) {
+		const normalized = normalizeManifestRoute(entry);
+		if (normalized.public === true && !oldPublicRoutes.has(normalized.name)) newlyPublic.push(normalized.name);
+	}
+	return { newlyPublic };
+}
+async function resolveVersionMetadata(client, pluginId, pluginDetail, version) {
+	if (pluginDetail.latestVersion?.version === version) return {
+		version: pluginDetail.latestVersion.version,
+		minDinewayVersion: pluginDetail.latestVersion.minDinewayVersion,
+		bundleSize: pluginDetail.latestVersion.bundleSize,
+		checksum: pluginDetail.latestVersion.checksum,
+		changelog: pluginDetail.latestVersion.changelog,
+		capabilities: pluginDetail.latestVersion.capabilities,
+		status: pluginDetail.latestVersion.status,
+		auditVerdict: pluginDetail.latestVersion.audit?.verdict ?? null,
+		imageAuditVerdict: pluginDetail.latestVersion.imageAudit?.verdict ?? null,
+		publishedAt: pluginDetail.latestVersion.publishedAt
+	};
+	return (await client.getVersions(pluginId)).find((v) => v.version === version) ?? null;
+}
+function validateBundleIdentity(bundle, pluginId, version) {
+	if (bundle.manifest.id !== pluginId) return {
+		success: false,
+		error: {
+			code: "MANIFEST_MISMATCH",
+			message: `Bundle manifest ID (${bundle.manifest.id}) does not match requested plugin (${pluginId})`
+		}
+	};
+	if (bundle.manifest.version !== version) return {
+		success: false,
+		error: {
+			code: "MANIFEST_VERSION_MISMATCH",
+			message: `Bundle manifest version (${bundle.manifest.version}) does not match requested version (${version})`
+		}
+	};
+	return null;
+}
+async function preflightSandboxBundle(bundle, sandboxRunner) {
+	await (await sandboxRunner.load(bundle.manifest, bundle.backendCode)).terminate();
+}
+function buildInstallPreview(pluginId, pluginDetail, versionMetadata) {
+	return {
+		pluginId,
+		name: pluginDetail.name,
+		description: pluginDetail.description,
+		authorName: pluginDetail.author.name,
+		version: versionMetadata.version,
+		minDinewayVersion: versionMetadata.minDinewayVersion,
+		bundleSize: versionMetadata.bundleSize,
+		checksum: versionMetadata.checksum,
+		changelog: versionMetadata.changelog,
+		capabilities: versionMetadata.capabilities,
+		status: versionMetadata.status,
+		auditVerdict: versionMetadata.auditVerdict,
+		imageAuditVerdict: versionMetadata.imageAuditVerdict,
+		publishedAt: versionMetadata.publishedAt
+	};
+}
+async function handleMarketplaceInstallPreview(marketplaceUrl, pluginId, opts) {
+	const client = getClient(marketplaceUrl, opts.siteOrigin);
+	if (!client) return {
+		success: false,
+		error: {
+			code: "MARKETPLACE_NOT_CONFIGURED",
+			message: "Marketplace is not configured"
+		}
+	};
+	try {
+		const pluginDetail = await client.getPlugin(pluginId);
+		const versionMetadata = await resolveVersionMetadata(client, pluginId, pluginDetail, opts.version);
+		if (!versionMetadata) return {
+			success: false,
+			error: {
+				code: "NO_VERSION",
+				message: `Version ${opts.version} was not found for plugin ${pluginId}`
+			}
+		};
+		if (versionMetadata.auditVerdict === "fail" || versionMetadata.auditVerdict === "warn") return {
+			success: false,
+			error: {
+				code: "AUDIT_FAILED",
+				message: versionMetadata.auditVerdict === "fail" ? "Plugin failed security audit and cannot be installed" : "Plugin audit was inconclusive and cannot be installed until reviewed"
+			}
+		};
+		return {
+			success: true,
+			data: buildInstallPreview(pluginId, pluginDetail, versionMetadata)
+		};
+	} catch (err) {
+		if (err instanceof MarketplaceUnavailableError) return {
+			success: false,
+			error: {
+				code: "MARKETPLACE_UNAVAILABLE",
+				message: "Marketplace is unavailable"
+			}
+		};
+		if (err instanceof MarketplaceError) return {
+			success: false,
+			error: {
+				code: err.code ?? "MARKETPLACE_ERROR",
+				message: err.message
+			}
+		};
+		console.error("Failed to preview marketplace plugin install:", err);
+		return {
+			success: false,
+			error: {
+				code: "INSTALL_FAILED",
+				message: "Failed to prepare plugin install preview"
+			}
+		};
+	}
+}
+async function handleMarketplaceUpdatePreview(db, storage, marketplaceUrl, pluginId, opts) {
+	const client = getClient(marketplaceUrl);
+	if (!client) return {
+		success: false,
+		error: {
+			code: "MARKETPLACE_NOT_CONFIGURED",
+			message: "Marketplace is not configured"
+		}
+	};
+	if (!storage) return {
+		success: false,
+		error: {
+			code: "STORAGE_NOT_CONFIGURED",
+			message: "Storage is required"
+		}
+	};
+	try {
+		const existing = await new PluginStateRepository(db).get(pluginId);
+		if (!existing || existing.source !== "marketplace") return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: `No marketplace plugin found: ${pluginId}`
+			}
+		};
+		const oldVersion = existing.marketplaceVersion ?? existing.version;
+		if (opts.version === oldVersion) return {
+			success: false,
+			error: {
+				code: "ALREADY_UP_TO_DATE",
+				message: "Plugin is already up to date"
+			}
+		};
+		const pluginDetail = await client.getPlugin(pluginId);
+		const versionMetadata = await resolveVersionMetadata(client, pluginId, pluginDetail, opts.version);
+		if (!versionMetadata) return {
+			success: false,
+			error: {
+				code: "NO_VERSION",
+				message: `Version ${opts.version} was not found for plugin ${pluginId}`
+			}
+		};
+		const bundle = await client.downloadBundle(pluginId, opts.version);
+		if (versionMetadata.checksum && bundle.checksum !== versionMetadata.checksum) return {
+			success: false,
+			error: {
+				code: "CHECKSUM_MISMATCH",
+				message: "Bundle checksum does not match marketplace record. Download may be corrupted."
+			}
+		};
+		const bundleIdentityError = validateBundleIdentity(bundle, pluginId, opts.version);
+		if (bundleIdentityError) return bundleIdentityError;
+		const oldBundle = await createPluginBundleStore(storage).read(pluginId, oldVersion);
+		const capabilityChanges = diffCapabilities(oldBundle?.manifest.capabilities ?? [], bundle.manifest.capabilities);
+		const routeVisibilityChanges = diffRouteVisibility(oldBundle?.manifest, bundle.manifest);
+		return {
+			success: true,
+			data: {
+				...buildInstallPreview(pluginId, pluginDetail, versionMetadata),
+				oldVersion,
+				capabilityChanges,
+				routeVisibilityChanges
+			}
+		};
+	} catch (err) {
+		if (err instanceof MarketplaceUnavailableError) return {
+			success: false,
+			error: {
+				code: "MARKETPLACE_UNAVAILABLE",
+				message: "Marketplace is unavailable"
+			}
+		};
+		if (err instanceof MarketplaceError) return {
+			success: false,
+			error: {
+				code: err.code ?? "MARKETPLACE_ERROR",
+				message: err.message
+			}
+		};
+		console.error("Failed to preview marketplace plugin update:", err);
+		return {
+			success: false,
+			error: {
+				code: "UPDATE_FAILED",
+				message: "Failed to prepare plugin update preview"
+			}
+		};
+	}
+}
+async function handleMarketplaceInstall(db, storage, sandboxRunner, marketplaceUrl, pluginId, opts) {
+	const client = getClient(marketplaceUrl, opts?.siteOrigin);
+	if (!client) return {
+		success: false,
+		error: {
+			code: "MARKETPLACE_NOT_CONFIGURED",
+			message: "Marketplace is not configured"
+		}
+	};
+	if (!storage) return {
+		success: false,
+		error: {
+			code: "STORAGE_NOT_CONFIGURED",
+			message: "Storage is required for marketplace plugin installation"
+		}
+	};
+	const bundleStore = createPluginBundleStore(storage);
+	if (!sandboxRunner || !sandboxRunner.isAvailable()) return {
+		success: false,
+		error: {
+			code: "SANDBOX_NOT_AVAILABLE",
+			message: "Sandbox runner is required for marketplace plugins"
+		}
+	};
+	try {
+		const stateRepo = new PluginStateRepository(db);
+		const existing = await stateRepo.get(pluginId);
+		if (existing && existing.source === "marketplace") return {
+			success: false,
+			error: {
+				code: "ALREADY_INSTALLED",
+				message: `Plugin ${pluginId} is already installed`
+			}
+		};
+		if (opts?.configuredPluginIds?.has(pluginId)) return {
+			success: false,
+			error: {
+				code: "PLUGIN_ID_CONFLICT",
+				message: `Cannot install marketplace plugin "${pluginId}" — a configured plugin with the same ID already exists`
+			}
+		};
+		const pluginDetail = await client.getPlugin(pluginId);
+		const version = opts?.version ?? pluginDetail.latestVersion?.version;
+		if (!version) return {
+			success: false,
+			error: {
+				code: "NO_VERSION",
+				message: `No published versions found for plugin ${pluginId}`
+			}
+		};
+		const versionMetadata = await resolveVersionMetadata(client, pluginId, pluginDetail, version);
+		if (!versionMetadata) return {
+			success: false,
+			error: {
+				code: "NO_VERSION",
+				message: `Version ${version} was not found for plugin ${pluginId}`
+			}
+		};
+		if (versionMetadata.auditVerdict === "fail" || versionMetadata.auditVerdict === "warn") return {
+			success: false,
+			error: {
+				code: "AUDIT_FAILED",
+				message: versionMetadata.auditVerdict === "fail" ? "Plugin failed security audit and cannot be installed" : "Plugin audit was inconclusive and cannot be installed until reviewed"
+			}
+		};
+		const bundle = await client.downloadBundle(pluginId, version);
+		if (versionMetadata.checksum && bundle.checksum !== versionMetadata.checksum) return {
+			success: false,
+			error: {
+				code: "CHECKSUM_MISMATCH",
+				message: "Bundle checksum does not match marketplace record. Download may be corrupted."
+			}
+		};
+		const bundleIdentityError = validateBundleIdentity(bundle, pluginId, version);
+		if (bundleIdentityError) return bundleIdentityError;
+		await preflightSandboxBundle(bundle, sandboxRunner);
+		await bundleStore.write(pluginId, version, bundle);
+		await stateRepo.upsert(pluginId, version, "active", {
+			source: "marketplace",
+			marketplaceVersion: version,
+			displayName: pluginDetail.name,
+			description: pluginDetail.description ?? void 0
+		});
+		client.reportInstall(pluginId, version).catch(() => {});
+		return {
+			success: true,
+			data: {
+				pluginId,
+				version,
+				capabilities: bundle.manifest.capabilities
+			}
+		};
+	} catch (err) {
+		if (err instanceof MarketplaceUnavailableError) return {
+			success: false,
+			error: {
+				code: "MARKETPLACE_UNAVAILABLE",
+				message: "Plugin marketplace is currently unavailable"
+			}
+		};
+		if (err instanceof MarketplaceError) return {
+			success: false,
+			error: {
+				code: err.code ?? "MARKETPLACE_ERROR",
+				message: err.message
+			}
+		};
+		if (err instanceof DinewayStorageError) return {
+			success: false,
+			error: {
+				code: err.code ?? "STORAGE_ERROR",
+				message: "Storage error while installing plugin"
+			}
+		};
+		if (err && typeof err === "object" && "code" in err) {
+			const code = err.code;
+			if (typeof code === "string" && code.trim()) return {
+				success: false,
+				error: {
+					code,
+					message: "Failed to install plugin from marketplace"
+				}
+			};
+		}
+		console.error("Failed to install marketplace plugin:", err);
+		return {
+			success: false,
+			error: {
+				code: "INSTALL_FAILED",
+				message: "Failed to install plugin from marketplace"
+			}
+		};
+	}
+}
+async function handleMarketplaceUpdate(db, storage, sandboxRunner, marketplaceUrl, pluginId, opts) {
+	const client = getClient(marketplaceUrl);
+	if (!client) return {
+		success: false,
+		error: {
+			code: "MARKETPLACE_NOT_CONFIGURED",
+			message: "Marketplace is not configured"
+		}
+	};
+	if (!storage) return {
+		success: false,
+		error: {
+			code: "STORAGE_NOT_CONFIGURED",
+			message: "Storage is required"
+		}
+	};
+	const bundleStore = createPluginBundleStore(storage);
+	if (!sandboxRunner || !sandboxRunner.isAvailable()) return {
+		success: false,
+		error: {
+			code: "SANDBOX_NOT_AVAILABLE",
+			message: "Sandbox runner is required"
+		}
+	};
+	try {
+		const stateRepo = new PluginStateRepository(db);
+		const existing = await stateRepo.get(pluginId);
+		if (!existing || existing.source !== "marketplace") return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: `No marketplace plugin found: ${pluginId}`
+			}
+		};
+		const oldVersion = existing.marketplaceVersion ?? existing.version;
+		const pluginDetail = await client.getPlugin(pluginId);
+		const newVersion = opts?.version ?? pluginDetail.latestVersion?.version;
+		if (!newVersion) return {
+			success: false,
+			error: {
+				code: "NO_VERSION",
+				message: "No newer version available"
+			}
+		};
+		if (newVersion === oldVersion) return {
+			success: false,
+			error: {
+				code: "ALREADY_UP_TO_DATE",
+				message: "Plugin is already up to date"
+			}
+		};
+		const versionMetadata = await resolveVersionMetadata(client, pluginId, pluginDetail, newVersion);
+		if (!versionMetadata) return {
+			success: false,
+			error: {
+				code: "NO_VERSION",
+				message: `Version ${newVersion} was not found for plugin ${pluginId}`
+			}
+		};
+		const bundle = await client.downloadBundle(pluginId, newVersion);
+		if (versionMetadata.checksum && bundle.checksum !== versionMetadata.checksum) return {
+			success: false,
+			error: {
+				code: "CHECKSUM_MISMATCH",
+				message: "Bundle checksum does not match marketplace record. Download may be corrupted."
+			}
+		};
+		const bundleIdentityError = validateBundleIdentity(bundle, pluginId, newVersion);
+		if (bundleIdentityError) return bundleIdentityError;
+		const oldBundle = await bundleStore.read(pluginId, oldVersion);
+		const capabilityChanges = diffCapabilities(oldBundle?.manifest.capabilities ?? [], bundle.manifest.capabilities);
+		if (capabilityChanges.added.length > 0 && !opts?.confirmCapabilityChanges) return {
+			success: false,
+			error: {
+				code: "CAPABILITY_ESCALATION",
+				message: "Plugin update requires new capabilities",
+				details: { capabilityChanges }
+			}
+		};
+		const routeVisibilityChanges = diffRouteVisibility(oldBundle?.manifest, bundle.manifest);
+		const hasNewPublicRoutes = routeVisibilityChanges.newlyPublic.length > 0;
+		if (hasNewPublicRoutes && !opts?.confirmRouteVisibilityChanges) return {
+			success: false,
+			error: {
+				code: "ROUTE_VISIBILITY_ESCALATION",
+				message: "Plugin update exposes new public (unauthenticated) routes",
+				details: {
+					routeVisibilityChanges,
+					capabilityChanges
+				}
+			}
+		};
+		await preflightSandboxBundle(bundle, sandboxRunner);
+		await bundleStore.write(pluginId, newVersion, bundle);
+		await stateRepo.upsert(pluginId, newVersion, "active", {
+			source: "marketplace",
+			marketplaceVersion: newVersion,
+			displayName: pluginDetail.name,
+			description: pluginDetail.description ?? void 0
+		});
+		bundleStore.delete(pluginId, oldVersion).catch(() => {});
+		return {
+			success: true,
+			data: {
+				pluginId,
+				oldVersion,
+				newVersion,
+				capabilityChanges,
+				routeVisibilityChanges: hasNewPublicRoutes ? routeVisibilityChanges : void 0
+			}
+		};
+	} catch (err) {
+		if (err instanceof MarketplaceUnavailableError) return {
+			success: false,
+			error: {
+				code: "MARKETPLACE_UNAVAILABLE",
+				message: "Marketplace is unavailable"
+			}
+		};
+		if (err instanceof MarketplaceError) return {
+			success: false,
+			error: {
+				code: err.code ?? "MARKETPLACE_ERROR",
+				message: err.message
+			}
+		};
+		console.error("Failed to update marketplace plugin:", err);
+		return {
+			success: false,
+			error: {
+				code: "UPDATE_FAILED",
+				message: "Failed to update plugin"
+			}
+		};
+	}
+}
+async function handleMarketplaceUninstall(db, storage, pluginId, opts) {
+	try {
+		const stateRepo = new PluginStateRepository(db);
+		const existing = await stateRepo.get(pluginId);
+		if (!existing || existing.source !== "marketplace") return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: `No marketplace plugin found: ${pluginId}`
+			}
+		};
+		const version = existing.marketplaceVersion ?? existing.version;
+		if (storage) await createPluginBundleStore(storage).delete(pluginId, version);
+		let dataDeleted = false;
+		if (opts?.deleteData) try {
+			await db.deleteFrom("_plugin_storage").where("plugin_id", "=", pluginId).execute();
+			dataDeleted = true;
+		} catch {}
+		await stateRepo.delete(pluginId);
+		return {
+			success: true,
+			data: {
+				pluginId,
+				dataDeleted
+			}
+		};
+	} catch (err) {
+		console.error("Failed to uninstall marketplace plugin:", err);
+		return {
+			success: false,
+			error: {
+				code: "UNINSTALL_FAILED",
+				message: "Failed to uninstall plugin"
+			}
+		};
+	}
+}
+async function handleMarketplaceUpdateCheck(db, marketplaceUrl) {
+	const client = getClient(marketplaceUrl);
+	if (!client) return {
+		success: false,
+		error: {
+			code: "MARKETPLACE_NOT_CONFIGURED",
+			message: "Marketplace is not configured"
+		}
+	};
+	try {
+		const marketplacePlugins = await new PluginStateRepository(db).getMarketplacePlugins();
+		const items = [];
+		for (const plugin of marketplacePlugins) try {
+			const detail = await client.getPlugin(plugin.pluginId);
+			const latest = detail.latestVersion?.version;
+			const installed = plugin.marketplaceVersion ?? plugin.version;
+			if (!latest) continue;
+			const hasUpdate = latest !== installed;
+			let capabilityChanges;
+			let hasCapabilityChanges = false;
+			if (hasUpdate && detail.latestVersion) {
+				capabilityChanges = diffCapabilities(detail.capabilities ?? [], detail.latestVersion.capabilities ?? []);
+				hasCapabilityChanges = capabilityChanges.added.length > 0 || capabilityChanges.removed.length > 0;
+			}
+			items.push({
+				pluginId: plugin.pluginId,
+				installed,
+				latest: latest ?? installed,
+				hasUpdate,
+				hasCapabilityChanges,
+				capabilityChanges: hasCapabilityChanges ? capabilityChanges : void 0,
+				hasRouteVisibilityChanges: false
+			});
+		} catch (err) {
+			console.warn(`Failed to check updates for ${plugin.pluginId}:`, err);
+		}
+		return {
+			success: true,
+			data: { items }
+		};
+	} catch (err) {
+		if (err instanceof MarketplaceUnavailableError) return {
+			success: false,
+			error: {
+				code: "MARKETPLACE_UNAVAILABLE",
+				message: "Marketplace is unavailable"
+			}
+		};
+		console.error("Failed to check marketplace updates:", err);
+		return {
+			success: false,
+			error: {
+				code: "UPDATE_CHECK_FAILED",
+				message: "Failed to check for updates"
+			}
+		};
+	}
+}
+async function handleMarketplaceSearch(marketplaceUrl, query, opts) {
+	const client = getClient(marketplaceUrl);
+	if (!client) return {
+		success: false,
+		error: {
+			code: "MARKETPLACE_NOT_CONFIGURED",
+			message: "Marketplace is not configured"
+		}
+	};
+	try {
+		return {
+			success: true,
+			data: await client.search(query, opts)
+		};
+	} catch (err) {
+		if (err instanceof MarketplaceUnavailableError) return {
+			success: false,
+			error: {
+				code: "MARKETPLACE_UNAVAILABLE",
+				message: "Marketplace is unavailable"
+			}
+		};
+		console.error("Failed to search marketplace:", err);
+		return {
+			success: false,
+			error: {
+				code: "SEARCH_FAILED",
+				message: "Failed to search marketplace"
+			}
+		};
+	}
+}
+async function handleMarketplaceGetPlugin(marketplaceUrl, pluginId) {
+	const client = getClient(marketplaceUrl);
+	if (!client) return {
+		success: false,
+		error: {
+			code: "MARKETPLACE_NOT_CONFIGURED",
+			message: "Marketplace is not configured"
+		}
+	};
+	try {
+		return {
+			success: true,
+			data: await client.getPlugin(pluginId)
+		};
+	} catch (err) {
+		if (err instanceof MarketplaceError && err.status === 404) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: `Plugin not found: ${pluginId}`
+			}
+		};
+		if (err instanceof MarketplaceUnavailableError) return {
+			success: false,
+			error: {
+				code: "MARKETPLACE_UNAVAILABLE",
+				message: "Marketplace is unavailable"
+			}
+		};
+		console.error("Failed to get marketplace plugin:", err);
+		return {
+			success: false,
+			error: {
+				code: "GET_PLUGIN_FAILED",
+				message: "Failed to get plugin details"
+			}
+		};
+	}
+}
+async function handleThemeSearch(marketplaceUrl, query, opts) {
+	const client = getClient(marketplaceUrl);
+	if (!client) return {
+		success: false,
+		error: {
+			code: "MARKETPLACE_NOT_CONFIGURED",
+			message: "Marketplace is not configured"
+		}
+	};
+	try {
+		return {
+			success: true,
+			data: await client.searchThemes(query, opts)
+		};
+	} catch (err) {
+		if (err instanceof MarketplaceUnavailableError) return {
+			success: false,
+			error: {
+				code: "MARKETPLACE_UNAVAILABLE",
+				message: "Marketplace is unavailable"
+			}
+		};
+		console.error("Failed to search themes:", err);
+		return {
+			success: false,
+			error: {
+				code: "THEME_SEARCH_FAILED",
+				message: "Failed to search themes"
+			}
+		};
+	}
+}
+async function handleThemeGetDetail(marketplaceUrl, themeId) {
+	const client = getClient(marketplaceUrl);
+	if (!client) return {
+		success: false,
+		error: {
+			code: "MARKETPLACE_NOT_CONFIGURED",
+			message: "Marketplace is not configured"
+		}
+	};
+	try {
+		return {
+			success: true,
+			data: await client.getTheme(themeId)
+		};
+	} catch (err) {
+		if (err instanceof MarketplaceError && err.status === 404) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: `Theme not found: ${themeId}`
+			}
+		};
+		if (err instanceof MarketplaceUnavailableError) return {
+			success: false,
+			error: {
+				code: "MARKETPLACE_UNAVAILABLE",
+				message: "Marketplace is unavailable"
+			}
+		};
+		console.error("Failed to get marketplace theme:", err);
+		return {
+			success: false,
+			error: {
+				code: "GET_THEME_FAILED",
+				message: "Failed to get theme details"
+			}
+		};
+	}
+}
+
+//#endregion
+export { validateRev as $, handleRevisionGet as A, handleContentDuplicate as B, handleSchemaFieldReorder as C, handleMediaGet as D, handleMediaDelete as E, handleContentCountScheduled as F, handleContentPermanentDelete as G, handleContentGetIncludingTrashed as H, handleContentCountTrashed as I, handleContentSchedule as J, handleContentPublish as K, handleContentCreate as L, handleRevisionRestore as M, generateManifest as N, handleMediaList as O, handleContentCompare as P, handleContentUpdate as Q, handleContentDelete as R, handleSchemaFieldList as S, handleMediaCreate as T, handleContentList as U, handleContentGet as V, handleContentListTrashed as W, handleContentUnpublish as X, handleContentTranslations as Y, handleContentUnschedule as Z, handleSchemaCollectionList as _, handleMarketplaceUninstall as a, handleSchemaFieldDelete as b, handleMarketplaceUpdatePreview as c, createPluginBundleStore as d, handleOrphanedTableList as f, handleSchemaCollectionGet as g, handleSchemaCollectionDelete as h, handleMarketplaceSearch as i, handleRevisionList as j, handleMediaUpdate as k, handleThemeGetDetail as l, handleSchemaCollectionCreate as m, handleMarketplaceInstall as n, handleMarketplaceUpdate as o, handleOrphanedTableRegister as p, handleContentRestore as q, handleMarketplaceInstallPreview as r, handleMarketplaceUpdateCheck as s, handleMarketplaceGetPlugin as t, handleThemeSearch as u, handleSchemaCollectionUpdate as v, handleSchemaFieldUpdate as w, handleSchemaFieldGet as x, handleSchemaFieldCreate as y, handleContentDiscardDraft as z };