emdash 1.0.1 → 1.1.0

package/src/database/migrations/091_redirect_artifacts.ts

@@ -0,0 +1,141 @@
+import { type Kysely, sql } from "kysely";
+
+import { isPostgres } from "../dialect-helpers.js";
+
+/**
+ * Published redirect artifacts: compact, content-addressed snapshots of the
+ * enabled redirect rules that the middleware loads in one query.
+ *
+ * `revision` counts changes to the columns enabled rules are published from
+ * and is bumped by triggers, so writes that bypass the handlers still mark the
+ * published generation stale. Hit tracking does not bump it.
+ */
+export async function up(db: Kysely<unknown>): Promise<void> {
+	const postgres = isPostgres(db);
+
+	await db.schema
+		.createTable("_emdash_redirect_state")
+		.ifNotExists()
+		.addColumn("id", "integer", (column) => column.primaryKey())
+		.addColumn("revision", "integer", (column) => column.notNull().defaultTo(0))
+		.addColumn("generation", "text")
+		.addColumn("generation_revision", "integer", (column) => column.notNull().defaultTo(-1))
+		.addColumn("repair_expires_at", postgres ? "bigint" : "integer", (column) =>
+			column.notNull().defaultTo(0),
+		)
+		.execute();
+	await sql`
+		INSERT INTO _emdash_redirect_state (id, revision, generation, generation_revision, repair_expires_at)
+		VALUES (1, 0, NULL, -1, 0)
+		ON CONFLICT (id) DO NOTHING
+	`.execute(db);
+
+	await db.schema
+		.createTable("_emdash_redirect_artifacts")
+		.ifNotExists()
+		.addColumn("digest", "text", (column) => column.primaryKey())
+		.addColumn("kind", "text", (column) => column.notNull())
+		.addColumn("payload", "text", (column) => column.notNull())
+		.execute();
+
+	await db.schema
+		.createTable("_emdash_redirect_generation_artifacts")
+		.ifNotExists()
+		.addColumn("generation", "text", (column) => column.notNull())
+		.addColumn("position", "integer", (column) => column.notNull())
+		.addColumn("digest", "text", (column) => column.notNull())
+		.addPrimaryKeyConstraint("pk_emdash_redirect_generation_artifacts", ["generation", "position"])
+		.execute();
+	await db.schema
+		.createIndex("idx_emdash_redirect_generation_artifacts_digest")
+		.ifNotExists()
+		.on("_emdash_redirect_generation_artifacts")
+		.column("digest")
+		.execute();
+
+	if (postgres) {
+		await sql`
+			CREATE OR REPLACE FUNCTION emdash_redirect_bump_revision()
+			RETURNS trigger
+			LANGUAGE plpgsql
+			AS $$
+			BEGIN
+				UPDATE _emdash_redirect_state SET revision = revision + 1 WHERE id = 1;
+				RETURN NULL;
+			END;
+			$$
+		`.execute(db);
+		await sql`DROP TRIGGER IF EXISTS emdash_redirect_state_revision_insert ON _emdash_redirects`.execute(
+			db,
+		);
+		await sql`
+			CREATE TRIGGER emdash_redirect_state_revision_insert
+			AFTER INSERT ON _emdash_redirects
+			FOR EACH ROW
+			WHEN (NEW.enabled = 1)
+			EXECUTE FUNCTION emdash_redirect_bump_revision()
+		`.execute(db);
+		await sql`DROP TRIGGER IF EXISTS emdash_redirect_state_revision_delete ON _emdash_redirects`.execute(
+			db,
+		);
+		await sql`
+			CREATE TRIGGER emdash_redirect_state_revision_delete
+			AFTER DELETE ON _emdash_redirects
+			FOR EACH ROW
+			WHEN (OLD.enabled = 1)
+			EXECUTE FUNCTION emdash_redirect_bump_revision()
+		`.execute(db);
+		await sql`DROP TRIGGER IF EXISTS emdash_redirect_state_revision_update ON _emdash_redirects`.execute(
+			db,
+		);
+		await sql`
+			CREATE TRIGGER emdash_redirect_state_revision_update
+			AFTER UPDATE OF source, destination, enabled, is_pattern, type, created_at ON _emdash_redirects
+			FOR EACH ROW
+			WHEN ((NEW.enabled = 1 OR OLD.enabled = 1) AND (
+				NEW.source IS DISTINCT FROM OLD.source OR
+				NEW.destination IS DISTINCT FROM OLD.destination OR
+				NEW.enabled IS DISTINCT FROM OLD.enabled OR
+				NEW.is_pattern IS DISTINCT FROM OLD.is_pattern OR
+				NEW.type IS DISTINCT FROM OLD.type OR
+				NEW.created_at IS DISTINCT FROM OLD.created_at
+			))
+			EXECUTE FUNCTION emdash_redirect_bump_revision()
+		`.execute(db);
+		return;
+	}
+
+	await sql`
+		CREATE TRIGGER IF NOT EXISTS emdash_redirect_state_revision_insert
+		AFTER INSERT ON _emdash_redirects
+		WHEN NEW.enabled = 1
+		BEGIN
+			UPDATE _emdash_redirect_state SET revision = revision + 1 WHERE id = 1;
+		END
+	`.execute(db);
+	await sql`
+		CREATE TRIGGER IF NOT EXISTS emdash_redirect_state_revision_delete
+		AFTER DELETE ON _emdash_redirects
+		WHEN OLD.enabled = 1
+		BEGIN
+			UPDATE _emdash_redirect_state SET revision = revision + 1 WHERE id = 1;
+		END
+	`.execute(db);
+	await sql`
+		CREATE TRIGGER IF NOT EXISTS emdash_redirect_state_revision_update
+		AFTER UPDATE OF source, destination, enabled, is_pattern, type, created_at ON _emdash_redirects
+		WHEN (NEW.enabled = 1 OR OLD.enabled = 1) AND (
+			NEW.source IS NOT OLD.source OR
+			NEW.destination IS NOT OLD.destination OR
+			NEW.enabled IS NOT OLD.enabled OR
+			NEW.is_pattern IS NOT OLD.is_pattern OR
+			NEW.type IS NOT OLD.type OR
+			NEW.created_at IS NOT OLD.created_at
+		)
+		BEGIN
+			UPDATE _emdash_redirect_state SET revision = revision + 1 WHERE id = 1;
+		END
+	`.execute(db);
+}
+
+export async function down(_db: Kysely<unknown>): Promise<void> {}

