emdash 1.3.0 → 1.4.0

package/src/astro/middleware/redirect.ts

@@ -25,6 +25,13 @@ import type { CachedRedirects, RedirectRule } from "../../redirects/cache.js";
 import { loadCachedRedirects, matchCachedPatterns } from "../../redirects/cache.js";
 import { isSiteRelativeDestination } from "../../redirects/destination.js";
 import { isTerminalStatus } from "../../redirects/status.js";
+import { peekRequestCache } from "../../request-cache.js";
+import {
+	getRequestContext,
+	runWithContext,
+	type EmDashRequestContext,
+} from "../../request-context.js";
+import { invalidateSiteSettingsSnapshot, peekSiteSettingsSnapshot } from "../../settings/index.js";
 
 /** Paths that should never be intercepted by redirects */
 const SKIP_PREFIXES = ["/_emdash", "/_image"];
@@ -123,81 +130,169 @@ export const onRequest = defineMiddleware(async (context, next) => {
 		}
 	}
 
-	try {
-		const repo = new RedirectRepository(db);
-		const source = createRedirectSource(db);
-		const routeCache: APIContext["cache"] | undefined = context.cache;
-
-		// One query loads the published rules into the cache; warm requests
-		// issue zero queries, and an expired cache checks the published version
-		// in the background. Empty-redirect sites cache an empty Map + array.
-		// A response the route cache stores is served to every visitor until it
-		// is purged, so before one is returned the rules are verified current.
-		let cached = await loadCachedRedirects(source);
-		let match = matchRedirect(cached, pathname);
-		let verified = false;
-		if (match && routeCacheStores(routeCache)) {
-			cached = await loadCachedRedirects(source, { verify: true });
-			verified = true;
-			match = matchRedirect(cached, pathname);
+	const routeCache: APIContext["cache"] | undefined = context.cache;
+	const renderedSettings = new Set<string>();
+	let currentSettingsVersion: string | null | undefined;
+	const checkSettings = () => {
+		if (currentSettingsVersion === undefined || renderedSettings.size === 0) return;
+		if (currentSettingsVersion === null) {
+			routeCache?.set(false);
+		} else if ([...renderedSettings].some((v) => v !== currentSettingsVersion)) {
+			routeCache?.set(false);
+			invalidateSiteSettingsSnapshot();
+		}
+	};
+	const requestSettings: NonNullable<EmDashRequestContext["siteSettings"]> = {
+		onRead(version) {
+			renderedSettings.add(version);
+			checkSettings();
+		},
+	};
+	const finalizeSettings = async () => {
+		if (!routeCacheStores(routeCache)) return;
+		if (requestSettings.live) {
+			if (currentSettingsVersion == null) routeCache?.set(false);
+			return;
+		}
+		const prefetched =
+			await peekRequestCache<NonNullable<ReturnType<typeof peekSiteSettingsSnapshot>>>(
+				"siteSettingsSnapshot",
+			);
+		if (prefetched) requestSettings.onRead(prefetched.version);
+		const snapshot = peekSiteSettingsSnapshot();
+		// Layouts and head components can first read settings after cache headers
+		// are sent. Pin the verified snapshot before handing off the stream.
+		if (currentSettingsVersion == null) {
+			routeCache?.set(false);
+		} else if (!snapshot) {
+			requestSettings.version = currentSettingsVersion;
+		} else if (snapshot.version !== currentSettingsVersion) {
+			routeCache?.set(false);
+			invalidateSiteSettingsSnapshot();
+		} else {
+			requestSettings.snapshot = snapshot;
 		}
-		if (match) return redirectResponse(context, repo, match) ?? next();
+	};
+	const run = async () => {
+		let repo: RedirectRepository | undefined;
+		let source: ReturnType<typeof createRedirectSource> | undefined;
+		let cached: CachedRedirects | undefined;
+		let match: RedirectMatch | null = null;
+		let verified = false;
 
-		// No redirect matched -- proceed and check for 404
-		const response = await next();
+		try {
+			repo = new RedirectRepository(db);
+			source = createRedirectSource(
+				db,
+				routeCache?.enabled
+					? (version) => {
+							currentSettingsVersion = version;
+							checkSettings();
+						}
+					: undefined,
+			);
 
-		// Keep a 404 out of the route cache: publishing the missing entry later
-		// purges content tags, not the missed path, so a cached 404 would outlive
-		// the fix. Astro has no cache handle for URLs that match no route, but a
-		// page answering a content miss with Astro.rewrite("/404") has one.
-		if (response.status === 404) {
+			// One query loads the published rules into the cache; warm requests
+			// issue zero queries, and an expired cache checks the published version
+			// in the background. Empty-redirect sites cache an empty Map + array.
+			// A response the route cache stores is served to every visitor until it
+			// is purged, so before one is returned the rules are verified current.
+			cached = await loadCachedRedirects(source);
+			match = matchRedirect(cached, pathname);
+			if (match && routeCacheStores(routeCache)) {
+				cached = await loadCachedRedirects(source, { verify: true });
+				verified = true;
+				match = matchRedirect(cached, pathname);
+			}
+		} catch {
+			// If the redirects table doesn't exist yet (pre-migration), skip silently.
+			// Without a freshness check, a settings snapshot must not be edge-cached.
+			currentSettingsVersion = null;
 			routeCache?.set(false);
+			return next();
 		}
 
-		if (!verified && routeCacheStores(routeCache)) {
-			const current = await loadCachedRedirects(source, { verify: true }).catch(() => cached);
-			const late = current === cached ? null : matchRedirect(current, pathname);
-			const redirected = late && redirectResponse(context, repo, late);
-			if (redirected) {
+		if (match) {
+			const redirected = redirectResponse(context, repo, match);
+			if (redirected) return redirected;
+		}
+
+		// No redirect matched -- proceed and check for 404.
+		const response = await next();
+
+		// Post-response work must not re-run the route either. Swallow errors here
+		// and return the response the route already produced.
+		try {
+			// Keep a 404 out of the route cache: publishing the missing entry later
+			// purges content tags, not the missed path, so a cached 404 would outlive
+			// the fix. Astro has no cache handle for URLs that match no route, but a
+			// page answering a content miss with Astro.rewrite("/404") has one.
+			if (response.status === 404) {
 				routeCache?.set(false);
-				// Finish the discarded render instead of cancelling it: a render cut off
-				// with its request never settles an isolate-wide fetch it started, and
-				// every later render awaiting that fetch hangs.
-				after(() => response.body?.pipeTo(new WritableStream()));
-				return redirected;
 			}
-		}
 
-		// Log misses under the path the visitor requested.
-		// Two shapes count as a miss: a 404 response (an unmatched route, or a
-		// page answering a content miss with Astro.rewrite("/404")), and a
-		// matched route answering a content miss with a redirect to /404 —
-		// there the missed path exists only on this first pass, before the
-		// browser follows the redirect. The error page itself is never logged: /404
-		// answers 404 by design and carries no path information.
-		const location = response.headers.get("location");
-		const missedByRedirect =
-			isRedirectCode(response.status) && (location === "/404" || location === "/404/");
-		const missedDirectly = response.status === 404 && pathname !== "/404" && pathname !== "/404/";
-		if (missedDirectly || missedByRedirect) {
-			const referrer = context.request.headers.get("referer") ?? null;
-			const userAgent = context.request.headers.get("user-agent") ?? null;
-			after(async () => {
-				try {
-					await repo.log404({
-						path: pathname,
-						referrer,
-						userAgent,
-					});
-				} catch (error) {
-					console.error("[emdash:redirects] failed to log 404:", error);
+			if (!verified && routeCacheStores(routeCache) && source && cached) {
+				currentSettingsVersion = undefined;
+				const current = await loadCachedRedirects(source, { verify: true }).catch(() => cached);
+				if (currentSettingsVersion === undefined) {
+					currentSettingsVersion = null;
+					checkSettings();
 				}
-			});
+				const late = current === cached ? null : matchRedirect(current, pathname);
+				const redirected = late && redirectResponse(context, repo, late);
+				if (redirected) {
+					routeCache?.set(false);
+					// Finish the discarded render instead of cancelling it: a render cut off
+					// with its request never settles an isolate-wide fetch it started, and
+					// every later render awaiting that fetch hangs.
+					after(() => response.body?.pipeTo(new WritableStream()));
+					return redirected;
+				}
+			}
+
+			try {
+				await finalizeSettings();
+			} catch {
+				routeCache?.set(false);
+			}
+
+			// Log misses under the path the visitor requested.
+			// Two shapes count as a miss: a 404 response (an unmatched route, or a
+			// page answering a content miss with Astro.rewrite("/404")), and a
+			// matched route answering a content miss with a redirect to /404 —
+			// there the missed path exists only on this first pass, before the
+			// browser follows the redirect. The error page itself is never logged: /404
+			// answers 404 by design and carries no path information.
+			const location = response.headers.get("location");
+			const missedByRedirect =
+				isRedirectCode(response.status) && (location === "/404" || location === "/404/");
+			const missedDirectly = response.status === 404 && pathname !== "/404" && pathname !== "/404/";
+			if (missedDirectly || missedByRedirect) {
+				const referrer = context.request.headers.get("referer") ?? null;
+				const userAgent = context.request.headers.get("user-agent") ?? null;
+				after(async () => {
+					try {
+						await repo.log404({
+							path: pathname,
+							referrer,
+							userAgent,
+						});
+					} catch (error) {
+						console.error("[emdash:redirects] failed to log 404:", error);
+					}
+				});
+			}
+		} catch (error) {
+			console.error("[emdash:redirects] post-response step failed:", error);
 		}
 
 		return response;
-	} catch {
-		// If the redirects table doesn't exist yet (pre-migration), skip silently
-		return next();
+	};
+	if (!routeCache?.enabled) return run();
+	const parent = getRequestContext();
+	if (parent) {
+		parent.siteSettings = requestSettings;
+		return run();
 	}
+	return runWithContext({ editMode: false, siteSettings: requestSettings }, run);
 });

package/src/astro/middleware/request-context.ts

@@ -252,6 +252,7 @@ export const onRequest = defineMiddleware(async (context, next) => {
 		};
 		if (virtualConfig?.objectCacheEnabled && context.cache?.enabled) {
 			const parent = getRequestContext();
+			if (parent?.siteSettings) parent.siteSettings.live = true;
 			return runWithContext({ ...parent, editMode: false, routeCacheFill: true }, render);
 		}
 		return render();

package/src/astro/middleware.ts

@@ -42,6 +42,7 @@ import {
 	isInstrumentationEnabled,
 } from "../database/instrumentation.js";
 import {
+	isMigrationRequiredError,
 	PendingMigrationsError,
 	resolveRuntimeMigrationMode,
 	type RuntimeMigrationMode,
@@ -484,6 +485,18 @@ function pendingMigrationsResponse(error: PendingMigrationsError): Response {
 	return migrationRequiredResponse();
 }
 
+function migrationRequiredErrorResponse(error: unknown): Response {
+	if (error instanceof PendingMigrationsError) return pendingMigrationsResponse(error);
+	if (Date.now() - lastRuntimeInitErrorLogAt >= RUNTIME_INIT_ERROR_LOG_INTERVAL_MS) {
+		lastRuntimeInitErrorLogAt = Date.now();
+		console.error(
+			"[emdash] database migrations are required:",
+			error instanceof Error ? error.message : error,
+		);
+	}
+	return migrationRequiredResponse();
+}
+
 function migrationRequiredResponse(): Response {
 	return new Response(
 		"Database migrations are required. Apply the deployment migration manifest and retry.",
@@ -906,8 +919,8 @@ export const onRequest = defineMiddleware(async (context, next) => {
 							storage: runtime.storage,
 						} as EmDashHandlers;
 					} catch (error) {
-						if (error instanceof PendingMigrationsError) {
-							return pendingMigrationsResponse(error);
+						if (isMigrationRequiredError(error)) {
+							return migrationRequiredErrorResponse(error);
 						}
 						if (migrationMode === "manual" && isMissingTableError(error)) {
 							console.error(
@@ -1176,8 +1189,8 @@ export const onRequest = defineMiddleware(async (context, next) => {
 					setPluginStatus: runtime.setPluginStatus.bind(runtime),
 				};
 			} catch (error) {
-				if (error instanceof PendingMigrationsError) {
-					return pendingMigrationsResponse(error);
+				if (isMigrationRequiredError(error)) {
+					return migrationRequiredErrorResponse(error);
 				}
 				if (migrationMode === "manual" && isMissingTableError(error)) {
 					console.error("[emdash] database schema is unavailable in manual migration mode:", error);

package/src/astro/routes/api/content/[collection]/[id]/terms/[taxonomy].ts

@@ -5,6 +5,7 @@
  * POST /_emdash/api/content/:collection/:id/terms/:taxonomy - Set terms for an entry
  */
 
+import { hasPermission } from "@emdash-cms/auth";
 import type { APIRoute } from "astro";
 
 import { requireAnyPerm, requireEntryEditPerm, requirePerm } from "#api/authorize.js";
@@ -80,7 +81,9 @@ export const GET: APIRoute = async ({ params, locals }) => {
 		// entry's locale server-side so the response includes only that locale's
 		// term variant.
 		const entry = await new ContentRepository(emdash.db).findByIdOrSlug(collection, id);
-		if (!entry) return apiError("NOT_FOUND", "Content not found", 404);
+		if (!entry || (entry.status !== "published" && !hasPermission(user, "content:read_drafts"))) {
+			return apiError("NOT_FOUND", "Content not found", 404);
+		}
 		const locale = entry.locale || getI18nConfig()?.defaultLocale || "en";
 		const defaultLocale = getI18nConfig()?.defaultLocale ?? "en";
 

package/src/astro/routes/api/content/[collection]/[id]/translations.ts

@@ -23,6 +23,14 @@ function isPublished(t: unknown): boolean {
 	);
 }
 
+function isEntry(t: unknown, idOrSlug: string): boolean {
+	return (
+		typeof t === "object" &&
+		t !== null &&
+		(("id" in t && t.id === idOrSlug) || ("slug" in t && t.slug === idOrSlug))
+	);
+}
+
 export const GET: APIRoute = async ({ params, locals }) => {
 	const { emdash, user } = locals;
 	if (!emdash?.handleContentTranslations) {
@@ -36,7 +44,9 @@ export const GET: APIRoute = async ({ params, locals }) => {
 	const result = await emdash.handleContentTranslations(collection, id);
 
 	// Filter out non-published translations for users without read_drafts so a
-	// subscriber can't enumerate locales that aren't yet live.
+	// subscriber can't enumerate locales that aren't yet live. The requested
+	// entry is one of the translations; if it isn't published, return 404 so
+	// its id or slug can't be probed either.
 	if (result.success && !hasPermission(user, "content:read_drafts")) {
 		const data =
 			result.data && typeof result.data === "object"
@@ -45,6 +55,9 @@ export const GET: APIRoute = async ({ params, locals }) => {
 				: undefined;
 		const translations = Array.isArray(data?.translations) ? data.translations : [];
 		const filtered = translations.filter(isPublished);
+		if (!filtered.some((t) => isEntry(t, id))) {
+			return apiError("NOT_FOUND", `Content item not found: ${id}`, 404);
+		}
 		return unwrapResult({
 			success: true,
 			data: { ...data, translations: filtered },

package/src/astro/routes/api/dashboard.ts

@@ -26,6 +26,8 @@ export const GET: APIRoute = async ({ locals }) => {
 	try {
 		const result = await handleDashboardStats(emdash.db, {
 			includeDrafts: hasPermission(user, "content:read_drafts"),
+			includeMediaCount: hasPermission(user, "media:read"),
+			includeUserCount: hasPermission(user, "users:read"),
 		});
 
 		return unwrapResult(result);

package/src/astro/routes/api/import/wordpress/analyze.ts

@@ -13,15 +13,16 @@ import mime from "mime/lite";
 
 import { requirePerm } from "#api/authorize.js";
 import { apiError, apiSuccess, handleError } from "#api/error.js";
-import { isInternalPostType } from "#import/utils.js";
-import { RESERVED_COLLECTION_SLUGS } from "#schema/types.js";
+import {
+	isInternalPostType,
+	mapPostTypeToCollection,
+	sanitizeCollectionSlug as sanitizeSlug,
+} from "#import/utils.js";
 import type { EmDashHandlers } from "#types";
 
 export const prerender = false;
 
 const NUMERIC_PATTERN = /^-?\d+(\.\d+)?$/;
-const INVALID_SLUG_CHARS = /[^a-z0-9_]/g;
-const LEADING_NON_ALPHA = /^[^a-z]+/;
 
 /** Field compatibility status */
 export type FieldCompatibility =
@@ -441,31 +442,6 @@ function isInternalMetaKey(key: string): boolean {
 	return false;
 }
 
-function sanitizeSlug(slug: string): string {
-	const sanitized = slug
-		.toLowerCase()
-		.replace(INVALID_SLUG_CHARS, "_")
-		.replace(LEADING_NON_ALPHA, "");
-	if (!sanitized) return "imported";
-	if (RESERVED_COLLECTION_SLUGS.includes(sanitized)) return `wp_${sanitized}`;
-	return sanitized;
-}
-
-function mapPostTypeToCollection(postType: string): string {
-	const mapping: Record<string, string> = {
-		post: "posts",
-		page: "pages",
-		attachment: "media",
-		product: "products",
-		portfolio: "portfolio",
-		testimonial: "testimonials",
-		team: "team",
-		event: "events",
-		faq: "faqs",
-	};
-	return mapping[postType] || sanitizeSlug(postType);
-}
-
 function mapMetaKeyToField(key: string): string {
 	// SEO plugins
 	if (key === "_yoast_wpseo_title") return "seo_title";

package/src/astro/routes/api/import/wordpress-plugin/execute.ts

@@ -37,7 +37,7 @@ import {
 } from "#import/sources/wordpress-plugin.js";
 import { resolveAndValidateExternalUrl, SsrfError } from "#import/ssrf.js";
 import type { ImportConfig, ImportResult, NormalizedItem } from "#import/types.js";
-import { resolveImportByline, sanitizeFieldSlug } from "#import/utils.js";
+import { resolveImportByline, sanitizeCollectionSlug, sanitizeFieldSlug } from "#import/utils.js";
 import {
 	attachPostTaxonomies,
 	loadTaxonomyPlanFromDb,
@@ -665,7 +665,7 @@ export async function ensureCustomTaxonomyDefs(
 		const collections = (taxonomy.post_types ?? [])
 			.map((postType) => config.postTypeMappings[postType])
 			.filter((mapping) => mapping?.enabled)
-			.map((mapping) => mapping.collection);
+			.map((mapping) => sanitizeCollectionSlug(mapping.collection));
 
 		const result = await handleTaxonomyCreate(db, {
 			name: taxonomy.name,
@@ -868,7 +868,7 @@ export async function importContent(
 			continue;
 		}
 
-		const collection = mapping.collection;
+		const collection = sanitizeCollectionSlug(mapping.collection);
 
 		// Check if collection exists in manifest
 		if (!manifest?.collections[collection]) {

package/src/astro/routes/api/media/file/[...key].ts

@@ -7,6 +7,8 @@
 import type { APIRoute } from "astro";
 
 import { apiError, handleError } from "#api/error.js";
+import { MediaRepository } from "#db/repositories/media.js";
+import { contentDisposition } from "#media/content-disposition.js";
 import {
 	IMMUTABLE_IMAGE_CACHE,
 	MUTABLE_MEDIA_CACHE_CONTROL,
@@ -80,6 +82,8 @@ export const GET: APIRoute = async ({ params, locals, request, cache }) => {
 		return apiError("NOT_CONFIGURED", "Storage not configured", 500);
 	}
 
+	// An unread download retains its storage connection even for a bodyless response.
+	let unusedBody: ReadableStream<Uint8Array> | undefined;
 	try {
 		// Range requests that include If-Range are served as whole-file responses
 		// because this route does not compare If-Range validators.
@@ -92,12 +96,12 @@ export const GET: APIRoute = async ({ params, locals, request, cache }) => {
 		const result = range
 			? await emdash.storage.download(key, { range })
 			: await emdash.storage.download(key);
+		unusedBody = result.body;
 		const served = range ? result.range : undefined;
 
 		// Adapters return the whole file for a range they don't serve, including
 		// one past the end. A size of 0 may be unknown, so it rules nothing out.
 		if (range && !served && result.size > 0 && !resolveByteRange(range, result.size)) {
-			await result.body.cancel().catch(() => undefined);
 			const response = apiError("RANGE_NOT_SATISFIABLE", "Range not satisfiable", 416);
 			response.headers.set("Content-Range", `bytes */${result.size}`);
 			return response;
@@ -132,24 +136,42 @@ export const GET: APIRoute = async ({ params, locals, request, cache }) => {
 
 		// Safe image/media types can render inline; everything else (SVG, PDF,
 		// HTML, JS, etc.) must be downloaded to prevent stored XSS.
-		if (SAFE_INLINE_TYPES.has(result.contentType)) {
-			headers["Content-Disposition"] = "inline";
-		} else {
-			headers["Content-Disposition"] = "attachment";
+		const disposition = SAFE_INLINE_TYPES.has(result.contentType) ? "inline" : "attachment";
+
+		// Name the download after the uploaded filename. Without this the
+		// browser falls back to the last path segment of the URL -- the storage
+		// key -- and every downloaded document is named after its ULID.
+		// Skipped for inline types, where no filename is shown to anyone.
+		let filename: string | null = null;
+		if (disposition === "attachment") {
+			// A failed lookup must not fail the download: naming the file is a
+			// nicety, and media with no row is served under the bare disposition.
+			try {
+				filename = await new MediaRepository(emdash.db).findFilenameByStorageKey(key);
+			} catch {
+				filename = null;
+			}
 		}
+		headers["Content-Disposition"] = contentDisposition(disposition, filename);
+
+		const body = request.method === "HEAD" ? null : result.body;
 
 		if (served) {
 			const end = served.offset + served.length - 1;
 			headers["Content-Range"] = `bytes ${served.offset}-${end}/${result.size}`;
 			headers["Content-Length"] = String(served.length);
-			return new Response(result.body, { status: 206, headers });
+			const response = new Response(body, { status: 206, headers });
+			if (body) unusedBody = undefined;
+			return response;
 		}
 
 		if (result.size) {
 			headers["Content-Length"] = String(result.size);
 		}
 
-		return new Response(result.body, { status: 200, headers });
+		const response = new Response(body, { status: 200, headers });
+		if (body) unusedBody = undefined;
+		return response;
 	} catch (error) {
 		// Check if it's a "not found" error
 		if (
@@ -159,5 +181,7 @@ export const GET: APIRoute = async ({ params, locals, request, cache }) => {
 			return apiError("NOT_FOUND", "File not found", 404);
 		}
 		return handleError(error, "Failed to serve file", "FILE_SERVE_ERROR");
+	} finally {
+		if (unusedBody && !unusedBody.locked) await unusedBody.cancel().catch(() => undefined);
 	}
 };

package/src/astro/routes/api/oauth/token.ts

@@ -17,6 +17,7 @@ import type { APIRoute } from "astro";
 import { z } from "zod";
 
 import { apiError, handleError } from "#api/error.js";
+import { OAuthErrorCode } from "#api/errors.js";
 import { handleDeviceTokenExchange, handleTokenRefresh } from "#api/handlers/device-flow.js";
 import { handleAuthorizationCodeExchange } from "#api/handlers/oauth-authorization.js";
 
@@ -189,7 +190,10 @@ function oauthSuccess(data: unknown): Response {
 
 function oauthError(error: string, description: string, status: number): Response {
 	return Response.json(
-		{ error, error_description: description },
+		{
+			error: error === "INVALID_GRANT" ? OAuthErrorCode.INVALID_GRANT : error,
+			error_description: description,
+		},
 		{ status, headers: OAUTH_TOKEN_HEADERS },
 	);
 }

package/src/astro/routes/api/widget-areas/[name]/reorder.ts

@@ -12,6 +12,7 @@ import { isParseError, parseBody } from "#api/parse.js";
 import { reorderWidgetsBody } from "#api/schemas.js";
 import { widgetAreaTag } from "#cache/chrome-tags.js";
 import { invalidateRouteCache } from "#cache/route-cache.js";
+import { invalidateWidgetObjectCache } from "#widgets/index.js";
 
 export const prerender = false;
 
@@ -57,11 +58,16 @@ export const POST: APIRoute = async ({ params, request, locals, cache }) => {
 		}
 
 		// Update sort_order for each widget
-		await Promise.all(
+		// Invalidating before every update settles would let a concurrent read
+		// cache a half-reordered area under the new epoch.
+		const results = await Promise.allSettled(
 			body.widgetIds.map((id, index) =>
 				db.updateTable("_emdash_widgets").set({ sort_order: index }).where("id", "=", id).execute(),
 			),
 		);
+		invalidateWidgetObjectCache();
+		const failed = results.find((result) => result.status === "rejected");
+		if (failed) throw failed.reason;
 
 		await invalidateRouteCache(cache, [widgetAreaTag(name)]);
 		return apiSuccess({ success: true });

package/src/astro/routes/api/widget-areas/[name]/widgets/[id].ts

@@ -13,7 +13,7 @@ import { isParseError, parseBody } from "#api/parse.js";
 import { updateWidgetBody } from "#api/schemas.js";
 import { widgetAreaTag } from "#cache/chrome-tags.js";
 import { invalidateRouteCache } from "#cache/route-cache.js";
-import { rowToWidget } from "#widgets/index.js";
+import { invalidateWidgetObjectCache, rowToWidget } from "#widgets/index.js";
 import type { WidgetRow } from "#widgets/types.js";
 
 export const prerender = false;
@@ -73,6 +73,7 @@ export const PUT: APIRoute = async ({ params, request, locals, cache }) => {
 		}
 
 		await db.updateTable("_emdash_widgets").set(updates).where("id", "=", id).execute();
+		invalidateWidgetObjectCache();
 
 		const widget = await db
 			.selectFrom("_emdash_widgets")
@@ -126,6 +127,7 @@ export const DELETE: APIRoute = async ({ params, locals, cache }) => {
 
 		await db.deleteFrom("_emdash_widgets").where("id", "=", id).execute();
 
+		invalidateWidgetObjectCache();
 		await invalidateRouteCache(cache, [widgetAreaTag(name)]);
 		return apiSuccess({ deleted: true });
 	} catch (error) {

package/src/astro/routes/api/widget-areas/[name]/widgets.ts

@@ -13,7 +13,7 @@ import { isParseError, parseBody } from "#api/parse.js";
 import { createWidgetBody } from "#api/schemas.js";
 import { widgetAreaTag } from "#cache/chrome-tags.js";
 import { invalidateRouteCache } from "#cache/route-cache.js";
-import { rowToWidget } from "#widgets/index.js";
+import { invalidateWidgetObjectCache, rowToWidget } from "#widgets/index.js";
 import type { WidgetRow } from "#widgets/types.js";
 
 export const prerender = false;
@@ -70,6 +70,7 @@ export const POST: APIRoute = async ({ params, request, locals, cache }) => {
 				component_props: body.componentProps ? JSON.stringify(body.componentProps) : null,
 			})
 			.execute();
+		invalidateWidgetObjectCache();
 
 		const widget = await db
 			.selectFrom("_emdash_widgets")

package/src/astro/routes/api/widget-areas/[name].ts

@@ -11,7 +11,7 @@ import { requirePerm } from "#api/authorize.js";
 import { apiError, apiSuccess, handleError } from "#api/error.js";
 import { widgetAreaTag } from "#cache/chrome-tags.js";
 import { invalidateRouteCache } from "#cache/route-cache.js";
-import { rowToWidget } from "#widgets/index.js";
+import { invalidateWidgetObjectCache, rowToWidget } from "#widgets/index.js";
 import type { WidgetRow } from "#widgets/types.js";
 
 export const prerender = false;
@@ -85,6 +85,7 @@ export const DELETE: APIRoute = async ({ params, locals, cache }) => {
 		// Delete area (widgets cascade)
 		await db.deleteFrom("_emdash_widget_areas").where("id", "=", area.id).execute();
 
+		invalidateWidgetObjectCache();
 		await invalidateRouteCache(cache, [widgetAreaTag(name)]);
 		return apiSuccess({ deleted: true });
 	} catch (error) {