emdash 1.1.0 → 1.3.0

package/src/plugins/adapt-sandbox-entry.ts

@@ -13,6 +13,7 @@
 import { z } from "zod";
 
 import type { PluginDescriptor } from "../astro/integration/runtime.js";
+import { safeJsonSchemaToZod } from "../mcp/json-schema.js";
 import type { RouteEntry, RouteHandler, SandboxedPlugin } from "../plugin-types.js";
 import { PLUGIN_CAPABILITIES, HOOK_NAMES } from "./manifest-schema.js";
 import { sanitizeHeadersForSandbox } from "./request-meta.js";
@@ -355,7 +356,10 @@ export function adaptSandboxEntry(
 				// `emdash-plugin build` removes `mcp` from the runtime module and
 				// ships the tools in the descriptor instead.
 				...Object.fromEntries(
-					(descriptor.mcp?.tools ?? []).map((tool) => [tool.name, toolFromManifest(tool)]),
+					(descriptor.mcp?.tools ?? []).map((tool) => [
+						tool.name,
+						toolFromManifest(tool, pluginId),
+					]),
 				),
 				...Object.fromEntries(
 					Object.entries(definition.mcp?.tools ?? {}).map(([name, tool]) => [
@@ -380,21 +384,27 @@ export function adaptSandboxEntry(
  * on first use: turning JSON Schema back into Zod takes milliseconds per
  * tool, and this adapter runs on every cold start, public requests included.
  */
-function toolFromManifest(tool: ManifestMcpTool): PluginMcpToolDefinition {
+function toolFromManifest(tool: ManifestMcpTool, pluginId: string): PluginMcpToolDefinition {
 	let input: z.ZodType | undefined;
-	let output: z.ZodType | undefined;
+	let output: z.ZodType | null | undefined;
 	return {
 		description: tool.description,
 		route: tool.route,
 		destructive: tool.destructive,
 		get input() {
-			input ??= z.fromJSONSchema({ ...tool.inputSchema });
+			input ??=
+				safeJsonSchemaToZod({ ...tool.inputSchema }, `${pluginId}/${tool.name}`, "input") ??
+				z.record(z.string(), z.unknown());
 			return input;
 		},
 		get output() {
 			if (!tool.outputSchema) return undefined;
-			output ??= z.fromJSONSchema({ ...tool.outputSchema });
-			return output;
+			if (output === undefined) {
+				output =
+					safeJsonSchemaToZod({ ...tool.outputSchema }, `${pluginId}/${tool.name}`, "output") ??
+					null;
+			}
+			return output ?? undefined;
 		},
 	};
 }

package/src/plugins/context.ts

@@ -1394,7 +1394,7 @@ const TRAILING_SLASH_RE = /\/$/;
 export interface SiteInfoOptions {
 	/** Site name from options table */
 	siteName?: string;
-	/** Site URL from options table or Astro config */
+	/** Site URL, resolved by the runtime in the same order as links in emails */
 	siteUrl?: string;
 	/** Site locale from options table */
 	locale?: string;
@@ -1403,12 +1403,8 @@ export interface SiteInfoOptions {
 }
 
 /**
- * Create site info from config and settings.
- *
- * Resolution order for URL:
- * 1. options table (emdash:site_url)
- * 2. Astro `site` config
- * 3. fallback to empty string
+ * Create site info from config and settings. A missing URL becomes an
+ * empty string.
  */
 export function createSiteInfo(options: SiteInfoOptions): SiteInfo {
 	return {

package/src/plugins/hooks.ts

@@ -1549,7 +1549,7 @@ export interface ExclusiveHookResolutionOptions {
 }
 
 /** Options table key prefix for exclusive hook selections */
-const EXCLUSIVE_HOOK_KEY_PREFIX = "emdash:exclusive_hook:";
+export const EXCLUSIVE_HOOK_KEY_PREFIX = "emdash:exclusive_hook:";
 
 /**
  * Resolve exclusive hook selections.

package/src/plugins/http-route-dispatch.ts

@@ -131,7 +131,11 @@ export async function dispatchPluginApiRequest({
 				? "Plugin route error"
 				: (result.error?.message ?? "Plugin route error");
 		const status = (result as { status?: number }).status ?? (code === "NOT_FOUND" ? 404 : 400);
-		return apiError(code, message, status);
+		const details =
+			code !== "INTERNAL_ERROR" && result.error && "details" in result.error
+				? result.error.details
+				: undefined;
+		return apiError(code, message, status, isRecord(details) ? details : undefined);
 	}
 
 	let response: Response;

package/src/plugins/manifest-schema.ts

@@ -237,6 +237,7 @@ const adminPageSchema = z.object({
 	path: z.string(),
 	label: z.string(),
 	icon: z.string().optional(),
+	group: z.string().trim().min(1).max(100).optional(),
 });
 
 const dashboardWidgetSchema = z.object({

package/src/plugins/route-error.ts

@@ -55,3 +55,17 @@ export class PluginRouteError extends Error {
 		return new PluginRouteError("INTERNAL_ERROR", message, 500);
 	}
 }
+
+/**
+ * Check whether a thrown value is a PluginRouteError.
+ *
+ * Also matches on shape, not just `instanceof`: under `astro dev`, Vite can load a
+ * plugin's `emdash` import as a separate module instance, so the error the plugin
+ * throws comes from a different copy of this class.
+ */
+export function isPluginRouteError(error: unknown): error is PluginRouteError {
+	if (error instanceof PluginRouteError) return true;
+	if (!(error instanceof Error) || error.name !== "PluginRouteError") return false;
+	const { code, status } = error as Partial<PluginRouteError>;
+	return typeof code === "string" && typeof status === "number";
+}

package/src/plugins/routes.ts

@@ -20,7 +20,7 @@ import { z } from "zod";
 import { SiteWriteBlockedError } from "../transfer/fence.js";
 import { PluginContextFactory, type PluginContextFactoryOptions } from "./context.js";
 import { extractRequestMeta } from "./request-meta.js";
-import { PluginRouteError } from "./route-error.js";
+import { isPluginRouteError, PluginRouteError } from "./route-error.js";
 import { parseDeclaredPluginRouteInput } from "./route-wire.js";
 import type { ResolvedPlugin, RouteContext, PluginRoute, UserInfo } from "./types.js";
 
@@ -293,7 +293,7 @@ export class PluginRouteHandler {
 				};
 			}
 			// Handle known error types
-			if (error instanceof PluginRouteError) {
+			if (isPluginRouteError(error)) {
 				return {
 					success: false,
 					error: {

package/src/plugins/state.ts

@@ -208,6 +208,42 @@ export class PluginStateRepository {
 		return (await this.get(pluginId))!;
 	}
 
+	/**
+	 * Insert an active state row unless the plugin already has one.
+	 *
+	 * Returns true only for the caller whose insert created the row, so
+	 * concurrent callers agree on a single owner for one-time setup.
+	 */
+	async createActiveIfAbsent(
+		pluginId: string,
+		version: string,
+		source: PluginSource,
+	): Promise<boolean> {
+		const now = new Date().toISOString();
+		const inserted = await this.db
+			.insertInto("_plugin_state")
+			.values({
+				plugin_id: pluginId,
+				status: "active",
+				version,
+				installed_at: now,
+				activated_at: now,
+				deactivated_at: null,
+				data: null,
+				source,
+				marketplace_version: null,
+				display_name: null,
+				description: null,
+				registry_publisher_did: null,
+				registry_slug: null,
+				mcp_tools_consent: null,
+			})
+			.onConflict((oc) => oc.column("plugin_id").doNothing())
+			.returning("plugin_id")
+			.executeTakeFirst();
+		return inserted !== undefined;
+	}
+
 	async restoreIfVersion(expectedVersion: string, state: PluginState): Promise<boolean> {
 		const result = await this.db
 			.updateTable("_plugin_state")
@@ -262,14 +298,11 @@ export class PluginStateRepository {
 }
 
 /**
- * Internal: map a `_plugin_state` row to the public `PluginState` shape.
- *
- * Kept at module scope so the three select paths (`get`, `getAll`,
- * `getMarketplacePlugins`, `getRegistryPlugins`) stay byte-identical in
- * their handling of nullable columns -- adding a new column to the table
- * means changing this function and nothing else.
+ * Map a `_plugin_state` row to the public `PluginState` shape. Every read
+ * path uses this, so adding a column to the table means changing this
+ * function and nothing else.
  */
-interface PluginStateRow {
+export interface PluginStateRow {
 	plugin_id: string;
 	status: string;
 	version: string;
@@ -286,7 +319,7 @@ interface PluginStateRow {
 	mcp_tools_consent: string | null;
 }
 
-function rowToPluginState(row: PluginStateRow): PluginState {
+export function rowToPluginState(row: PluginStateRow): PluginState {
 	return {
 		pluginId: row.plugin_id,
 		status: toPluginStatus(row.status),

package/src/plugins/types.ts

@@ -1969,6 +1969,12 @@ export interface PluginAdminPage {
 	path: string;
 	label: string;
 	icon?: string;
+	/**
+	 * Admin sidebar folder. Pages sharing a group with a collection shown in
+	 * the sidebar join that folder; pages with any other group share a folder
+	 * with that label in the Plugins section, across plugins.
+	 */
+	group?: string;
 }
 
 /**

package/src/query.ts

@@ -426,19 +426,57 @@ export function getEditMeta(value: unknown): EditFieldMeta | undefined {
 	return undefined;
 }
 
+/** Slugs of a collection's Portable Text fields; empty when they can't be read. */
+function getPortableTextFieldSlugs(collection: string): Promise<ReadonlySet<string>> {
+	return requestCached(`portable-text-fields:${collection}`, async () => {
+		try {
+			const { getDb } = await import("./loader.js");
+			const db = await getDb();
+			const rows = await db
+				.selectFrom("_emdash_fields as f")
+				.innerJoin("_emdash_collections as c", "c.id", "f.collection_id")
+				.select("f.slug")
+				.where("c.slug", "=", collection)
+				.where("f.type", "=", "portableText")
+				.execute();
+			return new Set(rows.map((row) => row.slug));
+		} catch (error) {
+			if (!isMissingTableError(error)) {
+				const msg = error instanceof Error ? error.message : String(error);
+				console.warn("[emdash] Failed to load Portable Text fields:", msg);
+			}
+			return new Set<string>();
+		}
+	});
+}
+
 /**
  * Tag PT-like arrays in entry data with edit metadata (non-enumerable).
  * A PT array is identified by: is an array, first element has _type property.
+ * An empty one is identified by its field being in `portableTextFields`, and
+ * a missing or blank one becomes an empty array, so the page can still render
+ * an editor for it.
  */
-function tagEditableFields(data: Record<string, unknown>, collection: string, id: string): void {
+function tagEditableFields(
+	data: Record<string, unknown>,
+	collection: string,
+	id: string,
+	portableTextFields: ReadonlySet<string> = new Set(),
+): void {
+	for (const field of portableTextFields) {
+		const value = data[field];
+		if (value == null || (typeof value === "string" && !value.trim())) {
+			data[field] = [];
+		}
+	}
 	for (const [field, value] of Object.entries(data)) {
-		if (
-			Array.isArray(value) &&
-			value.length > 0 &&
-			value[0] &&
-			typeof value[0] === "object" &&
-			"_type" in value[0]
-		) {
+		if (!Array.isArray(value)) continue;
+		const first: unknown = value[0];
+		const isPortableText =
+			value.length === 0
+				? portableTextFields.has(field)
+				: typeof first === "object" && first !== null && "_type" in first;
+		if (isPortableText) {
 			Object.defineProperty(value, EMDASH_EDIT, {
 				value: { collection, id, field } satisfies EditFieldMeta,
 				enumerable: false,
@@ -907,6 +945,13 @@ async function getEmDashCollectionUncached<T extends string, D = InferCollection
 			: filter?.offset !== undefined
 				? { offset: filter.offset }
 				: {};
+	// Same draft access as `getEmDashEntry`: editors see every entry's draft,
+	// a preview token only the draft of the entry it was issued for.
+	const draftRevisions = ctx?.editMode
+		? "all"
+		: ctx?.preview?.collection === type
+			? { id: ctx.preview.id }
+			: undefined;
 	const result = await getLiveCollection(COLLECTION_NAME, {
 		type,
 		status: filter?.status,
@@ -915,6 +960,7 @@ async function getEmDashCollectionUncached<T extends string, D = InferCollection
 		where: filter?.where,
 		orderBy: filter?.orderBy,
 		locale: resolvedLocale,
+		draftRevisions,
 	});
 
 	const { entries, error, cacheHint } = result;
@@ -931,10 +977,12 @@ async function getEmDashCollectionUncached<T extends string, D = InferCollection
 	const hasMoreResult = requestedLimit != null && requestedLimit > 0 ? hasMore : undefined;
 
 	const isEditMode = ctx?.editMode ?? false;
+	const portableTextFields =
+		isEditMode && pageEntries.length > 0 ? await getPortableTextFieldSlugs(type) : undefined;
 	const entriesWithEdit = pageEntries.map((entry: ContentEntry<D>) => {
 		const dbId = entryDatabaseId(entry);
 		if (isEditMode) {
-			tagEditableFields(entryData(entry), type, dbId);
+			tagEditableFields(entryData(entry), type, dbId, portableTextFields);
 		}
 		if (!canExposeRevisionMetadata(entry, type)) {
 			stripRevisionMetadata(entry);
@@ -1151,12 +1199,13 @@ async function resolveEmDashEntry<T extends string, D = InferCollectionData<T>>(
 	// Resolve locale: explicit option > ALS context > undefined (no filter)
 	const requestedLocale = options?.locale ?? ctx?.locale;
 	const references = options?.references;
+	const portableTextFields = isEditMode ? await getPortableTextFieldSlugs(type) : undefined;
 
 	/** Wrap a raw Astro entry with edit proxy, tagging editable fields if needed */
 	function wrapEntry(raw: ContentEntry<D>): ContentEntry<D> {
 		const dbId = entryDatabaseId(raw);
 		if (isEditMode) {
-			tagEditableFields(entryData(raw), type, dbId);
+			tagEditableFields(entryData(raw), type, dbId, portableTextFields);
 		}
 		return {
 			...raw,

package/src/redirects/cache.ts

@@ -9,7 +9,8 @@
  * A cold isolate loads the rules from its source and waits for them. Once
  * warm, requests never wait: an expired cache keeps serving while one
  * background revalidation asks the source whether the loaded version is still
- * current and reloads only when it is not.
+ * current and reloads only when it is not. A caller that must not act on stale
+ * rules asks for them to be verified, and waits for that check.
  *
  * This module deliberately has NO Astro imports so it can be safely imported
  * from handlers, seed, CLI, and tests without dragging in `astro:middleware`.
@@ -147,9 +148,40 @@ function revalidateInBackground(source: RedirectSource, cached: CachedRedirects)
 	});
 }
 
-export async function loadCachedRedirects(source: RedirectSource): Promise<CachedRedirects> {
+export interface LoadCachedRedirectsOptions {
+	/**
+	 * Confirm the cached rules are current before returning them, reloading
+	 * them when they are not, instead of revalidating in the background. If the
+	 * check fails, the cached rules are returned.
+	 */
+	verify?: boolean;
+}
+
+export async function loadCachedRedirects(
+	source: RedirectSource,
+	options: LoadCachedRedirectsOptions = {},
+): Promise<CachedRedirects> {
+	let verify = options.verify === true;
 	for (let attempt = 0; attempt < REDIRECT_CACHE_MAX_REFRESH_ATTEMPTS; attempt++) {
 		const cached = cacheState.redirects;
+		if (cached && verify) {
+			verify = false;
+			let current: boolean;
+			try {
+				current = cached.version !== null && (await source.isCurrent(cached.version));
+			} catch (error) {
+				console.error("[emdash:redirects] checking redirects are current failed:", error);
+				return cached;
+			}
+			if (current) {
+				if (cacheState.redirects === cached) {
+					cacheState.expiresAt = Date.now() + REDIRECT_CACHE_TTL_MS;
+				}
+				return cached;
+			}
+			if (cacheState.redirects === cached) invalidateRedirectCache();
+			continue;
+		}
 		if (cached) {
 			if (Date.now() >= cacheState.expiresAt) revalidateInBackground(source, cached);
 			return cached;

package/src/redirects/patterns.ts

@@ -160,20 +160,44 @@ export function compilePattern(source: string): CompiledPattern {
 	};
 }
 
+function toggledTrailingSlash(path: string): string | null {
+	if (path.length <= 1) return null;
+	return path.endsWith("/") ? path.slice(0, -1) : `${path}/`;
+}
+
 /**
  * Match a path against a compiled pattern.
  * Returns captured params or null if no match.
+ *
+ * Trailing slashes are ignored so `/category/arts/feed` and
+ * `/category/arts/feed/` match the same rule, consistent with exact and
+ * catch-all redirects.
  */
 export function matchPattern(
 	compiled: CompiledPattern,
 	path: string,
 ): Record<string, string> | null {
 	const match = path.match(compiled.regex);
-	if (!match) return null;
+	if (match) {
+		const params: Record<string, string> = {};
+		for (let i = 0; i < compiled.paramNames.length; i++) {
+			const value = match[i + 1];
+			if (value !== undefined) {
+				params[compiled.paramNames[i]] = value;
+			}
+		}
+		return params;
+	}
+
+	const alt = toggledTrailingSlash(path);
+	if (!alt) return null;
+
+	const altMatch = alt.match(compiled.regex);
+	if (!altMatch) return null;
 
 	const params: Record<string, string> = {};
 	for (let i = 0; i < compiled.paramNames.length; i++) {
-		const value = match[i + 1];
+		const value = altMatch[i + 1];
 		if (value !== undefined) {
 			params[compiled.paramNames[i]] = value;
 		}

package/src/schema/block-values.ts

@@ -141,6 +141,21 @@ function existingByKey(value: unknown, path: string): Map<string, Record<string,
 	return result;
 }
 
+function inferredBlockType(
+	field: Field,
+	block: Record<string, unknown>,
+	previous: Record<string, unknown> | undefined,
+	options: BlockWriteOptions,
+): unknown {
+	const allowedTypes = field.validation?.allowedTypes ?? [];
+	return block._type === undefined &&
+		!options.restoreBlocks &&
+		allowedTypes.length === 1 &&
+		(!previous || previous._type === allowedTypes[0])
+		? allowedTypes[0]
+		: block._type;
+}
+
 function normalizeBlockArray(
 	field: Field,
 	value: unknown,
@@ -174,7 +189,9 @@ function normalizeBlockArray(
 	return value.map((rawBlock, index) => {
 		const blockPath = `${path}[${index}]`;
 		if (!isRecord(rawBlock)) validationError(blockPath, "must be an object");
-		if (typeof rawBlock._type !== "string" || rawBlock._type.length === 0) {
+		const previous = typeof rawBlock._key === "string" ? existing.get(rawBlock._key) : undefined;
+		const blockTypeSlug = inferredBlockType(field, rawBlock, previous, options);
+		if (typeof blockTypeSlug !== "string" || blockTypeSlug.length === 0) {
 			validationError(`${blockPath}._type`, "must be a block type slug");
 		}
 		if (
@@ -192,19 +209,18 @@ function normalizeBlockArray(
 			validationError(`${blockPath}._key`, "must be a non-empty string");
 		}
 
-		const previous = typeof rawBlock._key === "string" ? existing.get(rawBlock._key) : undefined;
-		const type = types.get(rawBlock._type);
-		if (!type) unsupported(`${blockPath}._type`, `block type "${rawBlock._type}" is unavailable`);
+		const type = types.get(blockTypeSlug);
+		if (!type) unsupported(`${blockPath}._type`, `block type "${blockTypeSlug}" is unavailable`);
 		if (previous) {
-			if (previous._type !== rawBlock._type) {
+			if (previous._type !== blockTypeSlug) {
 				validationError(`${blockPath}._type`, "cannot change an existing block's type");
 			}
 		} else if (
-			!allowed.has(rawBlock._type) &&
-			!(options.restoreBlocks && retired.has(rawBlock._type))
+			!allowed.has(blockTypeSlug) &&
+			!(options.restoreBlocks && retired.has(blockTypeSlug))
 		) {
-			const reason = retired.has(rawBlock._type) ? "is retired" : "is not allowed by this field";
-			validationError(`${blockPath}._type`, `block type "${rawBlock._type}" ${reason}`);
+			const reason = retired.has(blockTypeSlug) ? "is retired" : "is not allowed by this field";
+			validationError(`${blockPath}._type`, `block type "${blockTypeSlug}" ${reason}`);
 		}
 
 		let version: number;
@@ -234,7 +250,7 @@ function normalizeBlockArray(
 		const definition = versionFor(type, version, `${blockPath}._version`);
 		const normalized: Record<string, unknown> = {
 			...rawBlock,
-			_type: rawBlock._type,
+			_type: blockTypeSlug,
 			_version: version,
 			_key: key,
 		};
@@ -258,7 +274,7 @@ function normalizeBlockArray(
 		}
 		return {
 			...normalized,
-			_type: rawBlock._type,
+			_type: blockTypeSlug,
 			_version: version,
 			_key: key,
 		};
@@ -274,16 +290,24 @@ export async function normalizeBlocksData(
 	partial = true,
 	resolvedTypes?: ResolvedBlockTypes,
 ): Promise<Record<string, unknown>> {
-	const blockFields = collection.fields.filter(
-		(field) => field.type === "blocks" && (!partial || Object.hasOwn(data, field.slug)),
-	);
-	if (blockFields.length === 0) return data;
-	const types = resolvedTypes ?? (await resolveBlockTypes(db));
 	const normalized = { ...data };
+	const blockFields: Field[] = [];
+	for (const field of collection.fields) {
+		if (field.type !== "blocks") continue;
+		// Left in place, an undefined value would replace the stored blocks in the
+		// draft merge and reach the column write as NULL.
+		if (partial && data[field.slug] === undefined) {
+			delete normalized[field.slug];
+		} else {
+			blockFields.push(field);
+		}
+	}
+	if (blockFields.length === 0) return normalized;
+	const types = resolvedTypes ?? (await resolveBlockTypes(db));
 	for (const field of blockFields) {
 		normalized[field.slug] = normalizeBlockArray(
 			field,
-			Object.hasOwn(data, field.slug) ? data[field.slug] : [],
+			data[field.slug] === undefined ? [] : data[field.slug],
 			existingData[field.slug],
 			types,
 			options,
@@ -291,3 +315,42 @@ export async function normalizeBlocksData(
 	}
 	return normalized;
 }
+
+/**
+ * Fill in the `_type` an ordinary write infers for blocks that omit it, so
+ * `content:beforeSave` hooks see the type the block will be stored with.
+ * `loadExistingData` is only called when some block omits `_type`.
+ */
+export async function inferBlockTypes(
+	collection: CollectionWithFields,
+	data: Record<string, unknown>,
+	loadExistingData: () => Promise<Record<string, unknown> | undefined>,
+): Promise<Record<string, unknown>> {
+	const untyped = collection.fields.flatMap((field) => {
+		const value = data[field.slug];
+		return field.type === "blocks" &&
+			Array.isArray(value) &&
+			value.some((block) => isRecord(block) && block._type === undefined)
+			? [{ field, value }]
+			: [];
+	});
+	if (untyped.length === 0) return data;
+	const existingData = (await loadExistingData()) ?? {};
+	const inferred = { ...data };
+	for (const { field, value } of untyped) {
+		const stored = existingData[field.slug];
+		inferred[field.slug] = value.map((block: unknown) => {
+			if (!isRecord(block)) return block;
+			const previous =
+				Array.isArray(stored) && typeof block._key === "string"
+					? stored.find(
+							(candidate: unknown): candidate is Record<string, unknown> =>
+								isRecord(candidate) && candidate._key === block._key,
+						)
+					: undefined;
+			const type = inferredBlockType(field, block, previous, {});
+			return type === block._type ? block : { ...block, _type: type };
+		});
+	}
+	return inferred;
+}

package/src/schema/registry.ts

@@ -10,6 +10,7 @@ import { sql } from "kysely";
 import { ulid } from "ulidx";
 
 import { refreshDevTypes } from "../astro/dev-typegen.js";
+import { deleteSharedCollectionRecords } from "../database/collection-cleanup.js";
 import {
 	columnExists,
 	currentTimestamp,
@@ -50,6 +51,7 @@ import type {
 } from "../transfer/schema-importer.js";
 import { chunks, SQL_BATCH_SIZE } from "../utils/chunks.js";
 import { resetRegisteredCollectionsCache } from "./collection-slugs-cache.js";
+import { MAX_SCHEMA_SLUG_LENGTH, SCHEMA_SLUG_PATTERN } from "./slug.js";
 import {
 	type Collection,
 	type CollectionAdminConfig,
@@ -76,7 +78,6 @@ import {
 import { compileUrlPattern } from "./url-pattern.js";
 
 // Regex patterns for schema registry
-const SLUG_VALIDATION_PATTERN = /^[a-z][a-z0-9_]*$/;
 const EC_PREFIX_PATTERN = /^ec_/;
 const SINGLE_QUOTE_PATTERN = /'/g;
 const UNDERSCORE_PATTERN = /_/g;
@@ -1211,11 +1212,18 @@ export class SchemaRegistry {
 				const ftsManager = new FTSManager(trx);
 				await ftsManager.dropFtsTable(slug);
 
-				// Drop the content table
+				// Drop the content table first: ec_* rows hold foreign keys to
+				// revisions.id, so the content table must go before revisions can
+				// be removed.
 				const tableName = this.getTableName(slug);
 				await sql`DROP TABLE IF EXISTS ${sql.ref(tableName)}`.execute(trx);
 				contentTableDropped = true;
 
+				// Remove shared-table records that are keyed by collection slug.
+				// Dropping the content table or deleting the collection row does not
+				// cascade to these, so they have to be cleared explicitly.
+				await deleteSharedCollectionRecords(trx, slug);
+
 				// Delete the collection record (fields will cascade)
 				await trx.deleteFrom("_emdash_collections").where("id", "=", existing.id).execute();
 			});
@@ -2331,15 +2339,18 @@ export class SchemaRegistry {
 			throw new SchemaError(`${type} slug is required`, "INVALID_SLUG");
 		}
 
-		if (!SLUG_VALIDATION_PATTERN.test(slug)) {
+		if (!SCHEMA_SLUG_PATTERN.test(slug)) {
 			throw new SchemaError(
 				`${type} slug must start with a letter and contain only lowercase letters, numbers, and underscores`,
 				"INVALID_SLUG",
 			);
 		}
 
-		if (slug.length > 63) {
-			throw new SchemaError(`${type} slug must be 63 characters or less`, "INVALID_SLUG");
+		if (slug.length > MAX_SCHEMA_SLUG_LENGTH) {
+			throw new SchemaError(
+				`${type} slug must be ${MAX_SCHEMA_SLUG_LENGTH} characters or less`,
+				"INVALID_SLUG",
+			);
 		}
 	}