emdash 0.33.0 → 0.34.0

package/src/api/schemas/schema.ts

@@ -1,15 +1,41 @@
 import { z } from "zod";
 
+import { MAX_COLLECTION_LIST_COLUMNS } from "../../schema/types.js";
+import { compileUrlPattern } from "../../schema/url-pattern.js";
 import { slugPattern } from "./common.js";
 
 // ---------------------------------------------------------------------------
 // Schema (collections & fields): Input schemas
 // ---------------------------------------------------------------------------
 
-const collectionSupportValues = z.enum(["drafts", "revisions", "preview", "scheduling", "search"]);
+const collectionSupportValues = z.enum([
+	"drafts",
+	"revisions",
+	"preview",
+	"scheduling",
+	"search",
+	"seo",
+]);
 
 const collectionSourcePattern = /^(template:.+|import:.+|manual|discovered|seed)$/;
 
+const collectionListColumns = z.array(
+	z.string().min(1).max(63).regex(slugPattern, "Invalid field slug format"),
+);
+
+const collectionAdminInputConfig = z.object({
+	listColumns: collectionListColumns
+		.max(
+			MAX_COLLECTION_LIST_COLUMNS,
+			`At most ${MAX_COLLECTION_LIST_COLUMNS} list columns are allowed`,
+		)
+		.optional(),
+});
+
+const collectionAdminResponseConfig = z.object({
+	listColumns: collectionListColumns.optional(),
+});
+
 const fieldTypeValues = z.enum([
 	"string",
 	"text",
@@ -49,6 +75,17 @@ const repeaterSubFieldSchema = z.object({
 	options: z.array(z.string()).optional(),
 });
 
+const urlPatternValue = z.string().superRefine((pattern, ctx) => {
+	try {
+		compileUrlPattern(pattern);
+	} catch {
+		ctx.addIssue({
+			code: "custom",
+			message: "Invalid URL pattern",
+		});
+	}
+});
+
 const fieldValidation = z
 	.object({
 		required: z.boolean().optional(),
@@ -71,6 +108,35 @@ const fieldValidation = z
 			.max(64, "allowedMimeTypes may contain at most 64 entries")
 			.optional(),
 	})
+	.superRefine((validation, ctx) => {
+		for (const [minimum, maximum] of [
+			["min", "max"],
+			["minLength", "maxLength"],
+			["minItems", "maxItems"],
+		] as const) {
+			const minimumValue = validation[minimum];
+			const maximumValue = validation[maximum];
+			if (minimumValue !== undefined && maximumValue !== undefined && minimumValue > maximumValue) {
+				ctx.addIssue({
+					code: "custom",
+					path: [maximum],
+					message: `${maximum} must be greater than or equal to ${minimum}`,
+				});
+			}
+		}
+
+		if (validation.pattern !== undefined) {
+			try {
+				RegExp(validation.pattern);
+			} catch {
+				ctx.addIssue({
+					code: "custom",
+					path: ["pattern"],
+					message: "Invalid validation pattern",
+				});
+			}
+		}
+	})
 	.optional();
 
 const fieldWidgetOptions = z.record(z.string(), z.unknown()).optional();
@@ -82,9 +148,11 @@ export const createCollectionBody = z
 		labelSingular: z.string().optional(),
 		description: z.string().optional(),
 		icon: z.string().optional(),
+		admin: collectionAdminInputConfig.optional(),
 		supports: z.array(collectionSupportValues).optional(),
 		source: z.string().regex(collectionSourcePattern).optional(),
-		urlPattern: z.string().optional(),
+		urlPattern: urlPatternValue.optional(),
+		routable: z.boolean().optional(),
 		hasSeo: z.boolean().optional(),
 		hidden: z.boolean().optional(),
 		sortOrder: z.number().int().nullish(),
@@ -97,8 +165,10 @@ export const updateCollectionBody = z
 		labelSingular: z.string().optional(),
 		description: z.string().optional(),
 		icon: z.string().optional(),
+		admin: collectionAdminInputConfig.optional(),
 		supports: z.array(collectionSupportValues).optional(),
-		urlPattern: z.string().nullish(),
+		urlPattern: urlPatternValue.nullish(),
+		routable: z.boolean().optional(),
 		hasSeo: z.boolean().optional(),
 		hidden: z.boolean().optional(),
 		sortOrder: z.number().int().nullish(),
@@ -122,6 +192,7 @@ export const createFieldBody = z
 		options: fieldWidgetOptions,
 		sortOrder: z.number().int().min(0).optional(),
 		searchable: z.boolean().optional(),
+		indexed: z.boolean().optional(),
 		translatable: z.boolean().optional(),
 	})
 	.meta({ id: "CreateFieldBody" });
