emdash 0.36.0 → 0.37.0

package/src/api/handlers/taxonomies.ts

@@ -304,8 +304,8 @@ export async function handleTaxonomyList(
 /**
  * Get a single taxonomy definition by name.
  *
- * Definitions are per-locale, so `locale` picks which one; without it the
- * lowest-locale match wins (same rule as `handleMenuGet`).
+ * Definitions are per-locale, so `locale` picks which one. Without it the
+ * configured default locale wins, then the lowest locale code.
  */
 export async function handleTaxonomyGet(
 	db: Kysely<Database>,
@@ -354,12 +354,8 @@ export async function handleTaxonomyCreate(
 			};
 		}
 
-		const collections = [...new Set(input.collections ?? [])];
-		const collectionError = await validateCollections(db, collections);
-		if (collectionError) {
-			return { success: false, error: collectionError };
-		}
-
+		let hierarchical = input.hierarchical ?? false;
+		let collections = [...new Set(input.collections ?? [])];
 		let translationGroup: string | null = null;
 		if (input.translationOf) {
 			const source = await db
@@ -374,6 +370,17 @@ export async function handleTaxonomyCreate(
 				};
 			}
 			translationGroup = source.translation_group ?? source.id;
+			if (input.hierarchical === undefined) {
+				hierarchical = source.hierarchical === 1;
+			}
+			if (input.collections === undefined) {
+				collections = [...new Set(defCollections(source))];
+			}
+		}
+
+		const collectionError = await validateCollections(db, collections);
+		if (collectionError) {
+			return { success: false, error: collectionError };
 		}
 
 		// Duplicate guard scoped to locale (so the same name can exist in ES
