emdash 0.39.0 → 0.40.0

package/src/api/schemas/auth.ts

@@ -81,9 +81,15 @@ export const magicLinkSendBody = z
 	})
 	.meta({ id: "MagicLinkSendBody" });
 
+export const magicLinkVerifyBody = z
+	.object({
+		token: z.string().min(1),
+	})
+	.meta({ id: "MagicLinkVerifyBody" });
+
 export const passkeyOptionsBody = z
 	.object({
-		email: z.email().optional(),
+		email: z.email().optional().describe("Ignored. Accepted for compatibility with older clients."),
 	})
 	.meta({ id: "PasskeyOptionsBody" });
 

package/src/api/schemas/common.ts

@@ -98,6 +98,11 @@ export const deleteResponseSchema = z.object({ deleted: z.literal(true) }).meta(
 	id: "DeleteResponse",
 });
 
+/** Media delete response: `storageDeleted` is false when the stored file survived and is retried by cleanup */
+export const mediaDeleteResponseSchema = deleteResponseSchema
+	.extend({ storageDeleted: z.boolean() })
+	.meta({ id: "MediaDeleteResponse" });
+
 /** Standard count response */
 export const countResponseSchema = z
 	.object({ count: z.number().int().min(0) })

package/src/api/schemas/content.ts

@@ -136,9 +136,24 @@ const contentFieldFiltersQuery = z
 	})
 	.pipe(contentFieldFiltersSchema);
 
+/** Statuses the content list can filter by. */
+const CONTENT_STATUSES = [
+	"draft",
+	"published",
+	"scheduled",
+	"archived",
+	"pending",
+	"private",
+	"future",
+] as const;
+
 export const contentListQuery = cursorPaginationQuery
 	.extend({
-		status: z.string().optional(),
+		/** Filter by status; `all` (like omitting it) lists every status. */
+		status: z
+			.enum([...CONTENT_STATUSES, "all"])
+			.optional()
+			.transform((status) => (status === "all" ? undefined : status)),
 		orderBy: z.string().optional(),
 		order: z.enum(["asc", "desc"]).optional(),
 		locale: localeCode.optional(),
@@ -196,6 +211,8 @@ export const contentCreateBody = z
 		}),
 		publishedAt: contentDateOverride,
 		createdAt: contentDateOverride,
+		migrateBlocks: z.boolean().optional(),
+		replaceBlocks: z.boolean().optional(),
 	})
 	.meta({ id: "ContentCreateBody" });
 
@@ -218,6 +235,8 @@ export const contentUpdateBody = z
 				"Replace taxonomy assignments as { taxonomyName: [termSlug, ...] }. Only named taxonomies are touched; pass an empty array to clear a taxonomy.",
 		}),
 		publishedAt: contentDateOverride,
+		migrateBlocks: z.boolean().optional(),
+		replaceBlocks: z.boolean().optional(),
 	})
 	.meta({ id: "ContentUpdateBody" });
 

package/src/api/schemas/media-usage.ts

@@ -1,5 +1,6 @@
 import { z } from "zod";
 
+import { MEDIA_USAGE_SITE_SETTINGS } from "../../media/usage/site-settings.js";
 import { slugPattern } from "./common.js";
 
 export const mediaUsageCoverageStatusSchema = z
@@ -67,10 +68,19 @@ export const mediaUsageEntryDetailSchema = z
 	})
 	.meta({ id: "MediaUsageEntryDetail" });
 
+export const mediaUsageSiteSettingDetailSchema = z
+	.object({
+		setting: z.enum(MEDIA_USAGE_SITE_SETTINGS),
+	})
+	.meta({ id: "MediaUsageSiteSettingDetail" });
+
 export const mediaUsageDetailsResponseSchema = z
 	.object({
 		items: z.array(mediaUsageEntryDetailSchema),
 		nextCursor: z.string().optional(),
+		siteSettings: z.array(mediaUsageSiteSettingDetailSchema).meta({
+			description: "Site settings that select the media item, repeated on every page",
+		}),
 		coverage: mediaUsageCoverageSchema,
 	})
 	.meta({ id: "MediaUsageDetailsResponse" });
@@ -327,4 +337,5 @@ export type MediaUsageSummary = z.infer<typeof mediaUsageSummarySchema>;
 export type MediaUsageOccurrenceDetail = z.infer<typeof mediaUsageOccurrenceDetailSchema>;
 export type MediaUsageSourceDetail = z.infer<typeof mediaUsageSourceDetailSchema>;
 export type MediaUsageEntryDetail = z.infer<typeof mediaUsageEntryDetailSchema>;