@@ -138,6 +209,7 @@ export const updateFieldBody = z
 		options: fieldWidgetOptions,
 		sortOrder: z.number().int().min(0).optional(),
 		searchable: z.boolean().optional(),
+		indexed: z.boolean().optional(),
 		translatable: z.boolean().optional(),
 	})
 	.meta({ id: "UpdateFieldBody" });
@@ -186,9 +258,11 @@ export const collectionSchema = z
 		labelSingular: z.string().nullable(),
 		description: z.string().nullable(),
 		icon: z.string().nullable(),
+		admin: collectionAdminResponseConfig.optional(),
 		supports: z.array(z.string()),
 		source: z.string().nullable(),
 		urlPattern: z.string().nullable(),
+		routable: z.boolean(),
 		hasSeo: z.boolean(),
 		hidden: z.boolean(),
 		sortOrder: z.number().int().nullable(),
@@ -212,6 +286,7 @@ export const fieldSchema = z
 		options: z.record(z.string(), z.unknown()).nullable(),
 		sortOrder: z.number().int(),
 		searchable: z.boolean(),
+		indexed: z.boolean(),
 		translatable: z.boolean(),
 		createdAt: z.string(),
 		updatedAt: z.string(),

package/src/api/schemas/taxonomies.ts

@@ -9,6 +9,12 @@ import { localeCode } from "./common.js";
 /** Collection slug format: lowercase alphanumeric + underscores, starts with letter */
 const collectionSlugPattern = /^[a-z][a-z0-9_]*$/;
 
+const collectionSlug = z
+	.string()
+	.min(1)
+	.max(63)
+	.regex(collectionSlugPattern, "Invalid collection slug format");
+
 export const createTaxonomyDefBody = z
 	.object({
 		name: z
@@ -19,25 +25,38 @@ export const createTaxonomyDefBody = z
 		label: z.string().min(1).max(200),
 		labelSingular: z.string().min(1).max(200).optional(),
 		hierarchical: z.boolean().optional().default(false),
-		collections: z
-			.array(
-				z.string().min(1).max(63).regex(collectionSlugPattern, "Invalid collection slug format"),
-			)
-			.max(100)
-			.optional()
-			.default([]),
+		collections: z.array(collectionSlug).max(100).optional().default([]),
 		locale: localeCode.optional(),
 		translationOf: z.string().min(1).optional(),
 	})
 	.meta({ id: "CreateTaxonomyDefBody" });
 
+/**
+ * `name` and `locale` are absent on purpose: both identify the definition row
+ * being written, and `.strict()` turns an attempt to change either into a 400
+ * rather than a silently ignored field.
+ */
+export const updateTaxonomyDefBody = z
+	.object({
+		label: z.string().min(1).max(200).optional(),
+		labelSingular: z.string().min(1).max(200).nullish(),
+		hierarchical: z.boolean().optional(),
+		collections: z.array(collectionSlug).max(100).optional(),
+	})
+	.strict()
+	.meta({ id: "UpdateTaxonomyDefBody" });
+
 // ---------------------------------------------------------------------------
 // Taxonomy terms: Input schemas
 // ---------------------------------------------------------------------------
 
 export const createTermBody = z
 	.object({
-		slug: z.string().min(1),
+		slug: z
+			.string()
+			.min(1)
+			.optional()
+			.meta({ description: "Term slug. Omit to derive a unique slug from the label." }),
 		label: z.string().min(1),
 		parentId: z.string().nullish(),
 		description: z.string().optional(),
@@ -81,6 +100,15 @@ export const termListQuery = z
 				description:
 					"Include each term's visible-usage count. Pass false to skip the aggregate; `count` is then absent from every term.",
 			}),
