emdash 1.1.0 → 1.2.0

package/src/loader.ts

@@ -565,6 +565,21 @@ function mapRowToData(
 		}
 	}
 
+	stashSortValue(data, row, sortColumn, rawValues);
+
+	return data;
+}
+
+/**
+ * Keep the row's raw sort value on `data` (non-enumerable) so the next-page
+ * cursor is encoded from the same value the keyset query compares against.
+ */
+function stashSortValue(
+	data: Record<string, unknown>,
+	row: Record<string, unknown>,
+	sortColumn: string | undefined,
+	rawValues: Record<string, SortCursorValue> = {},
+): void {
 	if (sortColumn !== undefined && sortColumn in row) {
 		rawValues[sortColumn] = sortCursorValue(row[sortColumn]);
 	}
@@ -574,8 +589,92 @@ function mapRowToData(
 		configurable: false,
 		writable: false,
 	});
+}
 
-	return data;
+/**
+ * Fetch the draft revision snapshots for the rows a collection read should
+ * serve as drafts, keyed by content row ID. One query per `SQL_BATCH_SIZE`
+ * revisions; nothing runs unless `scope` is set.
+ */
+async function loadDraftRevisions(
+	db: Kysely<Database>,
+	rows: Record<string, unknown>[],
+	scope: DraftRevisionScope | undefined,
+): Promise<Map<string, Record<string, unknown>>> {
+	const drafts = new Map<string, Record<string, unknown>>();
+	if (!scope) return drafts;
+	const wanted = new Map<string, string>();
+	for (const row of rows) {
+		const draftId = rowStr(row, "draft_revision_id");
+		if (!draftId) continue;
+		if (
+			scope !== "all" &&
+			scope.id !== rowStr(row, "id") &&
+			scope.id !== rowStr(row, "slug") &&
+			scope.id !== entryIdForRow(row)
+		) {
+			continue;
+		}
+		wanted.set(draftId, rowStr(row, "id"));
+	}
+	for (const ids of chunks([...wanted.keys()], SQL_BATCH_SIZE)) {
+		const result = await sql<{ id: string; data: string }>`
+			SELECT id, data FROM revisions WHERE id IN (${sql.join(ids)})
+		`.execute(db);
+		for (const revision of result.rows) {
+			const rowId = wanted.get(revision.id);
+			if (rowId) drafts.set(rowId, JSON.parse(revision.data));
+		}
+	}
+	return drafts;
+}
+
+/**
+ * Build an entry whose content fields come from a revision snapshot, keeping
+ * the system metadata of the content table row.
+ */
+function revisionEntry(
+	row: Record<string, unknown>,
+	parsed: Record<string, unknown>,
+	booleanFields: ReturnType<typeof parseFoldedBooleanFields>,
+	sortColumn?: string,
+) {
+	const systemData: Record<string, unknown> = {};
+	for (const [key, mappedKey] of Object.entries(INCLUDE_IN_DATA)) {
+		if (key in row) {
+			if (DATE_COLUMNS.has(key)) {
+				systemData[mappedKey] = typeof row[key] === "string" ? new Date(row[key]) : null;
+			} else {
+				systemData[mappedKey] = row[key];
+			}
+		}
+	}
+	// Use slug from revision metadata if present, else from content table
+	const slug = typeof parsed._slug === "string" ? parsed._slug : rowStr(row, "slug");
+	const revSlug = slug || rowStr(row, "id");
+	const i18nConfig = virtualConfig?.i18n;
+	const i18nEnabled = i18nConfig && i18nConfig.locales.length > 1;
+	const revLocale = rowStr(row, "locale");
+	const shouldPrefixRev =
+		i18nEnabled &&
+		revLocale !== "" &&
+		(revLocale !== i18nConfig.defaultLocale || i18nConfig.prefixDefaultLocale);
+	const data: Record<string, unknown> = {
+		...systemData,
+		slug,
+		...mapRevisionData(parsed, booleanFields),
+	};
+	stashSortValue(data, row, sortColumn);
+	return {
+		id: shouldPrefixRev ? `${revLocale}/${revSlug}` : revSlug,
+		slug,
+		status: rowStr(row, "status", "draft"),
+		data,
+		cacheHint: {
+			tags: [rowStr(row, "id")],
+			lastModified: row.updated_at ? new Date(rowStr(row, "updated_at")) : undefined,
+		},
+	};
 }
 
 /**
@@ -723,13 +822,17 @@ let virtualConfig:
 	| undefined;
 let virtualCreateDialect: ((config: unknown) => Dialect) | undefined;
 
-async function loadVirtualModules() {
+async function loadVirtualConfig() {
 	if (virtualConfig === undefined) {
 		// eslint-disable-next-line @typescript-eslint/ban-ts-comment
 		// @ts-ignore - virtual module
 		const configModule = await import("virtual:emdash/config");
 		virtualConfig = configModule.default;
 	}
+}
+
+async function loadVirtualModules() {
+	await loadVirtualConfig();
 	if (virtualCreateDialect === undefined) {
 		// eslint-disable-next-line @typescript-eslint/ban-ts-comment
 		// @ts-ignore - virtual module
@@ -1429,6 +1532,16 @@ export interface OffsetCollectionFilter extends CollectionFilterBase {
  */
 export type CollectionFilter = CursorCollectionFilter | OffsetCollectionFilter;
 