+export type MediaUsageSiteSettingDetail = z.infer<typeof mediaUsageSiteSettingDetailSchema>;
 export type MediaUsageDetailsResponse = z.infer<typeof mediaUsageDetailsResponseSchema>;

package/src/api/schemas/menus.ts

@@ -13,7 +13,7 @@ import { localeCode } from "./common.js";
  */
 export const menuItemTypeEnum = z.enum(["custom", "page", "post", "taxonomy", "collection"]);
 
-const safeHref = z
+export const safeHref = z
 	.string()
 	.trim()
 	.refine(

package/src/api/schemas/schema.ts

@@ -53,6 +53,7 @@ const fieldTypeValues = z.enum([
 	"json",
 	"slug",
 	"repeater",
+	"blocks",
 ]);
 
 const repeaterSubFieldSchema = z.object({
@@ -107,6 +108,8 @@ const fieldValidation = z
 			.min(1, "allowedMimeTypes must not be empty — omit the field to allow all types")
 			.max(64, "allowedMimeTypes may contain at most 64 entries")
 			.optional(),
+		allowedTypes: z.array(z.string().min(1).max(63).regex(slugPattern)).optional(),
+		retiredTypes: z.array(z.string().min(1).max(63).regex(slugPattern)).optional(),
 	})
 	.superRefine((validation, ctx) => {
 		for (const [minimum, maximum] of [
@@ -248,6 +251,80 @@ export const schemaExportQuery = z.object({
 	format: z.string().optional(),
 });
 
+const blockFieldTypeValues = z.enum([
+	"string",
+	"text",
+	"url",
+	"number",
+	"integer",
+	"boolean",
+	"datetime",
+	"select",
+	"multiSelect",
+	"portableText",
+	"image",
+	"file",
+	"repeater",
+]);
+
+const blockFieldValidation = z
+	.object({
+		min: z.number().optional(),
+		max: z.number().optional(),
+		minLength: z.number().int().min(0).optional(),
+		maxLength: z.number().int().min(0).optional(),
+		pattern: z.string().optional(),
+		options: z.array(z.string()).optional(),
+		subFields: z.array(repeaterSubFieldSchema).min(1).optional(),
+		minItems: z.number().int().min(0).optional(),
+		maxItems: z.number().int().min(1).optional(),
+		allowedMimeTypes: z.array(z.string()).min(1).max(64).optional(),
+	})
+	.strict()
+	.optional();
+
+export const blockFieldDefinitionSchema = z
+	.object({
+		slug: z.string().min(1).max(63).regex(slugPattern, "Invalid field slug format"),
+		label: z.string().min(1).max(200),
+		type: blockFieldTypeValues,
+		required: z.boolean().optional(),
+		defaultValue: z.unknown().optional(),
+		validation: blockFieldValidation,
+		options: z.object({ darkVariant: z.boolean().optional() }).strict().optional(),
+	})
+	.strict();
+
+export const createBlockTypeBody = z
+	.object({
+		slug: z.string().min(1).max(63).regex(slugPattern, "Invalid block type slug format"),
+		label: z.string().min(1).max(200),
+		description: z.string().optional(),
+		icon: z.string().optional(),
+		category: z.string().optional(),
+		fields: z.array(blockFieldDefinitionSchema),
+	})
+	.strict()
+	.meta({ id: "CreateBlockTypeBody" });
+
+export const updateBlockTypeBody = z
+	.object({
+		expectedFingerprint: z.string().min(1),
+		label: z.string().min(1).max(200).optional(),
+		description: z.string().nullish(),
+		icon: z.string().nullish(),
+		category: z.string().nullish(),
+		fields: z.array(blockFieldDefinitionSchema).optional(),
+		breaking: z.boolean().optional(),
+	})
+	.strict()
+	.meta({ id: "UpdateBlockTypeBody" });
+
+export const activateBlockTypeVersionBody = z
+	.object({ expectedFingerprint: z.string().min(1) })
+	.strict()
+	.meta({ id: "ActivateBlockTypeVersionBody" });
+
 export const collectionGetQuery = z.object({
 	includeFields: z
 		.string()
@@ -297,6 +374,8 @@ export const fieldSchema = z
 		validation: z.record(z.string(), z.unknown()).nullable(),
 		widget: z.string().nullable(),
 		options: z.record(z.string(), z.unknown()).nullable(),
+		blockTypes: z.array(z.lazy(() => blockTypeSchema)).optional(),
+		blockTypeFingerprint: z.string().optional(),
 		sortOrder: z.number().int(),
 		searchable: z.boolean(),
 		indexed: z.boolean(),
@@ -326,6 +405,44 @@ export const fieldListResponseSchema = z
 	.object({ items: z.array(fieldSchema) })
 	.meta({ id: "FieldListResponse" });
 
+export const blockTypeVersionSchema = z
+	.object({
+		id: z.string(),
+		blockTypeId: z.string(),
+		version: z.number().int().positive(),
+		fields: z.array(blockFieldDefinitionSchema),
+		fingerprint: z.string(),
+		active: z.boolean(),
+		unsupportedTypes: z.array(z.object({ type: z.string(), path: z.string() }).strict()).optional(),
+		createdAt: z.string(),
+		updatedAt: z.string(),
+	})
+	.meta({ id: "BlockTypeVersion" });
+
+export const blockTypeSchema = z
+	.object({
+		id: z.string(),
+		slug: z.string(),
+		label: z.string(),
+		description: z.string().optional(),
+		icon: z.string().optional(),
+		category: z.string().optional(),
+		currentVersion: z.number().int().positive(),
+		source: z.enum(["user", "seed"]),
+		versions: z.array(blockTypeVersionSchema),
+		createdAt: z.string(),
+		updatedAt: z.string(),
+	})
+	.meta({ id: "BlockType" });
+
+export const blockTypeResponseSchema = z
+	.object({ item: blockTypeSchema })
+	.meta({ id: "BlockTypeResponse" });
+
+export const blockTypeListResponseSchema = z
+	.object({ items: z.array(blockTypeSchema) })
+	.meta({ id: "BlockTypeListResponse" });
+
 export const orphanedTableSchema = z
 	.object({
 		slug: z.string(),

package/src/api/schemas/settings.ts

@@ -27,7 +27,7 @@ const socialSettings = z.object({
 
 const seoSettingsInput = z.object({
 	titleSeparator: z.string().max(10).optional(),
-	defaultOgImage: mediaReferenceInput.optional(),
+	defaultOgImage: mediaReferenceInput.nullable().optional(),
 	robotsTxt: z.string().max(5000).optional(),
 	googleVerification: z.string().max(100).optional(),
 	bingVerification: z.string().max(100).optional(),
@@ -37,8 +37,8 @@ export const settingsUpdateBody = z
 	.object({
 		title: z.string().optional(),
 		tagline: z.string().optional(),
-		logo: mediaReferenceInput.optional(),
-		favicon: mediaReferenceInput.optional(),
+		logo: mediaReferenceInput.nullable().optional(),
+		favicon: mediaReferenceInput.nullable().optional(),
 		url: z.union([httpUrl, z.literal("")]).optional(),
 		postsPerPage: z.number().int().min(1).max(100).optional(),
 		dateFormat: z.string().optional(),

package/src/api/schemas/taxonomies.ts

@@ -65,6 +65,24 @@ export const createTermBody = z
 	})
 	.meta({ id: "CreateTermBody" });
 
+export const bulkTagBody = z
+	.object({
+		termId: z.string().min(1),
+		apply: z.boolean().default(false),
+		refreshOnly: z.boolean().optional(),
+		items: z
+			.array(
+				z.union([
+					z.object({ collection: collectionSlug, id: z.string().min(1) }).strict(),
+					z.object({ url: z.string().min(1).max(2048) }).strict(),
+				]),
+			)
+			.min(1)
+			.max(50),
+	})
+	.strict()
+	.meta({ id: "BulkTagBody" });
+
 export const updateTermBody = z
 	.object({
 		slug: z.string().min(1).optional(),

package/src/api/schemas/transfer.ts

@@ -0,0 +1,249 @@
+import { z } from "zod";
+
+import {
+	siteImportDecisionsInputSchema,
+	siteImportPlanSchema,
+} from "../../transfer/format/plan.js";
+import { APPROVAL_STATUSES } from "../../transfer/ops/approvals.js";
+import { EXPORT_STATES, IMPORT_STATES } from "../../transfer/ops/states.js";
+
+const sha256DigestSchema = z.string().regex(/^sha256:[0-9a-f]{64}$/);
+
+export const transferPaginationQuery = z.object({
+	cursor: z.string().min(1).max(2048).optional().meta({
+		description: "Opaque cursor from the previous page's `nextCursor`",
+	}),
+	limit: z.coerce.number().int().min(1).max(100).optional().default(50).meta({
+		description: "Maximum number of items to return (1-100, default 50)",
+	}),
+});
+
+export const transferApprovalListQuery = transferPaginationQuery.extend({
+	status: z
+		.enum(APPROVAL_STATUSES)
+		.optional()
+		.meta({ description: "Only approvals in this status" }),
+});
+
+export const transferImportAnalyzeBody = z
+	.object({
+		decisions: siteImportDecisionsInputSchema.optional().meta({
+			description:
+				"Principal mappings and site title/tagline choices. Applied once analysis has produced a plan; omitted values keep the plan's defaults.",
+		}),
+	})
+	.meta({ id: "TransferImportAnalyzeBody" });
+
+export const transferOperationSchema = z
+	.object({
+		id: z.string(),
+		kind: z.enum(["export", "import"]),
+		state: z.union([z.enum(EXPORT_STATES), z.enum(IMPORT_STATES)]),
+		stage: z.string().nullable(),
+		cursor: z.unknown().nullable(),
+		progress: z
+			.object({
+				done: z.number().int().min(0),
+				total: z.number().int().min(0),
+				records: z.number().int().min(0).optional().meta({
+					description: "Records an export has written so far",
+				}),
+				bytesDone: z.number().int().min(0).optional(),
+				bytesTotal: z.number().int().min(0).optional(),
+			})
+			.nullable(),
+		options: z.unknown(),
+		idempotencyKey: z.string().nullable(),
+		packageDigest: sha256DigestSchema.nullable(),
+		planDigest: sha256DigestSchema.nullable(),
+		originSiteId: z.string().nullable(),
+		receipt: z.unknown().nullable(),
+		errorCode: z.string().nullable(),
+		errorDetail: z.record(z.string(), z.unknown()).nullable(),
+		writeEpoch: z.number().int(),
+		attemptCount: z.number().int(),
+		leaseExpiresAt: z.string().nullable(),
+		runtimeGeneration: z.number().int(),
+		cancelRequestedAt: z.string().nullable(),
+		mutationStartedAt: z.string().nullable(),
+		createdBy: z.string(),
+		createdAt: z.string(),
+		updatedAt: z.string(),
+		completedAt: z.string().nullable(),
+		expiresAt: z.string().nullable(),
+		stagingCollectedAt: z.string().nullable(),
+	})
+	.meta({ id: "TransferOperation" });
+
+export const transferOperationResponseSchema = z
+	.object({ operation: transferOperationSchema })
+	.meta({ id: "TransferOperationResponse" });
+
+export const transferOperationListResponseSchema = z
+	.object({
+		items: z.array(transferOperationSchema),
+		nextCursor: z.string().optional(),
+	})
+	.meta({ id: "TransferOperationListResponse" });
+
+export const transferMissingFileSchema = z
+	.object({
+		path: z.string(),
+		bytes: z.number().int().min(0),
+		sha256: z.string().regex(/^[0-9a-f]{64}$/),
+	})
+	.meta({ id: "TransferMissingFile" });
+
+export const transferMissingFilesResponseSchema = z
+	.object({
+		items: z.array(transferMissingFileSchema),
+		nextCursor: z.string().optional(),
+	})
+	.meta({ id: "TransferMissingFilesResponse" });
+
+export const transferImportCreateResponseSchema = z
+	.object({
+		operation: transferOperationSchema,
+		created: z.boolean(),
+		missing: transferMissingFilesResponseSchema,
+	})
+	.meta({ id: "TransferImportCreateResponse" });
+
+export const transferImportStatusResponseSchema = z
+	.object({
+		operation: transferOperationSchema,
+		files: z.object({
+			declared: z.number().int().min(0),
+			verified: z.number().int().min(0),
+		}),
+	})
+	.meta({ id: "TransferImportStatusResponse" });
+
+export const transferFileUploadResponseSchema = z
+	.object({
+		path: z.string(),
+		bytes: z.number().int().min(0),
+		alreadyVerified: z.boolean(),
+		remaining: z.number().int().min(0),
+	})
+	.meta({ id: "TransferFileUploadResponse" });
+
+export const transferImportAnalyzeResponseSchema = z
+	.object({
+		operation: transferOperationSchema,
+		plan: siteImportPlanSchema.optional(),
+		planDigest: sha256DigestSchema.optional(),
+		nextRequestInMs: z.number().int().min(0).nullable(),
+	})
+	.meta({ id: "TransferImportAnalyzeResponse" });
+
+export const transferImportPlanResponseSchema = z
+	.object({
+		plan: siteImportPlanSchema,
+		planDigest: sha256DigestSchema,
+	})
+	.meta({ id: "TransferImportPlanResponse" });
+
+export const transferCapabilitiesSchema = z
+	.object({
+		formatVersions: z.array(z.string()),
+		features: z.array(z.string()),
+		optionalFeatures: z.array(z.string()),
+		limits: z.object({
+			manifestBytes: z.number().int(),
+			recordLineBytes: z.number().int(),
+			chunkBytes: z.number().int(),
+			chunkRecords: z.number().int(),
+			totalRecords: z.number().int(),
+			totalFiles: z.number().int(),
+			indexChunks: z.number().int(),
+			jsonDepth: z.number().int(),
+			maxBlobBytes: z.number().int(),
+		}),
+		portableDomain: z.object({
+			empty: z.boolean(),
+			blockers: z.array(z.record(z.string(), z.string())),
+			seededScaffold: z.array(z.record(z.string(), z.string())),
+		}),
+	})
+	.meta({ id: "TransferCapabilities" });
+
+export const transferApprovalSchema = z
+	.object({
+		id: z.string(),
+		status: z.enum(APPROVAL_STATUSES),
+		action: z.enum(["export", "import"]),
+		userId: z.string(),
+		requestedByTokenId: z.string().nullable(),
+		approvedBy: z.string().nullable(),
+		operationId: z.string().nullable(),
+		paramsDigest: sha256DigestSchema.nullable(),
+		packageDigest: sha256DigestSchema.nullable(),
+		planDigest: sha256DigestSchema.nullable(),
+		expiresAt: z.string(),
+		createdAt: z.string(),
+		decidedAt: z.string().nullable(),
+		consumedAt: z.string().nullable(),
+	})
+	.meta({ id: "TransferApproval" });
+
+export const transferApprovalResponseSchema = z
+	.object({ approval: transferApprovalSchema })
+	.meta({ id: "TransferApprovalResponse" });
+
+export const transferApprovalListResponseSchema = z
+	.object({
+		items: z.array(transferApprovalSchema),
+		nextCursor: z.string().optional(),
+	})
+	.meta({ id: "TransferApprovalListResponse" });
+
+export const transferImportExecuteBody = z
+	.object({
+		packageDigest: sha256DigestSchema,
+		planDigest: sha256DigestSchema,
+	})
+	.meta({ id: "TransferImportExecuteBody" });
+
+export const transferExportCreateBody = z
+	.strictObject({
+		comments: z.boolean().optional().meta({
+			description: "Include comments and reactions (default true)",
+		}),
+	})
+	.meta({ id: "TransferExportCreateBody" });
+
+export const transferExportCreateResponseSchema = z
+	.object({ operation: transferOperationSchema, created: z.boolean() })
+	.meta({ id: "TransferExportCreateResponse" });
+
+export const transferAdvanceResponseSchema = z
+	.object({
+		operation: transferOperationSchema,
+		nextRequestInMs: z.number().int().min(0).nullable(),
+	})
+	.meta({ id: "TransferAdvanceResponse" });
+
+export const transferImportReceiptSchema = z
+	.object({
+		operationId: z.string(),
+		packageDigest: sha256DigestSchema,
+		planDigest: sha256DigestSchema,
+		targetSiteId: z.string(),
+		originSiteId: z.string(),
+		formatVersion: z.string(),
+		importerEmDashVersion: z.string(),
+		completedAt: z.string(),
+		logicalDigest: sha256DigestSchema,
+		counts: z.record(z.string(), z.number().int().min(0)),
+		warnings: z.array(z.object({ code: z.string(), message: z.string() })),
+		verification: z.literal("verified"),
+		receiptDigest: sha256DigestSchema.meta({
+			description: "Digest of the canonical JSON of every other receipt field",
+		}),
+	})
+	.meta({ id: "TransferImportReceipt" });
+
+export const transferImportReceiptResponseSchema = z
+	.object({ receipt: transferImportReceiptSchema })
+	.meta({ id: "TransferImportReceiptResponse" });

package/src/api/transfer-download.ts

@@ -0,0 +1,36 @@
+import type { ExportFileStream } from "./handlers/transfer.js";
+
+const DOWNLOAD_HEADERS = {
+	"Cache-Control": "private, no-store",
+	"X-Content-Type-Options": "nosniff",
+};
+
+/** A downloaded package file: raw bytes with their size and SHA-256 ETag. */
+export function exportFileResponse(file: ExportFileStream): Response {
+	return new Response(file.body, {
+		status: 200,
+		headers: {
+			...DOWNLOAD_HEADERS,
+			"Content-Type":
+				file.path === "manifest.json" ? "application/json" : "application/octet-stream",
+			"Content-Length": String(file.bytes),
+			"Content-Disposition": "attachment",
+			ETag: `"${file.sha256}"`,
+		},
+	});
+}
+
+/** A streamed `.emdash` archive of an export. */
+export function exportArchiveResponse(
+	operationId: string,
+	body: ReadableStream<Uint8Array>,
+): Response {
+	return new Response(body, {
+		status: 200,
+		headers: {
+			...DOWNLOAD_HEADERS,
+			"Content-Type": "application/x-tar",
+			"Content-Disposition": `attachment; filename="emdash-site-${operationId}.emdash"`,
+		},
+	});
+}

package/src/api/types.ts

@@ -68,6 +68,8 @@ export interface ManifestFieldDescriptor extends FieldDescriptor {
 	widget?: string;
 	validation?: Record<string, unknown>;
 	unsupportedType?: { type: string; path: string };
+	blockTypes?: BlockType[];
+	blockTypeFingerprint?: string;
 }
 
 export interface FieldDescriptor {
@@ -108,3 +110,4 @@ export interface ApiContext {
 	userId?: string;
 	userRole?: string;
 }
+import type { BlockType } from "../schema/block-types.js";

package/src/astro/integration/routes.ts

@@ -428,6 +428,21 @@ export function injectCoreRoutes(
 		entrypoint: resolveRoute("api/schema/collections/index.ts"),
 	});
 
+	injectRoute({
+		pattern: "/_emdash/api/schema/block-types",
+		entrypoint: resolveRoute("api/schema/block-types/index.ts"),
+	});
+
+	injectRoute({
+		pattern: "/_emdash/api/schema/block-types/[slug]/versions/[version]/activate",
+		entrypoint: resolveRoute("api/schema/block-types/[slug]/versions/[version]/activate.ts"),
+	});
+
+	injectRoute({
+		pattern: "/_emdash/api/schema/block-types/[slug]",
+		entrypoint: resolveRoute("api/schema/block-types/[slug]/index.ts"),
+	});
+
 	// Order matters: the static `reorder` route must precede the dynamic
 	// `[slug]` route so Astro's resolver dispatches POST
 	// /schema/collections/reorder to the reorder handler instead of treating
@@ -501,6 +516,12 @@ export function injectCoreRoutes(
 		entrypoint: resolveRoute("api/settings/backups/archives/[name].ts"),
 	});
 
+	// Site transfer routes
+	injectRoute({
+		pattern: "/_emdash/api/admin/transfer/[...path]",
+		entrypoint: resolveRoute("api/admin/transfer/[...path].ts"),
+	});
+
 	// Snapshot route (for DO preview database population)
 	injectRoute({
 		pattern: "/_emdash/api/snapshot",
@@ -513,6 +534,11 @@ export function injectCoreRoutes(
 		entrypoint: resolveRoute("api/taxonomies/index.ts"),
 	});
 
+	injectRoute({
+		pattern: "/_emdash/api/taxonomies/bulk-tag",
+		entrypoint: resolveRoute("api/taxonomies/bulk-tag.ts"),
+	});
+
 	injectRoute({
 		pattern: "/_emdash/api/taxonomies/[name]",
 		entrypoint: resolveRoute("api/taxonomies/[name].ts"),
@@ -615,6 +641,11 @@ export function injectCoreRoutes(
 		entrypoint: resolveRoute("api/admin/plugins/registry/artifact.ts"),
 	});
 
+	injectRoute({
+		pattern: "/_emdash/api/admin/plugins/registry/publisher-handle",
+		entrypoint: resolveRoute("api/admin/plugins/registry/publisher-handle.ts"),
+	});
+
 	injectRoute({
 		pattern: "/_emdash/api/admin/plugins/registry/[id]/update",
 		entrypoint: resolveRoute("api/admin/plugins/registry/[id]/update.ts"),