+		resolveFallback: z
+			.enum(["true", "false"])
+			.transform((value) => value === "true")
+			.optional()
+			.default(false)
+			.meta({
+				description:
+					"Resolve one term per translation group, preferring the requested locale and then the configured default locale.",
+			}),
 	})
 	.meta({ id: "TermListQuery" });
 
@@ -119,6 +147,10 @@ export const taxonomyListResponseSchema = z
 	.object({ taxonomies: z.array(taxonomyDefSchema) })
 	.meta({ id: "TaxonomyListResponse" });
 
+export const taxonomyResponseSchema = z
+	.object({ taxonomy: taxonomyDefSchema })
+	.meta({ id: "TaxonomyResponse" });
+
 export const termSchema = z
 	.object({
 		id: z.string(),

package/src/api/types.ts

@@ -41,6 +41,7 @@ export interface ManifestResponse {
 			label: string;
 			labelSingular: string;
 			supports: string[];
+			routable?: boolean;
 			fields: Record<string, FieldDescriptor>;
 		}
 	>;

package/src/astro/integration/index.ts

@@ -12,7 +12,7 @@
 
 import { createRequire } from "node:module";
 
-import type { AstroIntegration, AstroIntegrationLogger } from "astro";
+import type { AstroIntegration, AstroIntegrationLogger, AstroIntegrationMiddleware } from "astro";
 
 import { validateAllowedOrigins, validateOriginShape } from "../../auth/allowed-origins.js";
 import { INTERNAL_MEDIA_PREFIX } from "../../media/normalize.js";
@@ -253,6 +253,58 @@ function printDevServerInfo(baseUrl: string, mcpEnabled: boolean): void {
 	console.log("");
 }
 
+export function buildMiddlewareEntries(
+	config: Pick<EmDashConfig, "middleware" | "playground">,
+	root: URL,
+): AstroIntegrationMiddleware[] {
+	const entries: AstroIntegrationMiddleware[] = [];
+
+	if (config.middleware !== undefined) {
+		const configuredEntrypoint = config.middleware?.outer;
+		if (
+			(typeof configuredEntrypoint !== "string" && !(configuredEntrypoint instanceof URL)) ||
+			(typeof configuredEntrypoint === "string" && configuredEntrypoint.trim() === "")
+		) {
+			throw new Error("middleware.outer must be a non-empty module specifier string or URL.");
+		}
+		const entrypoint =
+			typeof configuredEntrypoint === "string" &&
+			(configuredEntrypoint.startsWith("./") || configuredEntrypoint.startsWith("../"))
+				? new URL(configuredEntrypoint, root)
+				: configuredEntrypoint;
+		entries.push({
+			entrypoint,
+			order: "pre",
+		});
+	}
+
+	if (config.playground) {
+		entries.push({
+			entrypoint: config.playground.middlewareEntrypoint,
+			order: "pre",
+		});
+	}
+
+	entries.push(
+		{ entrypoint: "emdash/middleware", order: "pre" },
+		{ entrypoint: "emdash/middleware/redirect", order: "pre" },
+	);
+
+	if (!config.playground) {
+		entries.push(
+			{ entrypoint: "emdash/middleware/setup", order: "pre" },
+			{ entrypoint: "emdash/middleware/auth", order: "pre" },
+		);
+	}
+
+	entries.push(
+		{ entrypoint: "emdash/middleware/media-usage-write-fence", order: "pre" },
+		{ entrypoint: "emdash/middleware/request-context", order: "pre" },
+	);
+
+	return entries;
+}
+
 /**
  * Create the EmDash Astro integration
  */
@@ -543,49 +595,10 @@ export function emdash(config: EmDashConfig = {}): AstroIntegration {
 					injectMcpRoute(injectRoute);
 				}
 
-				// In playground mode, inject the playground middleware FIRST.
-				// It sets up a per-session DO database in ALS before anything
-				// else runs, so the runtime init middleware sees a real DB.
-				if (resolvedConfig.playground) {
-					addMiddleware({
-						entrypoint: resolvedConfig.playground.middlewareEntrypoint,
-						order: "pre",
-					});
-				}
-
-				// Add middleware to provide database and manifest
-				addMiddleware({
-					entrypoint: "emdash/middleware",
-					order: "pre",
-				});
-
-				// Add redirect middleware (runs after runtime init, before setup/auth)
-				addMiddleware({
-					entrypoint: "emdash/middleware/redirect",
-					order: "pre",
-				});
-
-				// Skip setup and auth in playground mode -- the playground middleware
-				// handles session creation and injects an anonymous admin user.
-				if (!resolvedConfig.playground) {
-					addMiddleware({
-						entrypoint: "emdash/middleware/setup",
-						order: "pre",
-					});
-
-					addMiddleware({
-						entrypoint: "emdash/middleware/auth",
-						order: "pre",
-					});
+				for (const middleware of buildMiddlewareEntries(resolvedConfig, astroConfig.root)) {
+					addMiddleware(middleware);
 				}
 
-				// Add request context middleware (runs after auth, on ALL routes)
-				// Sets up ALS-based context for query functions (edit mode, preview)
-				addMiddleware({
-					entrypoint: "emdash/middleware/request-context",
-					order: "pre",
-				});
-
 				// Route info is printed with absolute, clickable URLs once the
 				// dev server is listening (see astro:server:setup), since the
 				// port isn't known yet here. Nothing useful to print for build.

package/src/astro/integration/routes.ts

@@ -249,6 +249,24 @@ export function injectCoreRoutes(
 		entrypoint: resolveRoute("api/admin/media-usage/repair.ts"),
 	});
 
+	injectRoute({
+		pattern: "/_emdash/api/admin/media-usage/work",
+		entrypoint: resolveRoute("api/admin/media-usage/work/index.ts"),
+	});
+
+	injectRoute({
+		pattern: "/_emdash/api/admin/media-usage/work/retry",
+		entrypoint: resolveRoute("api/admin/media-usage/work/retry.ts"),
+	});
+	injectRoute({
+		pattern: "/_emdash/api/admin/media-usage/collection-deletions",
+		entrypoint: resolveRoute("api/admin/media-usage/collection-deletions/index.ts"),
+	});
+	injectRoute({
+		pattern: "/_emdash/api/admin/media-usage/collection-deletions/retry",
+		entrypoint: resolveRoute("api/admin/media-usage/collection-deletions/retry.ts"),
+	});
+
 	// Import API routes
 	injectRoute({
 		pattern: "/_emdash/api/import/probe",
@@ -398,6 +416,16 @@ export function injectCoreRoutes(
 		entrypoint: resolveRoute("api/taxonomies/index.ts"),
 	});
 
+	injectRoute({
+		pattern: "/_emdash/api/taxonomies/[name]",
+		entrypoint: resolveRoute("api/taxonomies/[name].ts"),
+	});
+
+	injectRoute({
+		pattern: "/_emdash/api/taxonomies/[name]/translations",
+		entrypoint: resolveRoute("api/taxonomies/[name]/translations.ts"),
+	});
+
 	injectRoute({
 		pattern: "/_emdash/api/taxonomies/[name]/reorder",
 		entrypoint: resolveRoute("api/taxonomies/[name]/reorder.ts"),
@@ -856,10 +884,12 @@ export function injectCoreRoutes(
 		});
 	}
 
-	injectRoute({
-		pattern: "/sitemap-[collection].xml",
-		entrypoint: resolveRoute("sitemap-[collection].xml.ts"),
-	});
+	if (!options.srcDir || !hasUserDefinedPublicRoute(options.srcDir, "sitemap-[collection].xml")) {
+		injectRoute({
+			pattern: "/sitemap-[collection].xml",
+			entrypoint: resolveRoute("sitemap-[collection].xml.ts"),
+		});
+	}
 
 	if (!options.srcDir || !hasUserDefinedPublicRoute(options.srcDir, "robots.txt")) {
 		injectRoute({

package/src/astro/integration/runtime.ts

@@ -478,6 +478,21 @@ export interface EmDashConfig {
 	 */
 	trustedProxyHeaders?: string[];
 
+	/**
+	 * User middleware that wraps the complete EmDash request pipeline.
+	 *
+	 * Before `next()` it runs before EmDash initializes its runtime or database,
+	 * so `locals.emdash`, the authenticated user, and request-scoped EmDash state
+	 * are unavailable. This allows cached responses and request gates to return
+	 * without paying initialization cost. When it calls `next()`, the resolved
+	 * response includes EmDash HTML injection and all other response mutations,
+	 * allowing the middleware to finalize caching and response headers safely.
+	 */
+	middleware?: {
+		/** Astro middleware module entrypoint. */
+		outer: string | URL;
+	};
+
 	/**
 	 * Enable playground mode for ephemeral "try EmDash" sites.
 	 *

package/src/astro/integration/virtual-modules.ts

@@ -72,6 +72,9 @@ export const RESOLVED_VIRTUAL_SCHEDULER_ID = "\0" + VIRTUAL_SCHEDULER_ID;
 export const VIRTUAL_ENV_ID = "virtual:emdash/env";
 export const RESOLVED_VIRTUAL_ENV_ID = "\0" + VIRTUAL_ENV_ID;
 
+export const VIRTUAL_BUILD_ID = "virtual:emdash/build";
+export const RESOLVED_VIRTUAL_BUILD_ID = "\0" + VIRTUAL_BUILD_ID;
+
 /**
  * Generates the config virtual module.
  */
@@ -97,14 +100,17 @@ export function generateDialectModule(opts: {
 	type?: string;
 	supportsRequestScope: boolean;
 	supportsCoalescing: boolean;
+	supportsCollectionDeletionGuard: boolean;
 }): string {
-	const { entrypoint, supportsRequestScope, supportsCoalescing } = opts;
+	const { entrypoint, supportsRequestScope, supportsCoalescing, supportsCollectionDeletionGuard } =
+		opts;
 	if (!entrypoint) {
 		return [
 			`export const createDialect = undefined;`,
 			`export const dialectType = "sqlite";`,
 			`export const createRequestScopedDb = (_opts) => null;`,
 			`export const createCoalescingDialect = undefined;`,
+			`export const executeCollectionDeletionGuard = undefined;`,
 		].join("\n");
 	}
 	const type = opts.type ?? "sqlite";
@@ -113,12 +119,16 @@ export function generateDialectModule(opts: {
 		? `import { createCoalescingDialect as _createCoalescingDialect } from "${entrypoint}";
 export const createCoalescingDialect = _createCoalescingDialect;`
 		: `export const createCoalescingDialect = undefined;`;
+	const collectionDeletionExport = supportsCollectionDeletionGuard
+		? `export { executeCollectionDeletionGuard } from "${entrypoint}";`
+		: `export const executeCollectionDeletionGuard = undefined;`;
 
 	if (supportsRequestScope) {
 		return `
 import { createDialect as _createDialect } from "${entrypoint}";
 export { createRequestScopedDb } from "${entrypoint}";
 ${coalescingExport}
+${collectionDeletionExport}
 export const createDialect = _createDialect;
 export const dialectType = ${JSON.stringify(type)};
 `;
@@ -127,6 +137,7 @@ export const dialectType = ${JSON.stringify(type)};
 	return `
 import { createDialect as _createDialect } from "${entrypoint}";
 ${coalescingExport}
+${collectionDeletionExport}
 export const createDialect = _createDialect;
 export const dialectType = ${JSON.stringify(type)};
 export const createRequestScopedDb = (_opts) => null;
@@ -497,6 +508,19 @@ export function generateEnvModule(adapterName: string | undefined): string {
 	return `export const env = undefined;`;
 }
 
+/**
+ * Generates the build virtual module.
+ *
+ * Content-hashed `/_astro/*` names make the response depend on the build, not
+ * only on the content. Exposing the build timestamp lets the middleware fold
+ * that dimension into the cache validator, so a code-only deploy stops
+ * answering conditional requests with 304 while the assets the cached HTML
+ * references are already gone.
+ */
+export function generateBuildModule(buildTime: number): string {
+	return `export const buildTime = ${buildTime};`;
+}
+
 /**
  * Generates the scheduler virtual module.
  *

package/src/astro/integration/vite-config.ts

@@ -48,10 +48,13 @@ import {
 	RESOLVED_VIRTUAL_SCHEDULER_ID,
 	VIRTUAL_ENV_ID,
 	RESOLVED_VIRTUAL_ENV_ID,
+	VIRTUAL_BUILD_ID,
+	RESOLVED_VIRTUAL_BUILD_ID,
 	generateSeedModule,
 	generateWaitUntilModule,
 	generateSchedulerModule,
 	generateEnvModule,
+	generateBuildModule,
 	generateConfigModule,
 	generateDialectModule,
 	generateStorageModule,
@@ -179,6 +182,11 @@ export function createVirtualModulesPlugin(
 
 	let viteCommand: "build" | "serve" | undefined;
 
+	// Captured once per plugin instance rather than inside load(): Vite may load
+	// the module more than once (client and server passes, dev reloads), and a
+	// validator that moved between those loads would invalidate at random.
+	const buildTime = Date.now();
+
 	return {
 		name: "emdash-virtual-modules",
 		configResolved(config) {
@@ -233,6 +241,9 @@ export function createVirtualModulesPlugin(
 			if (id === VIRTUAL_ENV_ID) {
 				return RESOLVED_VIRTUAL_ENV_ID;
 			}
+			if (id === VIRTUAL_BUILD_ID) {
+				return RESOLVED_VIRTUAL_BUILD_ID;
+			}
 		},
 		load(id: string) {
 			if (id === RESOLVED_VIRTUAL_CONFIG_ID) {
@@ -246,6 +257,8 @@ export function createVirtualModulesPlugin(
 					type: resolvedConfig.database?.type,
 					supportsRequestScope: resolvedConfig.database?.supportsRequestScope ?? false,
 					supportsCoalescing: resolvedConfig.database?.supportsCoalescing ?? false,
+					supportsCollectionDeletionGuard:
+						resolvedConfig.database?.supportsCollectionDeletionGuard ?? false,
 				});
 			}
 			// Generate a module that statically imports the configured storage
@@ -333,6 +346,9 @@ export function createVirtualModulesPlugin(
 			if (id === RESOLVED_VIRTUAL_ENV_ID) {
 				return generateEnvModule(astroConfig.adapter?.name);
 			}
+			if (id === RESOLVED_VIRTUAL_BUILD_ID) {
+				return generateBuildModule(buildTime);
+			}
 		},
 	};
 }
@@ -478,7 +494,6 @@ export function createViteConfig(
 							"emdash > @unpic/placeholder",
 							"emdash > blurhash",
 							"emdash > croner",
-							"emdash > image-size",
 							"emdash > jose",
 							"emdash > jpeg-js",
 							"emdash > kysely",

package/src/astro/middleware/media-usage-write-fence.ts

@@ -0,0 +1,30 @@
+import { defineMiddleware } from "astro:middleware";
+
+import { checkMediaUsageActivationWriteFence } from "#api/media-usage-write-fence.js";
+
+const FENCED_WRITE_PATHS = [
+	"/_emdash/api/content",
+	"/_emdash/api/schema",
+	"/_emdash/api/admin/media-usage/repair",
+	"/_emdash/api/revisions",
+	"/_emdash/api/import",
+	"/_emdash/api/mcp",
+] as const;
+
+const SAFE_METHODS = new Set(["GET", "HEAD", "OPTIONS"]);
+
+export const onRequest = defineMiddleware(async (context, next) => {
+	if (!isFencedWriteRequest(context.request.method, context.url.pathname)) return next();
+	const db = context.locals.emdash?.db;
+	if (!db) return next();
+	return (await checkMediaUsageActivationWriteFence(db)) ?? next();
+});
+
+function isFencedWriteRequest(method: string, pathname: string): boolean {
+	if (SAFE_METHODS.has(method.toUpperCase())) return false;
+	return FENCED_WRITE_PATHS.some(
+		(prefix) => pathname === prefix || pathname.startsWith(`${prefix}/`),
+	);
+}
+
+export default onRequest;

package/src/astro/middleware/redirect.ts

@@ -104,8 +104,18 @@ export const onRequest = defineMiddleware(async (context, next) => {
 		// No redirect matched -- proceed and check for 404
 		const response = await next();
 
-		// Log 404s for unmatched paths (fire-and-forget)
-		if (response.status === 404) {
+		// Log misses (fire-and-forget) under the path the visitor requested.
+		// Two shapes count as a miss: an unmatched route rendering the error
+		// page with status 404, and a matched route answering a content miss
+		// with a redirect to /404 (the documented template pattern) — 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;
 			repo