emdash 0.2.0 → 0.4.0

package/src/astro/routes/api/comments/[collection]/[contentId]/index.ts

@@ -15,6 +15,7 @@ import { getSiteBaseUrl } from "#api/site-url.js";
 import { sendCommentNotification } from "#comments/notifications.js";
 import { createComment, type CommentHookRunner } from "#comments/service.js";
 import { CommentRepository } from "#db/repositories/comment.js";
+import { validateIdentifier } from "#db/validate.js";
 import { extractRequestMeta } from "#plugins/request-meta.js";
 import type { CollectionCommentSettings, ModerationDecision } from "#plugins/types.js";
 
@@ -106,6 +107,7 @@ export const POST: APIRoute = async ({ params, request, locals }) => {
 		}
 
 		// Verify the content item exists, is published, and not soft-deleted
+		validateIdentifier(collection, "collection");
 		const contentRow = await emdash.db
 			.selectFrom(`ec_${collection}` as never)
 			.select(["id" as never, "slug" as never, "author_id" as never, "published_at" as never])

package/src/astro/routes/api/import/wordpress/rewrite-urls.ts

@@ -17,6 +17,7 @@ import { requirePerm } from "#api/authorize.js";
 import { apiError, apiSuccess, handleError } from "#api/error.js";
 import { isParseError, parseBody } from "#api/parse.js";
 import { wpRewriteUrlsBody } from "#api/schemas.js";
+import { validateIdentifier } from "#db/validate.js";
 import { normalizeMediaValue } from "#media/normalize.js";
 import type { MediaProvider } from "#media/types.js";
 import type { EmDashHandlers } from "#types";