+/**
+ * Which entries a collection read serves from their draft revision: `"all"`
+ * (edit mode) or one entry's ID or slug (a preview token, scoped to that
+ * entry). Set by `getEmDashCollection` from the request context; not part of
+ * the public filter.
+ */
+type DraftRevisionScope = "all" | { id: string };
+
+type LoaderCollectionFilter = CollectionFilter & { draftRevisions?: DraftRevisionScope };
+
 /**
  * Filter for loadEntry - type and id are required
  */
@@ -1461,6 +1574,9 @@ let dbInstance: Kysely<Database> | null = null;
  * Initializes the default database on first call using config from virtual module.
  */
 export async function getDb(): Promise<Kysely<Database>> {
+	// Entry IDs depend on the i18n config, so it must be loaded on the
+	// request-scoped path too, not only when the default database is opened.
+	await loadVirtualConfig();
 	// Per-request DB override via ALS (normal mode)
 	const ctx = getRequestContext();
 	if (ctx?.db) {
@@ -1516,7 +1632,7 @@ export async function loadPublishedDates(type: string, locale?: string) {
  * };
  * ```
  */
-export function emdashLoader(): LiveLoader<EntryData, EntryFilter, CollectionFilter> {
+export function emdashLoader(): LiveLoader<EntryData, EntryFilter, LoaderCollectionFilter> {
 	return {
 		name: "emdash",
 
@@ -1790,7 +1906,14 @@ export function emdashLoader(): LiveLoader<EntryData, EntryFilter, CollectionFil
 
 				// Map rows to entries
 				const booleanFields = parseFoldedBooleanFields(rows[0]);
+				const drafts = await loadDraftRevisions(db, rows, filter?.draftRevisions);
 				const entries = rows.map((row) => {
+					const draft = drafts.get(rowStr(row, "id"));
+					if (draft) {
+						const revEntry = revisionEntry(row, draft, booleanFields, sortColumn);
+						stashFolded(revEntry.data, row);
+						return revEntry;
+					}
 					const id = entryIdForRow(row);
 					const data = mapRowToData(row, booleanFields, sortColumn);
 					stashFolded(data, row);
@@ -1941,8 +2064,6 @@ export function emdashLoader(): LiveLoader<EntryData, EntryFilter, CollectionFil
 				// no-op: extractSeo() returns null when the aliases are absent.
 				expandFoldedSeo(row);
 
-				const i18nConfig = virtualConfig?.i18n;
-				const i18nEnabled = i18nConfig && i18nConfig.locales.length > 1;
 				const entryId = entryIdForRow(row);
 
 				// Preview mode: override content fields with revision data,
@@ -1957,52 +2078,22 @@ export function emdashLoader(): LiveLoader<EntryData, EntryFilter, CollectionFil
 
 					const revData = revRow.rows[0];
 					if (revData) {
-						const parsed: Record<string, unknown> = JSON.parse(revData.data);
-						// System metadata from content table + content fields from revision
-						const systemData: Record<string, unknown> = {};
-						for (const [key, mappedKey] of Object.entries(INCLUDE_IN_DATA)) {
-							if (key in row) {
-								if (DATE_COLUMNS.has(key)) {
-									systemData[mappedKey] = typeof row[key] === "string" ? new Date(row[key]) : null;
-								} else {
-									systemData[mappedKey] = row[key];
-								}
-							}
-						}
-						// Use slug from revision metadata if present, else from content table
-						const slug = typeof parsed._slug === "string" ? parsed._slug : rowStr(row, "slug");
-						const revSlug = slug || rowStr(row, "id");
-						const revLocale = rowStr(row, "locale");
-						const shouldPrefixRev =
-							i18nEnabled &&
-							revLocale !== "" &&
-							(revLocale !== i18nConfig.defaultLocale || i18nConfig.prefixDefaultLocale);
-						const revId = shouldPrefixRev ? `${revLocale}/${revSlug}` : revSlug;
+						const revEntry = revisionEntry(
+							row,
+							JSON.parse(revData.data),
+							parseFoldedBooleanFields(row),
+						);
 						// SEO is not revisioned — it comes from the content row's
 						// joined _emdash_seo columns, not the revision snapshot.
-						const revEntryData: Record<string, unknown> = {
-							...systemData,
-							slug,
-							...mapRevisionData(parsed, parseFoldedBooleanFields(row)),
-						};
 						const revSeo = extractSeo(row);
 						if (revSeo) {
-							revEntryData.seo = revSeo;
+							revEntry.data.seo = revSeo;
 							// SEO comes from the content row, so the panel data is
 							// valid for the entry regardless of the revision shown.
 							primeSeoPanel(type, rowStr(row, "id"), revSeo);
 						}
-						stashFolded(revEntryData, row);
-						return {
-							id: revId,
-							slug,
-							status: rowStr(row, "status", "draft"),
-							data: revEntryData,
-							cacheHint: {
-								tags: [rowStr(row, "id")],
-								lastModified: row.updated_at ? new Date(rowStr(row, "updated_at")) : undefined,
-							},
-						};
+						stashFolded(revEntry.data, row);
+						return revEntry;
 					}
 				}
 

package/src/media/image-endpoint.ts

@@ -34,6 +34,17 @@ export const DEFAULT_TRANSFORM_QUALITY = 85;
 /** Upper bound for a requested dimension; caps the work a single request asks for. */
 export const MAX_TRANSFORM_DIMENSION = 4000;
 
+/** Weak prefix on an ETag, stripped for weak comparison per RFC 7232. */
+const WEAK_ETAG_PREFIX = /^W\//;
+
+/**
+ * Strip surrounding whitespace and the weak prefix from an ETag value for
+ * weak comparison. Defined at module scope so it is not recreated per request.
+ */
+function stripWeakEtagPrefix(value: string): string {
+	return value.trim().replace(WEAK_ETAG_PREFIX, "");
+}
+
 /** A format string accepted by {@link ImageTransformOptions.format}. */
 export type ImageTransformFormat = (typeof ALLOWED_TRANSFORM_FORMATS)[number];
 
@@ -56,6 +67,90 @@ export const IMMUTABLE_IMAGE_CACHE = "public, max-age=31536000, immutable";
 /** Cache policy for media keys that Replace original may overwrite. */
 export const MUTABLE_MEDIA_CACHE_CONTROL = "public, max-age=0, must-revalidate";
 
+/**
+ * Format a Date as an HTTP-date (RFC 7231).
+ */
+export function formatHttpDate(date: Date): string {
+	return date.toUTCString();
+}
+
+/**
+ * Build a weak validator from representation metadata. Weak because it is based
+ * on size and modification time rather than a content hash. Keeps the same
+ * shape for stored files and derived transforms so replacements change the tag.
+ */
+export function makeWeakEtag(size: number, lastModified?: Date, suffix?: string): string {
+	let value = String(size);
+	if (lastModified) value += `-${lastModified.getTime()}`;
+	if (suffix) value += `-${suffix}`;
+	return `W/"${value}"`;
+}
+
+/**
+ * Build a canonical fingerprint of the transform query params that affect the
+ * derived /_image bytes. Used as the suffix of a transform's weak ETag.
+ */
+export function getTransformFingerprint(params: URLSearchParams): string {
+	const parts: string[] = [];
+	const append = (name: string) => {
+		const value = params.get(name);
+		if (value !== null) parts.push(`${name}=${value}`);
+	};
+	append("w");
+	append("h");
+	append("f");
+	append("q");
+	append("fit");
+	return parts.join("&");
+}
+
+/**
+ * Check whether a request's preconditions are satisfied for the given
+ * representation. Returns true when the client already has the current version.
+ */
+export function isNotModified(
+	request: Request,
+	size: number,
+	lastModified?: Date,
+	suffix?: string,
+): boolean {
+	const etag = makeWeakEtag(size, lastModified, suffix);
+	const ifNoneMatch = request.headers.get("If-None-Match");
+	if (ifNoneMatch !== null) {
+		if (ifNoneMatch.trim() === "*") return true;
+		// If-None-Match uses weak comparison: "W/" prefixes are ignored.
+		const requestedTags = ifNoneMatch.split(",").map(stripWeakEtagPrefix);
+		return requestedTags.includes(stripWeakEtagPrefix(etag));
+	}
+	const ifModifiedSince = request.headers.get("If-Modified-Since");
+	if (ifModifiedSince !== null && lastModified) {
+		const since = Date.parse(ifModifiedSince);
+		if (!Number.isNaN(since)) {
+			// HTTP-date has one-second precision; round the stored time down so
+			// a Last-Modified header replayed as If-Modified-Since always matches.
+			return Math.floor(lastModified.getTime() / 1000) * 1000 <= since;
+		}
+	}
+	return false;
+}
+
+/**
+ * Headers that make a mutable representation conditionally cacheable.
+ */
+export function validatorHeaders(
+	size: number,
+	lastModified?: Date,
+	suffix?: string,
+): Record<string, string> {
+	const headers: Record<string, string> = {
+		ETag: makeWeakEtag(size, lastModified, suffix),
+	};
+	if (lastModified) {
+		headers["Last-Modified"] = formatHttpDate(lastModified);
+	}
+	return headers;
+}
+
 /**
  * Raster types safe to render inline. Anything else (SVG, PDF, ...) is served
  * as an attachment so it can't execute as an active document. Mirrors the
@@ -77,7 +172,11 @@ const SAFE_INLINE_IMAGE_TYPES = new Set([
  * inline raster allowlist (so a stored SVG can't run scripts in the site
  * origin). Transformed output is always generated raster and doesn't need this.
  */
-export function originalMediaHeaders(contentType: string): Record<string, string> {
+export function originalMediaHeaders(
+	contentType: string,
+	size?: number,
+	lastModified?: Date,
+): Record<string, string> {
 	return {
 		"Content-Type": contentType,
 		"Cache-Control": MUTABLE_MEDIA_CACHE_CONTROL,
@@ -85,6 +184,7 @@ export function originalMediaHeaders(contentType: string): Record<string, string
 		"Content-Security-Policy":
 			"sandbox; default-src 'none'; img-src 'self'; style-src 'unsafe-inline'",
 		"Content-Disposition": SAFE_INLINE_IMAGE_TYPES.has(contentType) ? "inline" : "attachment",
+		...(size !== undefined ? validatorHeaders(size, lastModified) : {}),
 	};
 }
 

package/src/media/responsive.ts

@@ -18,12 +18,19 @@ const ABSOLUTE_HTTP_URL = /^https?:\/\//i;
 /**
  * Pick the srcset widths to generate for an image rendered at `maxWidth`.
  * Includes breakpoints up to 2x (retina) plus the rendered width itself, so the
- * browser always has an exact-fit candidate.
+ * browser always has an exact-fit candidate. A known `originalWidth` below 2x
+ * lowers that limit, so the source is never upscaled for a high-density
+ * candidate. The limit itself is a candidate up to the largest breakpoint, so
+ * images narrower than the first breakpoint still get one.
  */
-export function responsiveWidths(maxWidth: number): number[] {
-	const cap = maxWidth * 2;
+export function responsiveWidths(maxWidth: number, originalWidth?: number): number[] {
+	const width = Math.round(maxWidth);
+	if (!(width >= 1)) return [];
+	const original = Math.round(originalWidth ?? 0);
+	const cap = original >= 1 && original < width * 2 ? original : width * 2;
 	const widths = new Set(RESPONSIVE_BREAKPOINTS.filter((w) => w <= cap));
-	widths.add(maxWidth);
+	widths.add(width);
+	if (cap <= Math.max(...RESPONSIVE_BREAKPOINTS)) widths.add(cap);
 	return [...widths].toSorted((a, b) => a - b);
 }
 
@@ -120,9 +127,9 @@ export interface ResponsiveImage {
  */
 export async function buildResponsiveImage(
 	getImage: GetImage,
-	opts: { src: string; width?: number; height?: number },
+	opts: { src: string; width?: number; height?: number; originalWidth?: number },
 ): Promise<ResponsiveImage | null> {
-	const { src, width, height } = opts;
+	const { src, width, height, originalWidth } = opts;
 	if (!src || !width || !height) return null;
 	if (!ABSOLUTE_HTTP_URL.test(src)) return null;
 	try {
@@ -131,7 +138,7 @@ export async function buildResponsiveImage(
 			src,
 			width,
 			height,
-			widths: responsiveWidths(width),
+			widths: responsiveWidths(width, originalWidth),
 			sizes,
 		});
 		// Passthrough: the service returned the source unchanged (unauthorized

package/src/media/usage/extractor.ts

@@ -1,3 +1,4 @@
+import { isPortableTextVideoBlock } from "../../content/converters/video.js";
 import { normalizeMime } from "../mime.js";
 import { INTERNAL_MEDIA_PREFIX } from "../normalize.js";
 import type {
@@ -141,6 +142,20 @@ function extractPortableTextOccurrences(
 				fieldSlug,
 				`${pathPrefix}[${blockIndex}]`,
 				block.asset,
+				"image",
+			);
+			continue;
+		}
+
+		// A plugin's own `video` block may hold a reference that isn't media.
+		if (isPortableTextVideoBlock(block)) {
+			addPortableTextAssetOccurrence(
+				occurrences,
+				seen,
+				fieldSlug,
+				`${pathPrefix}[${blockIndex}]`,
+				block.asset,
+				"video",
 			);
 			continue;
 		}
@@ -155,6 +170,7 @@ function extractPortableTextOccurrences(
 					fieldSlug,
 					`${pathPrefix}[${blockIndex}].images[${imageIndex}]`,
 					image.asset,
+					"image",
 				);
 			}
 		}
@@ -231,6 +247,7 @@ function addPortableTextAssetOccurrence(
 	fieldSlug: string,
 	pathPrefix: string,
 	asset: unknown,
+	kind: "image" | "video",
 ): void {
 	if (!isRecord(asset)) return;
 
@@ -241,12 +258,12 @@ function addPortableTextAssetOccurrence(
 	addRefOccurrence(occurrences, seen, {
 		fieldSlug,
 		fieldPath: `${pathPrefix}.asset.${ref.key}`,
-		referenceType: "portable_text_image",
+		referenceType: kind === "video" ? "portable_text_video" : "portable_text_image",
 		ref: buildMediaRef({
 			id: ref.id,
 			provider,
 			mimeType: normalizeMimeValue(asset.mimeType),
-			fallbackKind: "image",
+			fallbackKind: kind,
 		}),
 	});
 }

package/src/media/usage/types.ts

@@ -13,7 +13,11 @@ export type MediaKind =
 	| "text"
 	| "other";
 
-export type MediaUsageReferenceType = "image_field" | "file_field" | "portable_text_image";
+export type MediaUsageReferenceType =
+	| "image_field"
+	| "file_field"
+	| "portable_text_image"
+	| "portable_text_video";
 
 export interface MediaUsageExtractionSubField {
 	slug: string;

package/src/plugin-utils.ts

@@ -64,7 +64,7 @@ export async function parseApiResponse<T>(
 	fallbackMessage = "Request failed",
 ): Promise<T> {
 	if (!response.ok) {
-		throw new Error(await getErrorMessage(response, `${fallbackMessage}: ${response.statusText}`));
+		throw new Error(await getErrorMessage(response, fallbackMessage));
 	}
 	const body: { data: T } = await response.json();
 	return body.data;

package/src/plugins/context.ts

@@ -1394,7 +1394,7 @@ const TRAILING_SLASH_RE = /\/$/;
 export interface SiteInfoOptions {
 	/** Site name from options table */
 	siteName?: string;
-	/** Site URL from options table or Astro config */
+	/** Site URL, resolved by the runtime in the same order as links in emails */
 	siteUrl?: string;
 	/** Site locale from options table */
 	locale?: string;
@@ -1403,12 +1403,8 @@ export interface SiteInfoOptions {
 }
 
 /**
- * Create site info from config and settings.
- *
- * Resolution order for URL:
- * 1. options table (emdash:site_url)
- * 2. Astro `site` config
- * 3. fallback to empty string
+ * Create site info from config and settings. A missing URL becomes an
+ * empty string.
  */
 export function createSiteInfo(options: SiteInfoOptions): SiteInfo {
 	return {

package/src/plugins/hooks.ts

@@ -1549,7 +1549,7 @@ export interface ExclusiveHookResolutionOptions {
 }
 
 /** Options table key prefix for exclusive hook selections */
-const EXCLUSIVE_HOOK_KEY_PREFIX = "emdash:exclusive_hook:";
+export const EXCLUSIVE_HOOK_KEY_PREFIX = "emdash:exclusive_hook:";
 
 /**
  * Resolve exclusive hook selections.

package/src/plugins/http-route-dispatch.ts

@@ -131,7 +131,11 @@ export async function dispatchPluginApiRequest({
 				? "Plugin route error"
 				: (result.error?.message ?? "Plugin route error");
 		const status = (result as { status?: number }).status ?? (code === "NOT_FOUND" ? 404 : 400);
-		return apiError(code, message, status);
+		const details =
+			code !== "INTERNAL_ERROR" && result.error && "details" in result.error
+				? result.error.details
+				: undefined;
+		return apiError(code, message, status, isRecord(details) ? details : undefined);
 	}
 
 	let response: Response;

package/src/plugins/manifest-schema.ts

@@ -237,6 +237,7 @@ const adminPageSchema = z.object({
 	path: z.string(),
 	label: z.string(),
 	icon: z.string().optional(),
+	group: z.string().trim().min(1).max(100).optional(),
 });
 
 const dashboardWidgetSchema = z.object({

package/src/plugins/route-error.ts

@@ -55,3 +55,17 @@ export class PluginRouteError extends Error {
 		return new PluginRouteError("INTERNAL_ERROR", message, 500);
 	}
 }
+
+/**
+ * Check whether a thrown value is a PluginRouteError.
+ *
+ * Also matches on shape, not just `instanceof`: under `astro dev`, Vite can load a
+ * plugin's `emdash` import as a separate module instance, so the error the plugin
+ * throws comes from a different copy of this class.
+ */
+export function isPluginRouteError(error: unknown): error is PluginRouteError {
+	if (error instanceof PluginRouteError) return true;
+	if (!(error instanceof Error) || error.name !== "PluginRouteError") return false;
+	const { code, status } = error as Partial<PluginRouteError>;
+	return typeof code === "string" && typeof status === "number";
+}

package/src/plugins/routes.ts

@@ -20,7 +20,7 @@ import { z } from "zod";
 import { SiteWriteBlockedError } from "../transfer/fence.js";
 import { PluginContextFactory, type PluginContextFactoryOptions } from "./context.js";
 import { extractRequestMeta } from "./request-meta.js";
-import { PluginRouteError } from "./route-error.js";
+import { isPluginRouteError, PluginRouteError } from "./route-error.js";
 import { parseDeclaredPluginRouteInput } from "./route-wire.js";
 import type { ResolvedPlugin, RouteContext, PluginRoute, UserInfo } from "./types.js";
 
@@ -293,7 +293,7 @@ export class PluginRouteHandler {
 				};
 			}
 			// Handle known error types
-			if (error instanceof PluginRouteError) {
+			if (isPluginRouteError(error)) {
 				return {
 					success: false,
 					error: {

package/src/plugins/state.ts

@@ -208,6 +208,42 @@ export class PluginStateRepository {
 		return (await this.get(pluginId))!;
 	}
 
+	/**
+	 * Insert an active state row unless the plugin already has one.
+	 *
+	 * Returns true only for the caller whose insert created the row, so
+	 * concurrent callers agree on a single owner for one-time setup.
+	 */
+	async createActiveIfAbsent(
+		pluginId: string,
+		version: string,
+		source: PluginSource,
+	): Promise<boolean> {
+		const now = new Date().toISOString();
+		const inserted = await this.db
+			.insertInto("_plugin_state")
+			.values({
+				plugin_id: pluginId,
+				status: "active",
+				version,
+				installed_at: now,
+				activated_at: now,
+				deactivated_at: null,
+				data: null,
+				source,
+				marketplace_version: null,
+				display_name: null,
+				description: null,
+				registry_publisher_did: null,
+				registry_slug: null,
+				mcp_tools_consent: null,
+			})
+			.onConflict((oc) => oc.column("plugin_id").doNothing())
+			.returning("plugin_id")
+			.executeTakeFirst();
+		return inserted !== undefined;
+	}
+
 	async restoreIfVersion(expectedVersion: string, state: PluginState): Promise<boolean> {
 		const result = await this.db
 			.updateTable("_plugin_state")

package/src/plugins/types.ts

@@ -1969,6 +1969,12 @@ export interface PluginAdminPage {
 	path: string;
 	label: string;
 	icon?: string;
+	/**
+	 * Admin sidebar folder. Pages sharing a group with a collection shown in
+	 * the sidebar join that folder; pages with any other group share a folder
+	 * with that label in the Plugins section, across plugins.
+	 */
+	group?: string;
 }
 
 /**

package/src/query.ts

@@ -907,6 +907,13 @@ async function getEmDashCollectionUncached<T extends string, D = InferCollection
 			: filter?.offset !== undefined
 				? { offset: filter.offset }
 				: {};
+	// Same draft access as `getEmDashEntry`: editors see every entry's draft,
+	// a preview token only the draft of the entry it was issued for.
+	const draftRevisions = ctx?.editMode
+		? "all"
+		: ctx?.preview?.collection === type
+			? { id: ctx.preview.id }
+			: undefined;
 	const result = await getLiveCollection(COLLECTION_NAME, {
 		type,
 		status: filter?.status,
@@ -915,6 +922,7 @@ async function getEmDashCollectionUncached<T extends string, D = InferCollection
 		where: filter?.where,
 		orderBy: filter?.orderBy,
 		locale: resolvedLocale,
+		draftRevisions,
 	});
 
 	const { entries, error, cacheHint } = result;