emdash 0.36.0 → 0.38.0

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,12 @@ 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();
+
+const overrideLockFlag = z.boolean().optional().meta({
+	description:
+		"Write even though another editor holds this entry's edit lock. Without it the write is refused with 409 ENTRY_LOCKED.",
+});
 
 export const contentCreateBody = z
 	.object({
@@ -201,6 +211,7 @@ export const contentUpdateBody = z
 			.optional()
 			.meta({ description: "Opaque revision token for optimistic concurrency" }),
 		skipRevision: z.boolean().optional(),
+		overrideLock: overrideLockFlag,
 		seo: contentSeoInput.optional(),
 		taxonomies: z.record(z.string(), z.array(z.string())).optional().meta({
 			description:
@@ -212,27 +223,36 @@ 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"],
+			}),
+		overrideLock: overrideLockFlag,
 	})
 	.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" }),
+	overrideLock: overrideLockFlag,
+});
+
+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 +269,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 +399,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/entry-lock.ts

@@ -0,0 +1,48 @@
+import { z } from "zod";
+
+export const entryLockAcquireBody = z
+	.object({
+		takeover: z.boolean().optional().meta({
+			description:
+				"Take the lock from whoever holds it. Their next heartbeat or save reports the new holder.",
+		}),
+		token: z.string().min(1).max(128).optional().meta({
+			description:
+				"Identifies the caller's editing session. Send the same value on DELETE so a release from one tab does not drop a lock another tab of the same account still relies on.",
+		}),
+	})
+	.meta({ id: "EntryLockAcquireBody" });
+
+export const entryLockHolderSchema = z
+	.object({
+		userId: z.string(),
+		userName: z.string().nullable(),
+		acquiredAt: z.string(),
+		expiresAt: z.string(),
+	})
+	.meta({ id: "EntryLockHolder" });
+
+export const entryLockStatusSchema = z
+	.object({
+		enabled: z.boolean().meta({
+			description: "Whether the collection takes edit locks at all",
+		}),
+		holder: entryLockHolderSchema.nullable(),
+		heldByCaller: z.boolean(),
+	})
+	.meta({ id: "EntryLockStatus" });
+
+export const entryLockReleaseResponseSchema = z
+	.object({ released: z.boolean() })
+	.meta({ id: "EntryLockReleaseResponse" });
+
+export const entryLockConflictSchema = z.object({
+	success: z.literal(false),
+	error: z.object({
+		code: z.literal("ENTRY_LOCKED"),
+		message: z.string(),
+		details: entryLockHolderSchema,
+	}),
+});
+
+export type EntryLockAcquireBody = z.infer<typeof entryLockAcquireBody>;

package/src/api/schemas/index.ts

@@ -18,3 +18,4 @@ export * from "./redirects.js";
 export * from "./bylines.js";
 export * from "./byline-fields.js";
 export * from "./relations.js";
+export * from "./entry-lock.js";

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

@@ -1,6 +1,6 @@
 import { z } from "zod";
 
-import { MAX_COLLECTION_LIST_COLUMNS } from "../../schema/types.js";
+import { MAX_COLLECTION_GROUP_LENGTH, MAX_COLLECTION_LIST_COLUMNS } from "../../schema/types.js";
 import { compileUrlPattern } from "../../schema/url-pattern.js";
 import { slugPattern } from "./common.js";
 
@@ -141,6 +141,9 @@ const fieldValidation = z
 
 const fieldWidgetOptions = z.record(z.string(), z.unknown()).optional();
 
+/** Admin sidebar folder label; an empty string clears it like `null`. */
+const navGroupValue = z.string().trim().max(MAX_COLLECTION_GROUP_LENGTH);
+
 export const createCollectionBody = z
 	.object({
 		slug: z.string().min(1).max(63).regex(slugPattern, "Invalid slug format"),
@@ -156,6 +159,8 @@ export const createCollectionBody = z
 		hasSeo: z.boolean().optional(),
 		hidden: z.boolean().optional(),
 		sortOrder: z.number().int().nullish(),
+		editLocking: z.boolean().optional(),
+		group: navGroupValue.nullish(),
 	})
 	.meta({ id: "CreateCollectionBody" });
 
@@ -172,10 +177,14 @@ export const updateCollectionBody = z
 		hasSeo: z.boolean().optional(),
 		hidden: z.boolean().optional(),
 		sortOrder: z.number().int().nullish(),