@@ -280,6 +281,7 @@ async function rewriteUrls(
 			continue;
 
 		// Get table name
+		validateIdentifier(collection.slug, "collection slug");
 		const tableName = `ec_${collection.slug}`;
 
 		try {

package/src/astro/routes/api/manifest.ts

@@ -11,6 +11,7 @@ import type { APIRoute } from "astro";
 
 import { getAuthMode } from "#auth/mode.js";
 
+import { COMMIT, VERSION } from "../../../version.js";
 import type { EmDashManifest } from "../../types.js";
 
 export const prerender = false;
@@ -43,7 +44,8 @@ export const GET: APIRoute = async ({ locals }) => {
 				signupEnabled,
 			}
 		: {
-				version: "0.1.0",
+				version: VERSION,
+				commit: COMMIT,
 				hash: "default",
 				collections: {},
 				plugins: {},

package/src/astro/routes/api/redirects/[id].ts

@@ -17,6 +17,7 @@ import {
 } from "#api/handlers/redirects.js";
 import { isParseError, parseBody } from "#api/parse.js";
 import { updateRedirectBody } from "#api/schemas.js";
+import { invalidateRedirectCache } from "#redirects/cache.js";
 
 export const prerender = false;
 
@@ -57,6 +58,7 @@ export const PUT: APIRoute = async ({ params, request, locals }) => {
 		if (isParseError(body)) return body;
 
 		const result = await handleRedirectUpdate(db, id, body);
+		invalidateRedirectCache();
 		return unwrapResult(result);
 	} catch (error) {
 		return handleError(error, "Failed to update redirect", "REDIRECT_UPDATE_ERROR");
@@ -77,6 +79,7 @@ export const DELETE: APIRoute = async ({ params, locals }) => {
 
 	try {
 		const result = await handleRedirectDelete(db, id);
+		invalidateRedirectCache();
 		return unwrapResult(result);
 	} catch (error) {
 		return handleError(error, "Failed to delete redirect", "REDIRECT_DELETE_ERROR");

package/src/astro/routes/api/redirects/index.ts

@@ -12,6 +12,7 @@ import { handleError, unwrapResult } from "#api/error.js";
 import { handleRedirectCreate, handleRedirectList } from "#api/handlers/redirects.js";
 import { isParseError, parseBody, parseQuery } from "#api/parse.js";
 import { createRedirectBody, redirectsListQuery } from "#api/schemas.js";
+import { invalidateRedirectCache } from "#redirects/cache.js";
 
 export const prerender = false;
 
@@ -45,6 +46,7 @@ export const POST: APIRoute = async ({ request, locals }) => {
 		if (isParseError(body)) return body;
 
 		const result = await handleRedirectCreate(db, body);
+		invalidateRedirectCache();
 		return unwrapResult(result, 201);
 	} catch (error) {
 		return handleError(error, "Failed to create redirect", "REDIRECT_CREATE_ERROR");

package/src/astro/routes/api/schema/collections/[slug]/index.ts

@@ -59,6 +59,7 @@ export const PUT: APIRoute = async ({ params, request, locals }) => {
 		// eslint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- parseBody validates via Zod
 		body as UpdateCollectionInput,
 	);
+	emdash!.invalidateManifest();
 	return unwrapResult(result);
 };
 
@@ -76,5 +77,6 @@ export const DELETE: APIRoute = async ({ params, url, locals }) => {
 	const result = await handleSchemaCollectionDelete(emdash!.db, slug, {
 		force,
 	});
+	emdash!.invalidateManifest();
 	return unwrapResult(result);
 };

package/src/astro/routes/api/schema/collections/index.ts

@@ -43,5 +43,6 @@ export const POST: APIRoute = async ({ request, locals }) => {
 
 	// eslint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- Zod schema output narrowed to CreateCollectionInput
 	const result = await handleSchemaCollectionCreate(emdash!.db, body as CreateCollectionInput);
+	emdash!.invalidateManifest();
 	return unwrapResult(result, 201);
 };

package/src/astro/storage/adapters.ts

@@ -32,20 +32,34 @@ import type { StorageDescriptor, S3StorageConfig, LocalStorageConfig } from "./t
 /**
  * S3-compatible storage adapter
  *
- * Works with AWS S3, Cloudflare R2 (via S3 API), Minio, etc.
+ * Works with AWS S3, Cloudflare R2 (via S3 API), MinIO, etc.
+ *
+ * Any field omitted here is resolved from the matching `S3_*` environment
+ * variable when the container starts (`S3_ENDPOINT`, `S3_BUCKET`,
+ * `S3_ACCESS_KEY_ID`, `S3_SECRET_ACCESS_KEY`, `S3_REGION`, `S3_PUBLIC_URL`).
+ * Explicit values always take precedence over env vars.
+ *
+ * Note: env var resolution reads `process.env` on Node at runtime.
+ * Workers users should continue passing explicit values to `s3({...})`.
  *
  * @example
  * ```ts
+ * // All fields from env (container deployments)
+ * storage: s3()
+ *
+ * // Mix: CDN from config, credentials from env
+ * storage: s3({ publicUrl: "https://cdn.example.com" })
+ *
+ * // All explicit (unchanged from before)
  * storage: s3({
  *   endpoint: "https://xxx.r2.cloudflarestorage.com",
  *   bucket: "media",
- *   accessKeyId: process.env.R2_ACCESS_KEY_ID!,
- *   secretAccessKey: process.env.R2_SECRET_ACCESS_KEY!,
- *   publicUrl: "https://cdn.example.com", // optional CDN
+ *   accessKeyId: process.env.R2_ACCESS_KEY_ID,
+ *   secretAccessKey: process.env.R2_SECRET_ACCESS_KEY,
  * })
  * ```
  */
-export function s3(config: S3StorageConfig): StorageDescriptor {
+export function s3(config: Partial<S3StorageConfig> = {}): StorageDescriptor {
 	return {
 		entrypoint: "emdash/storage/s3",
 		config,

package/src/astro/storage/types.ts

@@ -39,10 +39,18 @@ export interface S3StorageConfig {
 	endpoint: string;
 	/** Bucket name */
 	bucket: string;
-	/** Access key ID */
-	accessKeyId: string;
-	/** Secret access key */
-	secretAccessKey: string;
+	/**
+	 * Access key ID.
+	 * May be resolved from the `S3_ACCESS_KEY_ID` env var at runtime on Node.
+	 * Must be provided together with `secretAccessKey`, or both omitted.
+	 */
+	accessKeyId?: string;
+	/**
+	 * Secret access key.
+	 * May be resolved from the `S3_SECRET_ACCESS_KEY` env var at runtime on Node.
+	 * Must be provided together with `accessKeyId`, or both omitted.
+	 */
+	secretAccessKey?: string;
 	/** Optional region (defaults to "auto") */
 	region?: string;
 	/** Optional public URL prefix for CDN */

package/src/astro/types.ts

@@ -102,6 +102,7 @@ export type ManifestAuthMode = string;
  */
 export interface EmDashManifest {
 	version: string;
+	commit?: string;
 	hash: string;
 	collections: Record<string, ManifestCollection>;
 	plugins: Record<string, ManifestPlugin>;

package/src/bylines/index.ts

@@ -14,6 +14,48 @@ import { validateIdentifier } from "../database/validate.js";
 import { getDb } from "../loader.js";
 import { chunks, SQL_BATCH_SIZE } from "../utils/chunks.js";
 
+/**
+ * Cached result of "does any byline exist in the database?"
+ * null = not yet checked, true/false = cached result.
+ * Invalidated when bylines are created or deleted.
+ */
+let hasBylines: boolean | null = null;
+
+/**
+ * Invalidate the cached "has any bylines" check.
+ * Call this when bylines are created, updated, or deleted.
+ */
+export function invalidateBylineCache(): void {
+	hasBylines = null;
+}
+
+/**
+ * Check if any bylines exist in the database. Result is cached
+ * for the lifetime of the worker/process and invalidated on writes.
+ */
+async function hasAnyBylines(): Promise<boolean> {
+	if (hasBylines !== null) return hasBylines;
+
+	try {
+		const db = await getDb();
+		const result = await sql<{ id: string }>`
+			SELECT id FROM _emdash_bylines LIMIT 1
+		`.execute(db);
+		hasBylines = result.rows.length > 0;
+	} catch (error: unknown) {
+		// Only treat "no such table" as a safe false -- anything else should
+		// not be cached so the next request retries.
+		const message = error instanceof Error ? error.message : "";
+		if (message.includes("no such table")) {
+			hasBylines = false;
+		} else {
+			return false;
+		}
+	}
+
+	return hasBylines;
+}
+
 /**
  * Get a byline by ID.
  *
@@ -134,6 +176,12 @@ export async function getBylinesForEntries(
 		return result;
 	}
 
+	// Skip DB queries entirely when no bylines have been created.
+	// The cache is invalidated when bylines are created/deleted.
+	if (!(await hasAnyBylines())) {
+		return result;
+	}
+
 	const db = await getDb();
 	const repo = new BylineRepository(db);
 
@@ -199,8 +247,8 @@ async function getAuthorId(
 	collection: string,
 	entryId: string,
 ): Promise<string | null> {
+	validateIdentifier(collection, "collection");
 	const tableName = `ec_${collection}`;
-	validateIdentifier(tableName, "content table");
 
 	const result = await sql<{ author_id: string | null }>`
 		SELECT author_id FROM ${sql.ref(tableName)}
@@ -220,8 +268,8 @@ async function getAuthorIds(
 	collection: string,
 	entryIds: string[],
 ): Promise<Map<string, string>> {
+	validateIdentifier(collection, "collection");
 	const tableName = `ec_${collection}`;
-	validateIdentifier(tableName, "content table");
 
 	const map = new Map<string, string>();
 	for (const chunk of chunks(entryIds, SQL_BATCH_SIZE)) {

package/src/cleanup.ts

@@ -121,11 +121,11 @@ export async function runSystemCleanup(
  * them down to REVISION_KEEP_COUNT.
  */
 async function pruneExcessiveRevisions(db: Kysely<Database>): Promise<number> {
-	const entries = await sql<{ collection: string; entry_id: string; cnt: number }>`
-		SELECT collection, entry_id, COUNT(*) as cnt
+	const entries = await sql<{ collection: string; entry_id: string }>`
+		SELECT collection, entry_id
 		FROM revisions
 		GROUP BY collection, entry_id
-		HAVING cnt > ${REVISION_PRUNE_THRESHOLD}
+		HAVING COUNT(*) > ${REVISION_PRUNE_THRESHOLD}
 	`.execute(db);
 
 	if (entries.rows.length === 0) return 0;

package/src/cli/commands/bundle-utils.ts

@@ -196,11 +196,7 @@ export async function resolveSourceEntry(
 ): Promise<string | undefined> {
 	const cleaned = distPath.replace(LEADING_DOT_SLASH_RE, "");
 
-	// Try the path directly (might be source already)
-	const direct = resolve(pluginDir, cleaned);
-	if (await fileExists(direct)) return direct;
-
-	// Convert dist path to src: dist/foo.mjs → src/foo.ts
+	// Prefer source over dist — dist/foo.mjs → src/foo.ts
 	const srcPath = cleaned.replace(DIST_PREFIX_RE, "src/").replace(MJS_EXT_RE, ".ts");
 	const srcFull = resolve(pluginDir, srcPath);
 	if (await fileExists(srcFull)) return srcFull;
@@ -210,6 +206,10 @@ export async function resolveSourceEntry(
 	const tsxFull = resolve(pluginDir, tsxPath);
 	if (await fileExists(tsxFull)) return tsxFull;
 
+	// Fall back to direct path (might be source already, or pre-compiled plugin)
+	const direct = resolve(pluginDir, cleaned);
+	if (await fileExists(direct)) return direct;
+
 	return undefined;
 }
 

package/src/database/dialect-helpers.ts

@@ -14,6 +14,7 @@ import type { ColumnDataType, Kysely, RawBuilder } from "kysely";
 import { sql } from "kysely";
 
 import type { DatabaseDialectType } from "../db/adapters.js";
+import { validateIdentifier, validateJsonFieldName } from "./validate.js";
 
 export type { DatabaseDialectType };
 
@@ -131,6 +132,8 @@ export function binaryType(db: Kysely<any>): ColumnDataType {
  */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any -- accepts any Kysely instance
 export function jsonExtractExpr(db: Kysely<any>, column: string, path: string): string {
+	validateIdentifier(column, "JSON column name");
+	validateJsonFieldName(path, "JSON path");
 	if (isPostgres(db)) {
 		return `${column}->>'${path}'`;
 	}

package/src/database/migrations/011_sections.ts

@@ -58,8 +58,8 @@ export async function up(db: Kysely<unknown>): Promise<void> {
 }
 
 export async function down(db: Kysely<unknown>): Promise<void> {
-	await db.schema.dropIndex("idx_content_taxonomies_term").execute();
-	await db.schema.dropIndex("idx_media_mime_type").execute();
+	await db.schema.dropIndex("idx_sections_source").execute();
+	await db.schema.dropIndex("idx_sections_category").execute();
 	await db.schema.dropTable("_emdash_sections").execute();
 	await db.schema.dropTable("_emdash_section_categories").execute();
 }

package/src/database/migrations/runner.ts

@@ -1,4 +1,4 @@
-import { type Kysely, type Migration, type MigrationProvider, Migrator } from "kysely";
+import { type Kysely, type Migration, type MigrationProvider, Migrator, sql } from "kysely";
 
 import type { Database } from "../types.js";
 // Import migrations statically for bundling
@@ -122,9 +122,30 @@ export async function getMigrationStatus(db: Kysely<Database>): Promise<Migratio
 }
 
 /**
- * Run all pending migrations
+ * Run all pending migrations.
+ *
+ * Includes a fast-path: if the migration table already exists and contains
+ * exactly MIGRATION_COUNT rows, all migrations have been applied and we can
+ * skip the Kysely Migrator entirely. This avoids the expensive
+ * `pragma_table_info` introspection that Kysely runs for every table in the
+ * database (twice!) just to check if the migration tables exist.
+ * On D1 with ~57 tables, that's ~116 queries saved per init.
  */
 export async function runMigrations(db: Kysely<Database>): Promise<{ applied: string[] }> {
+	// Fast path: check if all migrations are already applied.
+	// A single cheap query vs the Migrator's full schema introspection.
+	try {
+		const result = await sql<{ count: number }>`
+			SELECT COUNT(*) as count FROM ${sql.ref(MIGRATION_TABLE)}
+		`.execute(db);
+		if (result.rows[0]?.count === MIGRATION_COUNT) {
+			return { applied: [] };
+		}
+	} catch {
+		// Table doesn't exist yet (first run). Fall through to the Migrator
+		// which will create it.
+	}
+
 	const migrator = new Migrator({
 		db,
 		provider: new StaticMigrationProvider(),

package/src/database/repositories/byline.ts

@@ -3,6 +3,7 @@ import { ulid } from "ulidx";
 
 import { chunks, SQL_BATCH_SIZE } from "../../utils/chunks.js";
 import { listTablesLike } from "../dialect-helpers.js";
+import { withTransaction } from "../transaction.js";
 import type { BylineTable, Database } from "../types.js";
 import { validateIdentifier } from "../validate.js";
 import {
@@ -197,7 +198,7 @@ export class BylineRepository {
 		const existing = await this.findById(id);
 		if (!existing) return false;
 
-		await this.db.transaction().execute(async (trx) => {
+		await withTransaction(this.db, async (trx) => {
 			await trx.deleteFrom("_emdash_content_bylines").where("byline_id", "=", id).execute();
 
 			await trx.deleteFrom("_emdash_bylines").where("id", "=", id).execute();

package/src/database/repositories/content.ts

@@ -3,6 +3,7 @@ import { ulid } from "ulidx";
 
 import { slugify } from "../../utils/slugify.js";
 import type { Database } from "../types.js";
+import { validateIdentifier } from "../validate.js";
 import { RevisionRepository } from "./revision.js";
 import type {
 	CreateContentInput,
@@ -41,6 +42,7 @@ const SYSTEM_COLUMNS = new Set([
  * Get the table name for a collection type
  */
 function getTableName(type: string): string {
+	validateIdentifier(type, "collection type");
 	return `ec_${type}`;
 }
 
@@ -168,6 +170,7 @@ export class ContentRepository {
 		if (data && typeof data === "object") {
 			for (const [key, value] of Object.entries(data)) {
 				if (!SYSTEM_COLUMNS.has(key)) {
+					validateIdentifier(key, "content field name");
 					columns.push(key);
 					values.push(serializeValue(value));
 				}
@@ -578,6 +581,7 @@ export class ContentRepository {
 		if (input.data !== undefined && typeof input.data === "object") {
 			for (const [key, value] of Object.entries(input.data)) {
 				if (!SYSTEM_COLUMNS.has(key)) {
+					validateIdentifier(key, "content field name");
 					updates[key] = serializeValue(value);
 				}
 			}
@@ -1079,6 +1083,7 @@ export class ContentRepository {
 		for (const [key, value] of Object.entries(data)) {
 			if (SYSTEM_COLUMNS.has(key)) continue;
 			if (key.startsWith("_")) continue; // revision metadata
+			validateIdentifier(key, "content field name");
 			updates[key] = serializeValue(value);
 		}
 

package/src/database/repositories/redirect.ts

@@ -237,6 +237,19 @@ export class RedirectRepository {
 		return BigInt(result.numDeletedRows) > 0n;
 	}
 
+	/**
+	 * Fetch all enabled redirects (for loop detection graph building).
+	 * Not paginated — returns the full set.
+	 */
+	async findAllEnabled(): Promise<Redirect[]> {
+		const rows = await this.db
+			.selectFrom("_emdash_redirects")
+			.selectAll()
+			.where("enabled", "=", 1)
+			.execute();
+		return rows.map(rowToRedirect);
+	}
+
 	// --- Matching -----------------------------------------------------------
 
 	async findExactMatch(path: string): Promise<Redirect | null> {

package/src/database/validate.ts

@@ -79,16 +79,6 @@ export function validateIdentifier(value: string, label = "identifier"): void {
 	}
 }
 
-/**
- * Validate that a string is a safe SQL identifier, allowing hyphens.
- *
- * Like `validateIdentifier` but also permits hyphens, which appear in
- * plugin IDs (e.g., "my-plugin"). Matches `/^[a-z][a-z0-9_-]*$/`.
- *
- * @param value - The string to validate
- * @param label - Human-readable label for error messages
- * @throws {IdentifierError} If the value is not valid
- */
 /**
  * Validate that a string is a safe JSON field name for use in json_extract paths.
  *
@@ -120,6 +110,16 @@ export function validateJsonFieldName(value: string, label = "JSON field name"):
 	}
 }
 
+/**
+ * Validate that a string is a safe SQL identifier, allowing hyphens.
+ *
+ * Like `validateIdentifier` but also permits hyphens, which appear in
+ * plugin IDs (e.g., "my-plugin"). Matches `/^[a-z][a-z0-9_-]*$/`.
+ *
+ * @param value - The string to validate
+ * @param label - Human-readable label for error messages
+ * @throws {IdentifierError} If the value is not valid
+ */
 export function validatePluginIdentifier(value: string, label = "plugin identifier"): void {
 	if (!value || typeof value !== "string") {
 		throw new IdentifierError(`${label} must be a non-empty string`, String(value));

package/src/emdash-runtime.ts

@@ -23,6 +23,7 @@ import { isSqlite } from "./database/dialect-helpers.js";
 import { runMigrations } from "./database/migrations/runner.js";
 import { RevisionRepository } from "./database/repositories/revision.js";
 import type { ContentItem as ContentItemInternal } from "./database/repositories/types.js";
+import { validateIdentifier } from "./database/validate.js";
 import { normalizeMediaValue } from "./media/normalize.js";
 import type { MediaProvider, MediaProviderCapabilities } from "./media/types.js";
 import type { SandboxedPlugin, SandboxRunner } from "./plugins/sandbox/types.js";
@@ -36,8 +37,10 @@ import type {
 	PageMetadataContribution,
 	PageFragmentContribution,
 } from "./plugins/types.js";
+import { invalidateUrlPatternCache } from "./query.js";
 import type { FieldType } from "./schema/types.js";
 import { hashString } from "./utils/hash.js";
+import { COMMIT, VERSION } from "./version.js";
 
 const LEADING_SLASH_PATTERN = /^\//;
 
@@ -55,6 +58,7 @@ const VALID_LINK_REL = new Set([
 	"alternate",
 	"author",
 	"license",
+	"nlweb",
 	"site.standard.document",
 ]);
 
@@ -1352,7 +1356,8 @@ export class EmDashRuntime {
 				: undefined;
 
 		return {
-			version: "0.1.0",
+			version: VERSION,
+			commit: COMMIT,
 			hash: manifestHash,
 			collections: manifestCollections,
 			plugins: manifestPlugins,
@@ -1364,11 +1369,12 @@ export class EmDashRuntime {
 	}
 
 	/**
-	 * Invalidate the cached manifest (no-op now that we don't cache).
-	 * Kept for API compatibility.
+	 * Invalidate cached data derived from the manifest/schema.
+	 * Called when collections are created, updated, or deleted.
 	 */
 	invalidateManifest(): void {
-		// No-op - manifest is rebuilt on each request
+		// Invalidate the URL pattern cache used by resolveEmDashPath
+		invalidateUrlPatternCache();
 	}
 
 	// =========================================================================
@@ -1540,6 +1546,7 @@ export class EmDashRuntime {
 							});
 
 							// Update entry to point to new draft (metadata only, not data columns)
+							validateIdentifier(collection, "collection");
 							const tableName = `ec_${collection}`;
 							await sql`
 								UPDATE ${sql.ref(tableName)}
@@ -1609,7 +1616,7 @@ export class EmDashRuntime {
 
 		// Run afterDelete hooks (fire-and-forget)
 		if (result.success) {
-			this.runAfterDeleteHooks(id, collection);
+			this.runAfterDeleteHooks(id, collection, false);
 		}
 
 		return result;
@@ -1631,7 +1638,14 @@ export class EmDashRuntime {
 	}
 
 	async handleContentPermanentDelete(collection: string, id: string) {
-		return handleContentPermanentDelete(this.db, collection, id);
+		const result = await handleContentPermanentDelete(this.db, collection, id);
+
+		// Run afterDelete hooks so plugins (e.g. AI Search) can clean up
+		if (result.success) {
+			this.runAfterDeleteHooks(id, collection, true);
+		}
+
+		return result;
 	}
 
 	async handleContentCountTrashed(collection: string) {
@@ -2006,11 +2020,11 @@ export class EmDashRuntime {
 		}
 	}
 
-	private runAfterDeleteHooks(id: string, collection: string): void {
+	private runAfterDeleteHooks(id: string, collection: string, permanent: boolean): void {
 		// Trusted plugins
 		if (this.hooks.hasHooks("content:afterDelete")) {
 			this.hooks
-				.runContentAfterDelete(id, collection)
+				.runContentAfterDelete(id, collection, permanent)
 				.catch((err) => console.error("EmDash afterDelete hook error:", err));
 		}
 
@@ -2020,7 +2034,7 @@ export class EmDashRuntime {
 			if (!pluginId || !this.isPluginEnabled(pluginId)) continue;
 
 			plugin
-				.invokeHook("content:afterDelete", { id, collection })
+				.invokeHook("content:afterDelete", { id, collection, permanent })
 				.catch((err) =>
 					console.error(`EmDash: Sandboxed plugin ${pluginId} afterDelete error:`, err),
 				);

package/src/index.ts

@@ -102,6 +102,7 @@ export type {
 export { ulid } from "ulidx";
 export { computeContentHash, hashString } from "./utils/hash.js";
 export { sanitizeHref, isSafeHref } from "./utils/url.js";
+export { decodeSlug } from "./utils/slugify.js";
 
 // Live Collections query functions (loader is in emdash/runtime)
 export {
@@ -212,6 +213,8 @@ export type {
 	ResolvedHook,
 	ResolvedPluginHooks,
 	ContentHookEvent,
+	ContentDeleteEvent,
+	ContentPublishStateChangeEvent,
 	MediaUploadEvent,
 	HookResult,
 	PluginRoute,

package/src/loader.ts

@@ -16,6 +16,7 @@ import { Kysely, sql, type Dialect } from "kysely";
 
 import { currentTimestampValue, isPostgres } from "./database/dialect-helpers.js";
 import { decodeCursor, encodeCursor } from "./database/repositories/types.js";
+import { validateIdentifier } from "./database/validate.js";
 import type { Database } from "./index.js";
 import { getRequestContext } from "./request-context.js";
 
@@ -50,6 +51,7 @@ const SYSTEM_COLUMNS = new Set([
  * Get the table name for a collection type
  */
 function getTableName(type: string): string {
+	validateIdentifier(type, "collection type");
 	return `ec_${type}`;
 }