package/src/database/migrations/runner.ts

@@ -97,6 +97,8 @@ import * as m086 from "./086_relations_structural.js";
 import * as m087 from "./087_reference_field_relations.js";
 import * as m088 from "./088_cron_oneshot_utc.js";
 import * as m089 from "./089_auto_seed_completion.js";
+import * as m090 from "./090_redirect_enable_loop_guard.js";
+import * as m091 from "./091_redirect_artifacts.js";
 
 const MIGRATIONS: Readonly<Record<string, Migration>> = Object.freeze({
 	"001_initial": m001,
@@ -187,6 +189,8 @@ const MIGRATIONS: Readonly<Record<string, Migration>> = Object.freeze({
 	"087_reference_field_relations": m087,
 	"088_cron_oneshot_utc": m088,
 	"089_auto_seed_completion": m089,
+	"090_redirect_enable_loop_guard": m090,
+	"091_redirect_artifacts": m091,
 });
 
 /** Ordered names from the statically registered migration set. */

package/src/database/repositories/content.ts

@@ -1,4 +1,4 @@
-import { sql, type Kysely } from "kysely";
+import { sql, type Kysely, type RawBuilder } from "kysely";
 import { ulid } from "ulidx";
 
 import type { ContentFieldFilterValue, ContentFieldFilters } from "../../content-list-query.js";
@@ -11,7 +11,7 @@ import { chunks, SQL_BATCH_SIZE } from "../../utils/chunks.js";
 import { isMissingTableError } from "../../utils/db-errors.js";
 import { slugify } from "../../utils/slugify.js";
 import { ContentDatetimeNormalizer, type DatetimeContextCache } from "../content-datetime.js";
-import { executeAtomicBatchIfSupported } from "../dialect-helpers.js";
+import { executeAtomicBatchIfSupported, isPostgres } from "../dialect-helpers.js";
 import { withTransaction } from "../transaction.js";
 import type { Database } from "../types.js";
 import { validateIdentifier } from "../validate.js";
@@ -80,7 +80,7 @@ function sameStoredValue(left: unknown, right: unknown): boolean {
 function matchesPublication(
 	observed: ContentItem,
 	existing: ContentItem,
-	revision: { data: Record<string, unknown> },
+	revisionData: Record<string, unknown>,
 	revisionId: string,
 	slug: string | null,
 	publishedAt: string,
@@ -99,7 +99,7 @@ function matchesPublication(
 		return false;
 	}
 
-	return Object.entries(revision.data).every(
+	return Object.entries(revisionData).every(
 		([key, value]) =>
 			SYSTEM_COLUMNS.has(key) || key.startsWith("_") || sameStoredValue(observed.data[key], value),
 	);
@@ -154,35 +154,42 @@ interface ResolvedOrderField {
 	indexedCustomField: boolean;
 }
 
-type IndexedOrderValue = string | number | null;
+type NullableOrderValue = string | number | null;
 
-interface IndexedFieldCursorPayload {
+interface NullableOrderCursorPayload {
 	version: 1;
 	field: string;
-	value: IndexedOrderValue;
+	value: NullableOrderValue;
 }
 
-function encodeIndexedFieldCursor(field: string, value: IndexedOrderValue, id: string): string {
-	const payload: IndexedFieldCursorPayload = { version: 1, field, value };
+function encodeNullableOrderCursor(field: string, value: NullableOrderValue, id: string): string {
+	const payload: NullableOrderCursorPayload = { version: 1, field, value };
 	return encodeCursor(JSON.stringify(payload), id);
 }
 
-function decodeIndexedFieldCursor(
+/**
+ * `acceptPlain` also accepts the plain `{ orderValue, id }` cursor that
+ * built-in and collection sort fields were paged with before, which wrote a
+ * NULL as "".
+ */
+function decodeNullableOrderCursor(
 	cursor: string,
 	field: string,
-): { value: IndexedOrderValue; id: string } {
+	{ acceptPlain = false } = {},
+): { value: NullableOrderValue; id: string } {
 	const { orderValue, id } = decodeCursor(cursor);
 	let payload: unknown;
 	try {
 		payload = JSON.parse(orderValue);
 	} catch {
-		throw new InvalidCursorError(cursor);
+		payload = undefined;
 	}
 
 	if (payload === null || typeof payload !== "object") {
+		if (acceptPlain) return { value: orderValue === "" ? null : orderValue, id };
 		throw new InvalidCursorError(cursor);
 	}
-	const candidate = payload as Partial<IndexedFieldCursorPayload>;
+	const candidate = payload as Partial<NullableOrderCursorPayload>;
 	const validValue =
 		candidate.value === null ||
 		typeof candidate.value === "string" ||
@@ -191,7 +198,34 @@ function decodeIndexedFieldCursor(
 		throw new InvalidCursorError(cursor);
 	}
 
-	return { value: candidate.value as IndexedOrderValue, id };
+	return { value: candidate.value as NullableOrderValue, id };
+}
+
+/**
+ * Keyset condition for the rows after (`value`, `cursorId`) in a sort by the
+ * nullable `column`, then `id`. The ORDER BY keeps each dialect's own NULL
+ * position, lowest on SQLite and highest on Postgres, so the condition follows
+ * it.
+ */
+function nullableOrderCondition(
+	db: Kysely<Database>,
+	column: string,
+	direction: "ASC" | "DESC",
+	value: NullableOrderValue,
+	cursorId: string,
+): RawBuilder<boolean> {
+	const sort = sql.ref(column);
+	const id = sql.ref("id");
+	const cmp = direction === "ASC" ? sql.raw(">") : sql.raw("<");
+	const nullsFirst = (direction === "ASC") !== isPostgres(db);
+	if (value === null) {
+		return nullsFirst
+			? sql<boolean>`(${sort} IS NOT NULL OR ${id} ${cmp} ${cursorId})`
+			: sql<boolean>`(${sort} IS NULL AND ${id} ${cmp} ${cursorId})`;
+	}
+	// The row value, unlike the equivalent OR, lets SQLite keep reading the index in order.
+	const past = sql<boolean>`(${sort}, ${id}) ${cmp} (${value}, ${cursorId})`;
+	return nullsFirst ? past : sql<boolean>`(${past} OR ${sort} IS NULL)`;
 }
 
 /**
@@ -224,6 +258,13 @@ const ORDER_FIELD_COLUMNS: Record<string, string> = {
 	locale: "locale",
 };
 
+/**
+ * Order columns every row has a value for. Their cursors keep the plain
+ * `{ orderValue, id }` shape; a cursor for any other order column records a
+ * NULL explicitly.
+ */
+const NON_NULL_ORDER_COLUMNS = new Set(["created_at", "updated_at", "status", "locale"]);
+
 /** True when `field` maps to a system column and needs no per-collection resolution. */
 export function isSystemOrderField(field: string): boolean {
 	return field in ORDER_FIELD_COLUMNS;
@@ -806,6 +847,8 @@ export class ContentRepository {
 			options.sortableExtras,
 		);
 		const dbField = resolvedOrderField.column;
+		const nullableOrder =
+			resolvedOrderField.indexedCustomField || !NON_NULL_ORDER_COLUMNS.has(dbField);
 		const resolvedFieldFilters = await this.resolveFieldFilters(type, options.where?.fieldFilters);
 
 		// Validate order direction to prevent injection
@@ -841,15 +884,17 @@ export class ContentRepository {
 		// structured INVALID_CURSOR rather than silently returning page 1.
 		if (options.cursor) {
 			if (resolvedOrderField.indexedCustomField) {
-				const { value, id: cursorId } = decodeIndexedFieldCursor(options.cursor, orderField);
+				const { value, id: cursorId } = decodeNullableOrderCursor(options.cursor, orderField);
 				const isPresent = sql<boolean>`${sql.ref(dbField)} IS NOT NULL`;
 				const falseLiteral = sql<boolean>`FALSE`;
 				const trueLiteral = sql<boolean>`TRUE`;
 				if (safeOrderDirection === "ASC" && value === null) {
-					query = query.where(sql<boolean>`
+					// Kysely joins a raw condition to the others with a bare AND, so the
+					// OR must carry its own parentheses to stay under every filter.
+					query = query.where(sql<boolean>`(
 						(${isPresent}) > ${falseLiteral}
 						OR ((${isPresent}) = ${falseLiteral} AND ${sql.ref("id")} > ${cursorId})
-					`);
+					)`);
 				} else if (safeOrderDirection === "DESC" && value === null) {
 					query = query.where(sql<boolean>`
 						(${isPresent}) = ${falseLiteral} AND ${sql.ref("id")} < ${cursorId}
@@ -865,6 +910,13 @@ export class ContentRepository {
 							< (${trueLiteral}, ${value}, ${cursorId})
 					`);
 				}
+			} else if (nullableOrder) {
+				const { value, id: cursorId } = decodeNullableOrderCursor(options.cursor, orderField, {
+					acceptPlain: true,
+				});
+				query = query.where(
+					nullableOrderCondition(this.db, dbField, safeOrderDirection, value, cursorId),
+				);
 			} else {
 				const { orderValue, id: cursorId } = decodeCursor(options.cursor);
 
@@ -928,15 +980,15 @@ export class ContentRepository {
 		if (hasMore && items.length > 0) {
 			const lastRow = items.at(-1) as Record<string, unknown>;
 			const lastOrderValue = lastRow[dbField];
-			if (resolvedOrderField.indexedCustomField) {
+			if (nullableOrder) {
 				if (
 					lastOrderValue !== null &&
 					typeof lastOrderValue !== "string" &&
 					typeof lastOrderValue !== "number"
 				) {
-					throw new EmDashValidationError(`Invalid indexed value for order field: ${orderField}`);
+					throw new EmDashValidationError(`Invalid value for order field: ${orderField}`);
 				}
-				mappedResult.nextCursor = encodeIndexedFieldCursor(
+				mappedResult.nextCursor = encodeNullableOrderCursor(
 					orderField,
 					lastOrderValue,
 					String(lastRow.id),
@@ -1873,10 +1925,10 @@ export class ContentRepository {
 		// of translation groups — at the locale the list is scoped to. Matching
 		// the locale is what keeps the filter agreeing with the list: an
 		// inferred credit renders only when the author's byline has a row at
-		// that locale (`hydrateBylinesMany` -> `findByUserIds`), and byline
-		// translations start life with a null `user_id`, so a group translated
-		// into the locale but not re-linked resolves to no credit. `locale`
-		// falls back to each entry's own when the list spans locales.
+		// that locale (`hydrateBylinesMany` -> `findByUserIds`), so a group
+		// whose translation at the locale has no linked user resolves to no
+		// credit. `locale` falls back to each entry's own when the list spans
+		// locales.
 		const authorHasByline = (eb: any, bylineIds?: string[]) => {
 			let sub = eb
 				.selectFrom("_emdash_bylines as b")
@@ -2526,6 +2578,9 @@ export class ContentRepository {
 				throw new EmDashValidationError("Revision does not belong to the specified content item");
 			}
 
+			const writableFieldSlugs = await this.datetimes.writableFieldSlugs(type);
+			const revisionData = keepKnownFields(revision.data, writableFieldSlugs);
+
 			const stagedSlug = typeof revision.data._slug === "string" ? revision.data._slug : null;
 			const intendedSlug = stagedSlug ?? existing.slug;
 			if (requireSlug && !intendedSlug?.trim()) {
@@ -2545,7 +2600,7 @@ export class ContentRepository {
 
 			const assignments: ReturnType<typeof sql>[] = [];
 			if (stagedSlug !== null) assignments.push(sql`slug = ${stagedSlug}`);
-			for (const [key, value] of Object.entries(revision.data)) {
+			for (const [key, value] of Object.entries(revisionData)) {
 				if (SYSTEM_COLUMNS.has(key) || key.startsWith("_")) continue;
 				validateIdentifier(key, "content field name");
 				assignments.push(sql`${sql.ref(key)} = ${serializeValue(value)}`);
@@ -2603,7 +2658,7 @@ export class ContentRepository {
 				promoted = matchesPublication(
 					observed,
 					existing,
-					revision,
+					revisionData,
 					revisionToPublish,
 					intendedSlug,
 					intendedPublishedAt,

package/src/database/repositories/redirect.ts

@@ -428,13 +428,16 @@ export class RedirectRepository {
 
 	/**
 	 * Fetch all enabled redirects (for loop detection graph building).
-	 * Not paginated — returns the full set.
+	 * Not paginated — returns the full set. Ordered oldest first: the earliest
+	 * matching pattern rule wins, so this order is match precedence.
 	 */
 	async findAllEnabled(): Promise<Redirect[]> {
 		const rows = await this.db
 			.selectFrom("_emdash_redirects")
 			.selectAll()
 			.where("enabled", "=", 1)
+			.orderBy("created_at", (order) => order.asc().nullsFirst())
+			.orderBy("id", "asc")
 			.execute();
 		return rows.map(rowToRedirect);
 	}
@@ -458,6 +461,8 @@ export class RedirectRepository {
 			.selectAll()
 			.where("enabled", "=", 1)
 			.where("is_pattern", "=", 1)
+			.orderBy("created_at", (order) => order.asc().nullsFirst())
+			.orderBy("id", "asc")
 			.execute();
 		return rows.map(rowToRedirect);
 	}

package/src/database/request-scoped.ts

@@ -0,0 +1,34 @@
+/**
+ * Handles returned by the adapter's `createRequestScopedDb`. Some adapters
+ * (D1 with sessions, Hyperdrive, Durable Object SQL with sessions or on
+ * writes) build a new Kysely instance for each request or event, and every
+ * one addresses the configured database, so a cache keyed by instance uses
+ * `isRequestScopedDb` to treat them as one database. A database that other
+ * code puts in the request context (playground, Durable Object preview) is
+ * not registered.
+ */
+
+import type { Kysely } from "kysely";
+
+// On globalThis so Vite SSR chunk duplication cannot split the registry
+// between the middleware that registers handles and the caches that read it.
+const REQUEST_SCOPED_DBS_KEY = Symbol.for("emdash:request-scoped-dbs");
+
+function getRegistry(): WeakSet<object> {
+	// eslint-disable-next-line typescript/no-unsafe-type-assertion -- globalThis singleton pattern
+	const holder = globalThis as Record<symbol, WeakSet<object> | undefined>;
+	let registry = holder[REQUEST_SCOPED_DBS_KEY];
+	if (!registry) {
+		registry = new WeakSet();
+		holder[REQUEST_SCOPED_DBS_KEY] = registry;
+	}
+	return registry;
+}
+
+export function markRequestScopedDb<DB>(db: Kysely<DB>): void {
+	getRegistry().add(db);
+}
+
+export function isRequestScopedDb<DB>(db: Kysely<DB>): boolean {
+	return getRegistry().has(db);
+}

package/src/database/types.ts

@@ -808,6 +808,9 @@ export interface Database {
 	_emdash_comment_reactions: CommentReactionTable;
 	_emdash_redirects: RedirectTable;
 	_emdash_redirect_write_lock: RedirectWriteLockTable;
+	_emdash_redirect_state: RedirectStateTable;
+	_emdash_redirect_artifacts: RedirectArtifactTable;
+	_emdash_redirect_generation_artifacts: RedirectGenerationArtifactTable;
 	_emdash_404_log: NotFoundLogTable;
 	_emdash_bylines: BylineTable;
 	_emdash_content_bylines: ContentBylineTable;
@@ -872,6 +875,26 @@ export interface RedirectWriteLockTable {
 	generation: number;
 }
 
+export interface RedirectStateTable {
+	id: number;
+	revision: Generated<number>;
+	generation: string | null;
+	generation_revision: Generated<number>;
+	repair_expires_at: Generated<number>;
+}
+
+export interface RedirectArtifactTable {
+	digest: string;
+	kind: string;
+	payload: string;
+}
+
+export interface RedirectGenerationArtifactTable {
+	generation: string;
+	position: number;
+	digest: string;
+}
+
 export interface NotFoundLogTable {
 	id: string;
 	path: string;

package/src/db/adapters.ts

@@ -88,6 +88,8 @@ export interface DatabaseDescriptor {
 	 * runtime config (e.g. whether the user opted into D1 sessions) — whether
 	 * to return a per-request Kysely or null. Use this for features like D1
 	 * read-replica sessions, bookmark cookies, or any per-request DB handle.
+	 * The handle must address the configured database: core shares values it
+	 * caches from one handle, such as the preview secret, with later requests.
 	 *
 	 * When false or absent, the generator emits a stub that returns null and
 	 * the middleware takes its default (singleton) path.

package/src/emdash-runtime.ts

@@ -108,6 +108,7 @@ import type {
 import type {
 	ActorInfo,
 	ContentActionOrigin,
+	ContentSaveHookDetails,
 	ContentItem as PluginContentItem,
 	ResolvedPlugin,
 	MediaItem,
@@ -2365,7 +2366,7 @@ export class EmDashRuntime {
 	/**
 	 * Get or create storage instance
 	 */
-	private static getStorage(deps: RuntimeDependencies): Storage | null {
+	static getStorage(deps: RuntimeDependencies): Storage | null {
 		const storageConfig = deps.config.storage;
 		if (!storageConfig || !deps.createStorage) {
 			return null;
@@ -3395,6 +3396,11 @@ export class EmDashRuntime {
 			}
 		}
 
+		const saveHookDetails = {
+			locale,
+			...(body.translationOf ? { translationOf: body.translationOf } : {}),
+		};
+
 		// Run beforeSave hooks (trusted plugins)
 		let processedData = body.data;
 		if (!options.skipSaveHooks && this.hooks.hasHooks("content:beforeSave")) {
@@ -3405,6 +3411,7 @@ export class EmDashRuntime {
 					true,
 					undefined,
 					actor,
+					saveHookDetails,
 				);
 				processedData = hookResult.content;
 			} catch (error) {
@@ -3500,6 +3507,7 @@ export class EmDashRuntime {
 				true,
 				actor,
 				options.excludeAfterSavePluginId,
+				{ ...saveHookDetails, locale: result.data.item.locale ?? locale },
 			);
 		}
 
@@ -3610,6 +3618,7 @@ export class EmDashRuntime {
 						false,
 						resolvedItem?.id,
 						actor,
+						resolvedItem?.locale ? { locale: resolvedItem.locale } : {},
 					);
 					processedData = hookResult.content;
 				} catch (error) {
@@ -3921,7 +3930,15 @@ export class EmDashRuntime {
 
 		// Run afterSave hooks (fire-and-forget)
 		if (hydrated.success && hydrated.data) {
-			this.runAfterSaveHooks(contentItemToRecord(hydrated.data.item), collection, false, actor);
+			const savedLocale = hydrated.data.item.locale;
+			this.runAfterSaveHooks(
+				contentItemToRecord(hydrated.data.item),
+				collection,
+				false,
+				actor,
+				undefined,
+				savedLocale ? { locale: savedLocale } : {},
+			);
 		}
 
 		if (hydrated.success) {
@@ -5942,12 +5959,20 @@ export class EmDashRuntime {
 		isNew: boolean,
 		actor?: ActorInfo,
 		excludePluginId?: string,
+		details?: ContentSaveHookDetails,
 	): void {
 		after(async () => {
 			// Trusted plugins
 			if (this.hooks.hasHooks("content:afterSave")) {
 				try {
-					await this.hooks.runContentAfterSave(content, collection, isNew, actor, excludePluginId);
+					await this.hooks.runContentAfterSave(
+						content,
+						collection,
+						isNew,
+						actor,
+						excludePluginId,
+						details,
+					);
 				} catch (err) {
 					console.error("EmDash afterSave hook error:", err);
 				}

package/src/import/menus.ts

@@ -10,6 +10,7 @@ import { ulid } from "ulidx";
 import type { WxrNavMenu, WxrNavMenuItem } from "../cli/wxr/parser.js";
 import type { Database } from "../database/types.js";
 import type { MenuItemType } from "../menus/types.js";
+import { invalidateMenuObjectCache } from "../object-cache/index.js";
 
 /**
  * Result of menu import operation
@@ -107,6 +108,7 @@ export async function importMenusFromWxr(
 		}
 	}
 
+	if (result.menusCreated > 0) invalidateMenuObjectCache();
 	return result;
 }
 
@@ -169,6 +171,7 @@ export async function importMenusFromPlugin(
 		}
 	}
 
+	if (result.menusCreated > 0) invalidateMenuObjectCache();
 	return result;
 }
 

package/src/index.ts

@@ -131,6 +131,7 @@ export type {
 	PortableTextImageBlock,
 	PortableTextCodeBlock,
 	PortableTextHtmlBlock,
+	PortableTextIframeBlock,
 	PortableTextTableAlignment,
 	PortableTextTableBlock,
 	PortableTextTableCell,