@@ -402,7 +409,7 @@ export async function handleTaxonomyCreate(
 				name: input.name,
 				label: input.label,
 				label_singular: input.labelSingular ?? null,
-				hierarchical: input.hierarchical ? 1 : 0,
+				hierarchical: hierarchical ? 1 : 0,
 				collections: JSON.stringify(collections),
 				locale,
 				translation_group: translationGroup ?? id,

package/src/api/openapi/document.ts

@@ -32,6 +32,7 @@ import {
 	contentResponseSchema,
 	contentScheduleBody,
 	contentTermsBody,
+	contentTermsResponseSchema,
 	contentTrashQuery,
 	contentTranslationsResponseSchema,
 	contentUpdateBody,
@@ -62,6 +63,7 @@ import {
 	DEFAULT_MAX_UPLOAD_SIZE,
 	mediaConfirmBody,
 	mediaConfirmResponseSchema,
+	mediaDirectUploadBody,
 	mediaExistingResponseSchema,
 	mediaFolderBody,
 	mediaFolderIdSchema,
@@ -73,11 +75,14 @@ import {
 	mediaListReadResponseSchema,
 	mediaListResponseSchema,
 	mediaReadResponseSchema,
+	mediaReplaceBody,
+	mediaReplaceResponseSchema,
 	mediaResponseSchema,
 	mediaStreamUploadResponseSchema,
 	mediaUpdateBody,
 	mediaUploadUrlBody,
 	mediaUploadUrlResponseSchema,
+	mediaUploadResponseSchema,
 } from "../schemas/media.js";
 import {
 	createMenuBody,
@@ -170,6 +175,7 @@ import {
 // ---------------------------------------------------------------------------
 
 const JSON_CONTENT = "application/json";
+const MULTIPART_CONTENT = "multipart/form-data";
 
 /** Standard error responses shared across all authenticated endpoints */
 function standardErrors(
@@ -217,7 +223,7 @@ const contentPaths = {
 			tags: ["Content"],
 			requestParams: {
 				path: z.object({
-					collection: z.string().meta({ description: "Collection slug", example: "posts" }),
+					collection: z.string().meta({ description: "Collection slug", examples: ["posts"] }),
 				}),
 				query: contentListQuery,
 			},
@@ -608,15 +614,44 @@ const contentPaths = {
 		},
 	},
 
-	"/_emdash/api/content/{collection}/{id}/terms": {
-		put: {
+	"/_emdash/api/content/{collection}/{id}/terms/{taxonomy}": {
+		get: {
+			operationId: "getContentTerms",
+			summary: "Get taxonomy terms assigned to a content item",
+			description:
+				"Returns the terms of one taxonomy that are assigned to the content item, resolved to the item's locale with fallback to the site default.",
+			tags: ["Content"],
+			requestParams: {
+				path: z.object({
+					collection: z.string().meta({ description: "Collection slug" }),
+					id: z.string().meta({ description: "Content ID or slug" }),
+					taxonomy: z.string().meta({ description: "Taxonomy name" }),
+				}),
+			},
+			responses: {
+				"200": {
+					description: "Terms assigned to the content item",
+					content: {
+						[JSON_CONTENT]: {
+							schema: successEnvelope(contentTermsResponseSchema),
+						},
+					},
+				},
+				...authErrors,
+				...standardErrors(400, 404, 500),
+			},
+		},
+		post: {
 			operationId: "setContentTerms",
 			summary: "Set taxonomy terms on a content item",
+			description:
+				"Assign a set of terms to the content item for the named taxonomy, replacing any existing assignments for that taxonomy. Every term id must belong to the named taxonomy.",
 			tags: ["Content"],
 			requestParams: {
 				path: z.object({
 					collection: z.string().meta({ description: "Collection slug" }),
 					id: z.string().meta({ description: "Content ID or slug" }),
+					taxonomy: z.string().meta({ description: "Taxonomy name" }),
 				}),
 			},
 			requestBody: {
@@ -627,7 +662,7 @@ const contentPaths = {
 					description: "Terms updated",
 					content: {
 						[JSON_CONTENT]: {
-							schema: successEnvelope(z.object({ termIds: z.array(z.string()) })),
+							schema: successEnvelope(contentTermsResponseSchema),
 						},
 					},
 				},
@@ -713,6 +748,27 @@ function buildMediaPaths(maxUploadSize: number) {
 					...standardErrors(400, 500),
 				},
 			},
+			post: {
+				operationId: "uploadMedia",
+				summary: "Upload a media item",
+				tags: ["Media"],
+				requestBody: {
+					required: true,
+					content: { [MULTIPART_CONTENT]: { schema: mediaDirectUploadBody } },
+				},
+				responses: {
+					"200": {
+						description: "Existing deduplicated media item",
+						content: { [JSON_CONTENT]: { schema: successEnvelope(mediaUploadResponseSchema) } },
+					},
+					"201": {
+						description: "Created media item",
+						content: { [JSON_CONTENT]: { schema: successEnvelope(mediaUploadResponseSchema) } },
+					},
+					...authErrors,
+					...standardErrors(400, 413, 500),
+				},
+			},
 		},
 		"/_emdash/api/media/folders": {
 			get: {
@@ -883,6 +939,30 @@ function buildMediaPaths(maxUploadSize: number) {
 				},
 			},
 		},
+		"/_emdash/api/media/{id}/replace": {
+			put: {
+				operationId: "replaceMediaImage",
+				summary: "Replace a media image",
+				description:
+					"Overwrites a ready local image under its existing storage key and refreshes its file metadata while preserving its media ID, filename, and URL. The replacement may use different dimensions or an aspect ratio from the original.",
+				tags: ["Media"],
+				requestParams: {
+					path: z.object({ id: z.string().meta({ description: "Media ID" }) }),
+				},
+				requestBody: {
+					required: true,
+					content: { [MULTIPART_CONTENT]: { schema: mediaReplaceBody } },
+				},
+				responses: {
+					"200": {
+						description: "Replaced media item",
+						content: { [JSON_CONTENT]: { schema: successEnvelope(mediaReplaceResponseSchema) } },
+					},
+					...authErrors,
+					...standardErrors(400, 404, 413, 500),
+				},
+			},
+		},
 		"/_emdash/api/admin/media-usage/repair": {
 			post: {
 				operationId: "repairMediaUsage",
@@ -1648,7 +1728,7 @@ const taxonomyPaths = {
 			operationId: "getTaxonomy",
 			summary: "Get a taxonomy definition",
 			description:
-				"Definitions are per-locale; `locale` picks one, and without it the lowest-locale match is returned.",
+				"Definitions are per-locale; `locale` picks one. Without it the configured default locale is returned, falling back to the lowest locale code.",
 			tags: ["Taxonomies"],
 			requestParams: {
 				path: z.object({ name: z.string().meta({ description: "Taxonomy name" }) }),

package/src/api/parse.ts

@@ -108,7 +108,7 @@ function validate<T extends z.ZodType>(schema: T, data: unknown): ParseResult<z.
 	}
 
 	// Format Zod errors into a readable structure
-	const issues = result.error.issues.map((issue: z.ZodIssue) => ({
+	const issues = result.error.issues.map((issue: z.core.$ZodIssue) => ({
 		path: issue.path.join("."),
 		message: issue.message,
 	}));

package/src/api/schemas/auth.ts

@@ -41,7 +41,7 @@ const authenticationCredential = z.object({
 
 export const signupRequestBody = z
 	.object({
-		email: z.string().email(),
+		email: z.email(),
 	})
 	.meta({ id: "SignupRequestBody" });
 
@@ -55,7 +55,7 @@ export const signupCompleteBody = z
 
 export const inviteCreateBody = z
 	.object({
-		email: z.string().email(),
+		email: z.email(),
 		role: roleLevel.optional(),
 	})
 	.meta({ id: "InviteCreateBody" });
@@ -77,13 +77,13 @@ export const inviteCompleteBody = z
 
 export const magicLinkSendBody = z
 	.object({
-		email: z.string().email(),
+		email: z.email(),
 	})
 	.meta({ id: "MagicLinkSendBody" });
 
 export const passkeyOptionsBody = z
 	.object({
-		email: z.string().email().optional(),
+		email: z.email().optional(),
 	})
 	.meta({ id: "PasskeyOptionsBody" });
 

package/src/api/schemas/bylines.ts

@@ -13,9 +13,9 @@ export const bylineSummarySchema = z
 		bio: z.string().nullable(),
 		avatarMediaId: z.string().nullable(),
 		/**
-		 * Avatar media storage key + alt, folded in by the media join during
-		 * content byline hydration. Null on the plain byline finders, which
-		 * don't join media.
+		 * Avatar media storage key + alt, folded in by the media join on the
+		 * content byline hydration path and the single-row byline finders.
+		 * Null on `findMany`, which doesn't join media.
 		 */
 		avatarStorageKey: z.string().nullish(),
 		avatarAlt: z.string().nullish(),

package/src/api/schemas/comments.ts

@@ -7,7 +7,7 @@ import { z } from "zod";
 export const createCommentBody = z
 	.object({
 		authorName: z.string().min(1).max(100),
-		authorEmail: z.string().email(),
+		authorEmail: z.email(),
 		body: z.string().min(1).max(5000),
 		parentId: z.string().optional(),
 		/** Honeypot field — hidden in the form, filled only by bots */

package/src/api/schemas/common.ts

@@ -51,7 +51,6 @@ const HTTP_SCHEME_RE = /^https?:\/\//i;
 
 /** Validates that a URL string uses http or https scheme. Rejects javascript:/data: URI XSS vectors. */
 export const httpUrl = z
-	.string()
 	.url()
 	.refine((url) => HTTP_SCHEME_RE.test(url), "URL must use http or https");
 
@@ -78,7 +77,9 @@ export const apiErrorSchema = z
 	.object({
 		success: z.literal(false).meta({ description: "Discriminant: always false for errors" }),
 		error: z.object({
-			code: z.string().meta({ description: "Machine-readable error code", example: "NOT_FOUND" }),
+			code: z
+				.string()
+				.meta({ description: "Machine-readable error code", examples: ["NOT_FOUND"] }),
 			message: z.string().meta({ description: "Human-readable error message" }),
 		}),
 	})

package/src/api/schemas/content.ts

@@ -8,6 +8,16 @@ import { cursorPaginationQuery, httpUrl, localeCode } from "./common.js";
 // Content: Input schemas
 // ---------------------------------------------------------------------------
 
+const contentDateTime = z.iso
+	.datetime({ offset: true, message: "must be an ISO 8601 datetime" })
+	.or(
+		z.iso.datetime({
+			offset: true,
+			precision: -1,
+			message: "must be an ISO 8601 datetime",
+		}),
+	);
+
 /** SEO input — per-content meta fields */
 export const contentSeoInput = z
 	.object({
@@ -21,10 +31,7 @@ export const contentSeoInput = z
 
 /** ISO 8601 date or datetime bound for the content-list date range filter. */
 const contentDateBound = z
-	.union([
-		z.iso.datetime({ offset: true, message: "must be an ISO 8601 datetime" }),
-		z.iso.date({ message: "must be an ISO 8601 date" }),
-	])
+	.union([contentDateTime, z.iso.date({ message: "must be an ISO 8601 date" })])
 	.optional();
 
 /**
@@ -61,7 +68,7 @@ const booleanParam = z
 	.optional()
 	.transform((value) => value === "1" || value === "true");
 
-const contentFieldComparable = z.union([z.string().max(2048), z.number().finite()]);
+const contentFieldComparable = z.union([z.string().max(2048), z.number()]);
 const contentFieldFilterScalar = z.union([contentFieldComparable, z.boolean(), z.null()]);
 const contentFieldFilterValue = z.union([
 	contentFieldFilterScalar,
@@ -167,9 +174,7 @@ export const contentListQuery = cursorPaginationQuery
 	.meta({ id: "ContentListQuery" });
 
 /** ISO 8601 datetime for `publishedAt` / `createdAt`. Routes gate writes behind `content:publish_any`. */
-const contentDateOverride = z.iso
-	.datetime({ offset: true, message: "must be an ISO 8601 datetime" })
-	.nullish();
+const contentDateOverride = contentDateTime.nullish();
 
 export const contentCreateBody = z
 	.object({
@@ -212,27 +217,34 @@ export const contentUpdateBody = z
 
 export const contentScheduleBody = z
 	.object({
-		scheduledAt: z.string().min(1, "scheduledAt is required").meta({
-			description: "ISO 8601 datetime for scheduled publishing",
-			example: "2025-06-15T09:00:00Z",
-		}),
+		scheduledAt: z
+			.string()
+			.min(1, "scheduledAt is required")
+			.meta({
+				description: "ISO 8601 datetime for scheduled publishing",
+				examples: ["2025-06-15T09:00:00Z"],
+			}),
 	})
 	.meta({ id: "ContentScheduleBody" });
 
-export const contentPublishBody = z
-	.object({
+export const contentRevisionConditionBody = z.object({
+	_rev: z
+		.string()
+		.optional()
+		.meta({ description: "Opaque revision token for optimistic concurrency" }),
+});
+
+export const contentPublishBody = contentRevisionConditionBody
+	.extend({
 		// .optional() rather than .nullish(): publishing has no semantic
 		// meaning for `null` (you can't "clear" a publish timestamp by
 		// publishing). Tightening the schema here means callers either
 		// pass a valid datetime or omit the field, and the route doesn't
 		// have to silently drop a null that snuck through.
-		publishedAt: z.iso
-			.datetime({ offset: true, message: "must be an ISO 8601 datetime" })
-			.optional()
-			.meta({
-				description:
-					"Optional ISO 8601 datetime to backdate the publish (e.g. when migrating content). Requires content:publish_any permission. Without this, existing published_at is preserved on re-publish.",
-			}),
+		publishedAt: contentDateTime.optional().meta({
+			description:
+				"Optional ISO 8601 datetime to backdate the publish (e.g. when migrating content). Requires content:publish_any permission. Without this, existing published_at is preserved on re-publish.",
+		}),
 	})
 	.meta({ id: "ContentPublishBody" });
 
@@ -249,7 +261,49 @@ export const contentTermsBody = z
 	})
 	.meta({ id: "ContentTermsBody" });
 
-export const contentTrashQuery = cursorPaginationQuery;
+/** A single term variant returned as part of an entry's term assignments. */
+const contentEntryTermSchema = z
+	.object({
+		id: z.string(),
+		name: z.string().meta({ description: "Taxonomy name" }),
+		slug: z.string(),
+		label: z.string(),
+		parentId: z.string().nullable(),
+		locale: localeCode,
+		translationGroup: z.string().nullable(),
+	})
+	.meta({ id: "ContentEntryTerm" });
+
+/** Term assignments response for the content terms endpoint. */
+export const contentTermsResponseSchema = z
+	.object({
+		terms: z.array(contentEntryTermSchema),
+		unresolved: z.array(
+			z.object({
+				translationGroup: z.string(),
+				availableLocales: z.array(localeCode),
+				translations: z.array(
+					z.object({
+						id: z.string(),
+						slug: z.string(),
+						locale: localeCode,
+					}),
+				),
+			}),
+		),
+		entryLocale: localeCode,
+		defaultLocale: localeCode,
+		implicitDefaultLocale: z.boolean(),
+	})
+	.meta({ id: "ContentTermsResponse" });
+
+export const contentTrashQuery = cursorPaginationQuery
+	.extend({
+		locale: localeCode.optional().meta({
+			description: "Restrict the trash listing to entries in this locale",
+		}),
+	})
+	.meta({ id: "ContentTrashQuery" });
 
 // ---------------------------------------------------------------------------
 // Content: Response schemas
@@ -337,6 +391,8 @@ export const trashedContentItemSchema = z
 		type: z.string(),
 		slug: z.string().nullable(),
 		status: z.string(),
+		locale: z.string().nullable(),
+		translationGroup: z.string().nullable(),
 		data: z.record(z.string(), z.unknown()),
 		authorId: z.string().nullable(),
 		createdAt: z.string(),

package/src/api/schemas/media.ts

@@ -130,10 +130,51 @@ export function mediaUploadUrlBody(maxSize: number) {
 				.max(maxSize, `File size must not exceed ${formatFileSize(maxSize)}`),
 			contentHash: z.string().optional(),
 			fieldId: z.string().optional(),
+			deduplicate: z.boolean().optional(),
+			ensureUniqueFilename: z.boolean().optional(),
+			folderId: mediaFolderIdSchema.nullable().optional(),
 		})
 		.meta({ id: "MediaUploadUrlBody" });
 }
 
+export const mediaUploadDeduplicateForm = z
+	.enum(["true", "false"])
+	.default("true")
+	.transform((value) => value === "true");
+
+export const mediaUploadEnsureUniqueFilenameForm = z
+	.enum(["true", "false"])
+	.default("false")
+	.transform((value) => value === "true");
+
+export const mediaReplaceMetadataForm = z.object({
+	width: z.coerce.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+	height: z.coerce.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+});
+
+const binaryFileSchema = z.string().meta({ format: "binary" });
+
+export const mediaDirectUploadBody = z
+	.object({
+		file: binaryFileSchema,
+		width: z.string().optional(),
+		height: z.string().optional(),
+		thumbnail: binaryFileSchema.optional(),
+		fieldId: z.string().optional(),
+		deduplicate: z.enum(["true", "false"]).optional(),
+		ensureUniqueFilename: z.enum(["true", "false"]).optional(),
+		folderId: z.union([mediaFolderIdSchema, z.literal("unfiled")]).optional(),
+	})
+	.meta({ id: "MediaDirectUploadBody" });
+
+export const mediaReplaceBody = z
+	.object({
+		file: binaryFileSchema,
+		width: z.number().int().positive(),
+		height: z.number().int().positive(),
+	})
+	.meta({ id: "MediaReplaceBody" });
+
 export const mediaConfirmBody = z
 	.object({
 		size: z.number().int().nonnegative().optional(),
@@ -248,6 +289,17 @@ export const mediaConfirmResponseSchema = z
 	})
 	.meta({ id: "MediaConfirmResponse" });
 
+export const mediaUploadResponseSchema = z
+	.object({
+		item: mediaItemSchema.extend({ url: z.string() }),
+		deduplicated: z.literal(true).optional(),
+	})
+	.meta({ id: "MediaUploadResponse" });
+
+export const mediaReplaceResponseSchema = z
+	.object({ item: mediaItemSchema.extend({ url: z.string() }) })
+	.meta({ id: "MediaReplaceResponse" });
+
 export const mediaStreamUploadResponseSchema = z
 	.object({
 		uploaded: z.literal(true),

package/src/api/schemas/redirects.ts

@@ -98,7 +98,12 @@ export const notFoundSummaryQuery = z.object({
 
 export const notFoundPruneBody = z
 	.object({
-		olderThan: z.string().datetime({ message: "olderThan must be an ISO 8601 datetime" }),
+		olderThan: z.iso.datetime({ message: "olderThan must be an ISO 8601 datetime" }).or(
+			z.iso.datetime({
+				precision: -1,
+				message: "olderThan must be an ISO 8601 datetime",
+			}),
+		),
 	})
 	.meta({ id: "NotFoundPruneBody" });
 

package/src/api/schemas/schema.ts

@@ -176,6 +176,8 @@ export const updateCollectionBody = z
 		commentsModeration: z.enum(["all", "first_time", "none"]).optional(),
 		commentsClosedAfterDays: z.number().int().min(0).optional(),
 		commentsAutoApproveUsers: z.boolean().optional(),
+		titleField: z.string().min(1).max(63).regex(slugPattern, "Invalid field slug format").nullish(),
+		dateField: z.string().min(1).max(63).regex(slugPattern, "Invalid field slug format").nullish(),
 	})
 	.meta({ id: "UpdateCollectionBody" });
 
@@ -268,6 +270,8 @@ export const collectionSchema = z
 		sortOrder: z.number().int().nullable(),
 		createdAt: z.string(),
 		updatedAt: z.string(),
+		titleField: z.string().nullish(),
+		dateField: z.string().nullish(),
 	})
 	.meta({ id: "Collection" });
 

package/src/api/schemas/setup.ts

@@ -28,7 +28,7 @@ export const setupBody = z.object({
 });
 
 export const setupAdminBody = z.object({
-	email: z.string().email(),
+	email: z.email(),
 	name: z.string().optional(),
 });
 

package/src/api/schemas/taxonomies.ts

@@ -24,8 +24,8 @@ export const createTaxonomyDefBody = z
 			.regex(/^[a-z][a-z0-9_]*$/, "Name must be lowercase alphanumeric with underscores"),
 		label: z.string().min(1).max(200),
 		labelSingular: z.string().min(1).max(200).optional(),
-		hierarchical: z.boolean().optional().default(false),
-		collections: z.array(collectionSlug).max(100).optional().default([]),
+		hierarchical: z.boolean().optional(),
+		collections: z.array(collectionSlug).max(100).optional(),
 		locale: localeCode.optional(),
 		translationOf: z.string().min(1).optional(),
 	})

package/src/api/schemas/users.ts

@@ -18,7 +18,7 @@ export const usersListQuery = z
 export const userUpdateBody = z
 	.object({
 		name: z.string().optional(),
-		email: z.string().email().optional(),
+		email: z.email().optional(),
 		role: roleLevel.optional(),
 	})
 	.meta({ id: "UserUpdateBody" });

package/src/api/types.ts

@@ -35,16 +35,7 @@ export interface ContentResponse {
 export interface ManifestResponse {
 	version: string;
 	hash: string;
-	collections: Record<
-		string,
-		{
-			label: string;
-			labelSingular: string;
-			supports: string[];
-			routable?: boolean;
-			fields: Record<string, FieldDescriptor>;
-		}
-	>;
+	collections: ManifestCollectionMap;
 	plugins: Record<
 		string,
 		{
@@ -54,6 +45,28 @@ export interface ManifestResponse {
 	>;
 }
 
+export type ManifestCollectionMap = Record<string, ManifestCollectionDescriptor>;
+
+export interface ManifestCollectionDescriptor {
+	label: string;
+	labelSingular: string;
+	supports: string[];
+	hasSeo: boolean;
+	urlPattern?: string;
+	routable?: boolean;
+	titleField?: string;
+	dateField?: string;
+	hidden?: boolean;
+	listColumns?: string[];
+	fields: Record<string, ManifestFieldDescriptor>;
+}
+
+export interface ManifestFieldDescriptor extends FieldDescriptor {
+	id?: string;
+	widget?: string;
+	validation?: Record<string, unknown>;
+}
+
 export interface FieldDescriptor {
 	kind: string;
 	label?: string;

package/src/astro/dev-typegen.ts

@@ -0,0 +1,35 @@
+/**
+ * Dev-only hook for regenerating `emdash-env.d.ts` when the schema changes.
+ *
+ * The Astro integration registers an environment-specific refresh function
+ * (filesystem + local HTTP in Node dev, no-op everywhere else). Schema
+ * mutation code just triggers the hook, so runtime modules stay free of
+ * Node-only I/O.
+ */
+
+const REFRESH_FN_KEY = "__emdashDevTypegenRefresh";
+
+export interface DevTypegenRefreshFn {
+	(db: unknown): void | Promise<void>;
+}
+
+export function setDevTypegenRefresh(fn: DevTypegenRefreshFn): void {
+	if (typeof globalThis !== "undefined") {
+		Reflect.set(globalThis, REFRESH_FN_KEY, fn);
+	}
+}
+
+export function refreshDevTypes(db: unknown): void {
+	if (typeof import.meta.env === "undefined" || !import.meta.env.DEV) return;
+
+	const fn = Reflect.get(globalThis, REFRESH_FN_KEY);
+	if (typeof fn !== "function") return;
+
+	try {
+		Promise.resolve(fn(db)).catch((error: unknown) => {
+			console.error("[emdash] dev typegen refresh failed:", error);
+		});
+	} catch (error) {
+		console.error("[emdash] dev typegen refresh failed:", error);
+	}
+}