+		group: navGroupValue.nullish(),
 		commentsEnabled: z.boolean().optional(),
 		commentsModeration: z.enum(["all", "first_time", "none"]).optional(),
 		commentsClosedAfterDays: z.number().int().min(0).optional(),
 		commentsAutoApproveUsers: z.boolean().optional(),
+		editLocking: 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" });
 
@@ -266,8 +275,12 @@ export const collectionSchema = z
 		hasSeo: z.boolean(),
 		hidden: z.boolean(),
 		sortOrder: z.number().int().nullable(),
+		editLocking: z.boolean(),
+		group: z.string().nullish(),
 		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,30 @@ 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;
+	/** Admin sidebar folder shared with other collections of the same group */
+	group?: string;
+	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);
+	}
+}

package/src/astro/image-endpoint.ts

@@ -15,8 +15,8 @@ import { GET as genericGET } from "astro/assets/endpoint/generic";
 import { getConfiguredImageService, imageConfig } from "astro:assets";
 
 import {
-	IMMUTABLE_IMAGE_CACHE,
 	matchInternalMediaKey,
+	MUTABLE_MEDIA_CACHE_CONTROL,
 	originalMediaHeaders,
 } from "../media/image-endpoint.js";
 
@@ -72,7 +72,7 @@ export const GET: APIRoute = async (ctx) => {
 			status: 200,
 			headers: {
 				"Content-Type": FORMAT_MIME[format] ?? source.contentType,
-				"Cache-Control": IMMUTABLE_IMAGE_CACHE,
+				"Cache-Control": MUTABLE_MEDIA_CACHE_CONTROL,
 				"X-Content-Type-Options": "nosniff",
 			},
 		});

package/src/astro/integration/dev-typegen.ts

@@ -0,0 +1,91 @@
+import type { AstroIntegrationLogger } from "astro";
+
+/**
+ * Create a debounced refresh function that fetches the generated types from
+ * the dev server and writes them to `emdash-env.d.ts` in the project root.
+ *
+ * This runs in the Astro integration (Node) and is registered for schema
+ * mutations to call back into. It never runs in production builds or in
+ * workerd SSR isolates, because only the integration registers it.
+ */
+export function createDebouncedTypegenRefresh(
+	port: number,
+	logger: AstroIntegrationLogger,
+): () => void {
+	let timer: ReturnType<typeof setTimeout> | undefined;
+	let inFlight: Promise<unknown> | undefined;
+
+	function refresh(): void {
+		if (timer) clearTimeout(timer);
+		timer = setTimeout(() => {
+			timer = undefined;
+			if (inFlight) return;
+			inFlight = writeDevTypes(port, logger).finally(() => {
+				inFlight = undefined;
+			});
+		}, 200);
+	}
+
+	return refresh;
+}
+
+async function writeDevTypes(port: number, logger: AstroIntegrationLogger): Promise<void> {
+	const typegenUrl = `http://localhost:${port}/_emdash/api/typegen`;
+
+	try {
+		const { writeFile, readFile } = await import("node:fs/promises");
+		const { resolve } = await import("node:path");
+		const outputPath = resolve(process.cwd(), "emdash-env.d.ts");
+
+		const response = await fetch(typegenUrl, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+		});
+
+		if (!response.ok) {
+			const body = await response.text().catch(() => "");
+			logger.warn(`Typegen failed: ${response.status} ${body.slice(0, 200)}`);
+			return;
+		}
+
+		const json = await response.json();
+		if (typeof json !== "object" || json === null || !("data" in json)) {
+			logger.warn("Typegen returned an unexpected response shape");
+			return;
+		}
+
+		const result = json.data;
+		if (
+			typeof result !== "object" ||
+			result === null ||
+			!("types" in result) ||
+			!("collections" in result)
+		) {
+			logger.warn("Typegen returned an unexpected response shape");
+			return;
+		}
+
+		const types = result.types;
+		const collections = result.collections;
+		if (typeof types !== "string" || typeof collections !== "number") {
+			logger.warn("Typegen returned an unexpected response shape");
+			return;
+		}
+
+		let needsWrite = true;
+		try {
+			const existing = await readFile(outputPath, "utf-8");
+			if (existing === types) needsWrite = false;
+		} catch {
+			// File doesn't exist yet
+		}
+
+		if (needsWrite) {
+			await writeFile(outputPath, types, "utf-8");
+			logger.info(`Generated emdash-env.d.ts (${collections} collections)`);
+		}
+	} catch (error) {
+		const msg = error instanceof Error ? error.message : String(error);
+		logger.warn(`Typegen failed: ${msg}`);
+	}
+}