emdash 0.32.0 → 0.33.0

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

@@ -0,0 +1,31 @@
+/**
+ * Collection reorder endpoint
+ *
+ * POST /_emdash/api/schema/collections/reorder - Set the admin sidebar order
+ */
+
+import type { APIRoute } from "astro";
+
+import { requirePerm } from "#api/authorize.js";
+import { requireDb, unwrapResult } from "#api/error.js";
+import { handleSchemaCollectionReorder } from "#api/index.js";
+import { parseBody, isParseError } from "#api/parse.js";
+import { collectionReorderBody } from "#api/schemas.js";
+
+export const prerender = false;
+
+export const POST: APIRoute = async ({ request, locals }) => {
+	const { emdash, user } = locals;
+
+	const dbErr = requireDb(emdash?.db);
+	if (dbErr) return dbErr;
+
+	const denied = requirePerm(user, "schema:manage");
+	if (denied) return denied;
+
+	const body = await parseBody(request, collectionReorderBody);
+	if (isParseError(body)) return body;
+
+	const result = await handleSchemaCollectionReorder(emdash.db, body.slugs);
+	return unwrapResult(result);
+};

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

@@ -79,6 +79,8 @@ import type { PortableTextBlock } from "emdash";
 				description: c.description,
 				icon: c.icon,
 				supports: c.supports,
+				hidden: c.hidden,
+				sortOrder: c.sortOrder,
 				fields: c.fields.map((f) => ({
 					slug: f.slug,
 					label: f.label,

package/src/astro/routes/api/search/enable.ts

@@ -21,6 +21,7 @@ export const prerender = false;
  * - collection: Collection slug (required)
  * - enabled: boolean (required)
  * - weights: Optional field weights for ranking
+ * - tokenize: Optional FTS5 tokenizer configuration
  */
 export const POST: APIRoute = async ({ request, locals }) => {
 	const { emdash, user } = locals;
@@ -40,7 +41,10 @@ export const POST: APIRoute = async ({ request, locals }) => {
 	try {
 		if (body.enabled) {
 			// Enable search - creates FTS table, triggers, and populates index
-			await ftsManager.enableSearch(body.collection, { weights: body.weights });
+			await ftsManager.enableSearch(body.collection, {
+				weights: body.weights,
+				tokenize: body.tokenize,
+			});
 
 			const stats = await ftsManager.getIndexStats(body.collection);
 

package/src/astro/routes/api/search/rebuild.ts

@@ -57,7 +57,12 @@ export const POST: APIRoute = async ({ request, locals }) => {
 		}
 
 		// Rebuild the index
-		await ftsManager.rebuildIndex(body.collection, searchableFields, config.weights);
+		await ftsManager.rebuildIndex(
+			body.collection,
+			searchableFields,
+			config.weights,
+			config.tokenize,
+		);
 
 		// Get stats after rebuild
 		const stats = await ftsManager.getIndexStats(body.collection);

package/src/astro/routes/api/taxonomies/[name]/reorder.ts

@@ -0,0 +1,41 @@
+/**
+ * Taxonomy term reorder endpoint
+ *
+ * POST /_emdash/api/taxonomies/:name/reorder
+ *   body: { parentId?, ids }
+ *
+ * Sets the manual order of one sibling group. There is no `locale`: a term
+ * holds one position across every locale it is translated into.
+ */
+
+import type { APIRoute } from "astro";
+
+import { requirePerm } from "#api/authorize.js";
+import { apiError, handleError, requireDb, unwrapResult } from "#api/error.js";
+import { handleTermReorder } from "#api/handlers/taxonomies.js";
+import { isParseError, parseBody } from "#api/parse.js";
+import { reorderTermsBody } from "#api/schemas.js";
+
+export const prerender = false;
+
+export const POST: APIRoute = async ({ params, request, locals }) => {
+	const { emdash, user } = locals;
+	const { name } = params;
+	if (!name) return apiError("VALIDATION_ERROR", "Taxonomy name required", 400);
+
+	const dbErr = requireDb(emdash?.db);
+	if (dbErr) return dbErr;
+
+	const denied = requirePerm(user, "taxonomies:manage");
+	if (denied) return denied;
+
+	try {
+		const body = await parseBody(request, reorderTermsBody);
+		if (isParseError(body)) return body;
+
+		const result = await handleTermReorder(emdash.db, name, body);
+		return unwrapResult(result);
+	} catch (error) {
+		return handleError(error, "Failed to reorder terms", "TERM_REORDER_ERROR");
+	}
+};

package/src/astro/types.ts

@@ -31,6 +31,12 @@ export interface ManifestCollection {
 	supports: string[];
 	hasSeo: boolean;
 	urlPattern?: string;
+	/**
+	 * Omit the auto-generated sidebar entry in the admin. The collection is
+	 * still listed in the manifest so its routes, editor, and API keep working
+	 * — only the navigation link is dropped.
+	 */
+	hidden?: boolean;
 	fields: Record<
 		string,
 		{

package/src/cleanup.ts

@@ -10,13 +10,14 @@
  */
 
 import { createKyselyAdapter, type AuthTables } from "@emdash-cms/auth/adapters/kysely";
-import { sql, type Kysely } from "kysely";
+import type { Kysely } from "kysely";
 
 import { cleanupExpiredChallenges } from "./auth/challenge-store.js";
 import { MediaRepository } from "./database/repositories/media.js";
 import { RevisionRepository } from "./database/repositories/revision.js";
 import type { Database } from "./database/types.js";
 import { removeUploadAttempt } from "./media/upload-attempts.js";
+import { cleanupMediaUsageGenerations } from "./media/usage/gc.js";
 import type { Storage } from "./storage/types.js";
 
 /**
@@ -30,19 +31,19 @@ export interface CleanupResult {
 	pendingUploadFiles: number;
 	uploadAttempts: number;
 	revisionsPruned: number;
+	mediaUsageStaleGenerations: number;
+	mediaUsageAbandonedGenerations: number;
+	mediaUsageOrphanOccurrences: number;
 }
 
-/** Max revisions to keep per entry during periodic pruning */
 const REVISION_KEEP_COUNT = 50;
-
-/** Only prune entries that exceed this threshold */
-const REVISION_PRUNE_THRESHOLD = REVISION_KEEP_COUNT;
+const REVISION_PRUNE_BATCH_SIZE = 10;
 
 /**
  * Run all system cleanup tasks.
  *
- * Safe to call frequently -- each task is a single DELETE with a WHERE clause,
- * so repeated calls with nothing to clean are cheap (no-op queries).
+ * Safe to call frequently -- each subsystem tolerates repeated calls, and
+ * repeated calls with nothing to clean are cheap.
  *
  * @param db - The database instance
  * @param storage - Optional storage backend for deleting orphaned files.
@@ -60,6 +61,9 @@ export async function runSystemCleanup(
 		pendingUploadFiles: -1,
 		uploadAttempts: -1,
 		revisionsPruned: -1,
+		mediaUsageStaleGenerations: -1,
+		mediaUsageAbandonedGenerations: -1,
+		mediaUsageOrphanOccurrences: -1,
 	};
 
 	// 1. Passkey challenges (expire after 60s, clean anything past 5 min)
@@ -129,41 +133,42 @@ export async function runSystemCleanup(
 		console.error("[cleanup] Failed to clean media upload attempts:", error);
 	}
 
-	// 5. Revision pruning -- trim entries with excessive revision counts
 	try {
-		result.revisionsPruned = await pruneExcessiveRevisions(db);
+		result.revisionsPruned = await pruneQueuedRevisions(db);
 	} catch (error) {
 		console.error("[cleanup] Failed to prune revisions:", error);
 	}
 
+	try {
+		const usage = await cleanupMediaUsageGenerations(db);
+		result.mediaUsageStaleGenerations = usage.staleGenerations;
+		result.mediaUsageAbandonedGenerations = usage.abandonedGenerations;
+		result.mediaUsageOrphanOccurrences = usage.orphanOccurrences;
+	} catch (error) {
+		console.error("[cleanup] Failed to clean media-usage generations:", error);
+	}
+
 	return result;
 }
 
-/**
- * Find entries with more than REVISION_PRUNE_THRESHOLD revisions and prune
- * them down to REVISION_KEEP_COUNT.
- */
-async function pruneExcessiveRevisions(db: Kysely<Database>): Promise<number> {
-	const entries = await sql<{ collection: string; entry_id: string }>`
-		SELECT collection, entry_id
-		FROM revisions
-		GROUP BY collection, entry_id
-		HAVING COUNT(*) > ${REVISION_PRUNE_THRESHOLD}
-	`.execute(db);
-
-	if (entries.rows.length === 0) return 0;
-
+async function pruneQueuedRevisions(db: Kysely<Database>): Promise<number> {
+	const queued = await db
+		.selectFrom("_emdash_revision_prune_queue")
+		.selectAll()
+		.orderBy("revision_id")
+		.limit(REVISION_PRUNE_BATCH_SIZE)
+		.execute();
 	const revisionRepo = new RevisionRepository(db);
 	let totalPruned = 0;
 
-	for (const row of entries.rows) {
+	for (const row of queued) {
 		try {
-			const pruned = await revisionRepo.pruneOldRevisions(
+			totalPruned += await revisionRepo.pruneQueuedEntry(
 				row.collection,
 				row.entry_id,
+				row.revision_id,
 				REVISION_KEEP_COUNT,
 			);
-			totalPruned += pruned;
 		} catch (error) {
 			console.error(
 				`[cleanup] Failed to prune revisions for ${row.collection}/${row.entry_id}:`,

package/src/cli/commands/dev.ts

@@ -5,7 +5,7 @@
  */
 
 import { spawn } from "node:child_process";
-import { readFile, access } from "node:fs/promises";
+import { access, readFile } from "node:fs/promises";
 import { resolve } from "node:path";
 
 import { defineCommand } from "citty";
@@ -42,10 +42,15 @@ async function fileExists(path: string): Promise<boolean> {
 	}
 }
 
+export const DEV_DEPRECATION_MESSAGE =
+	"`emdash dev` is deprecated and will be removed in a future release.\n\n" +
+	"Use your project's dev script instead (for example, `pnpm dev`), or run `astro dev` directly.";
+
 export const devCommand = defineCommand({
 	meta: {
 		name: "dev",
 		description: "Start dev server with local database",
+		hidden: true,
 	},
 	args: {
 		database: {
@@ -73,6 +78,11 @@ export const devCommand = defineCommand({
 		},
 	},
 	async run({ args }) {
+		consola.box({
+			title: "DEPRECATED COMMAND",
+			message: DEV_DEPRECATION_MESSAGE,
+		});
+
 		const cwd = resolve(args.cwd);
 		const pkg = await readPackageJson(cwd);
 
@@ -119,8 +129,8 @@ export const devCommand = defineCommand({
 					const schema = await client.schemaExport();
 					const types = await client.schemaTypes();
 
-					const { writeFile, mkdir } = await import("node:fs/promises");
-					const { resolve: resolvePath, dirname } = await import("node:path");
+					const { mkdir, writeFile } = await import("node:fs/promises");
+					const { dirname, resolve: resolvePath } = await import("node:path");
 					const outputPath = resolvePath(cwd, ".emdash/types.ts");
 					await mkdir(dirname(outputPath), { recursive: true });
 					await writeFile(outputPath, types, "utf-8");

package/src/cli/commands/export-seed.ts

@@ -316,6 +316,8 @@ async function exportCollections(db: Kysely<Database>): Promise<SeedCollection[]
 			icon: collection.icon || undefined,
 			supports: collection.supports.length > 0 ? collection.supports : undefined,
 			urlPattern: collection.urlPattern || undefined,
+			hidden: collection.hidden || undefined,
+			sortOrder: collection.sortOrder,
 			fields: fields.map(
 				(field): SeedField => ({
 					slug: field.slug,

package/src/cli/index.ts

@@ -8,7 +8,7 @@
  * Commands:
  * - init: Bootstrap database from template config, or interactive setup
  * - types: Generate TypeScript types from schema
- * - dev: Run dev server with local D1
+ * - dev: [DEPRECATED, hidden] Run dev server with a local SQLite database
  * - seed: Apply a seed file to the database
  * - export-seed: Export database schema and content as a seed file
  * - secrets: Generate and inspect EmDash secrets (encryption keys, etc.)

package/src/components/CommentForm.astro

@@ -11,7 +11,7 @@
  * @example
  * ```astro
  * ---
- * import { CommentForm } from "emdash/ui";
+ * import { CommentForm } from "emdash/ui/comments";
  * ---
  * <CommentForm collection="posts" contentId={post.id} />
  * ```

package/src/components/Comments.astro

@@ -8,7 +8,7 @@
  * @example
  * ```astro
  * ---
- * import { Comments } from "emdash/ui";
+ * import { Comments } from "emdash/ui/comments";
  * ---
  * <Comments collection="posts" contentId={post.id} threaded />
  * ```

package/src/components/InlinePortableTextEditor.tsx

@@ -25,9 +25,17 @@ import Suggestion from "@tiptap/suggestion";
 import * as React from "react";
 import { createPortal } from "react-dom";
 
+import {
+	deriveLegacyListId,
+	normalizeProseMirrorOrderedListJson,
+	normalizeListId,
+	normalizeListStart,
+	readOrderedListMetadata,
+} from "../content/converters/numbered-list.js";
 import { computeThumbnailSize } from "../media/thumbnail.js";
 import { CodeMarkExtension } from "./code-mark.js";
 import { InlineCodeBlockExtension } from "./inline-code-block.js";
+import { EmDashOrderedList } from "./ordered-list.js";
 
 // ── Portable Text types ────────────────────────────────────────────
 
@@ -50,6 +58,8 @@ interface PTTextBlock {
 	style?: "normal" | "h1" | "h2" | "h3" | "h4" | "h5" | "h6" | "blockquote";
 	listItem?: "bullet" | "number";
 	level?: number;
+	listId?: string;
+	listStart?: number;
 	children: PTSpan[];
 	markDefs?: PTMarkDef[];
 	textAlign?: "left" | "center" | "right" | "justify";
@@ -106,8 +116,8 @@ function attrNum(attrs: Record<string, unknown> | undefined, key: string): numbe
 function pmToPortableText(doc: PMNode): PTBlock[] {
 	if (!doc || doc.type !== "doc" || !doc.content) return [];
 	const blocks: PTBlock[] = [];
-	for (const node of doc.content) {
-		const r = convertPMNode(node);
+	for (let i = 0; i < doc.content.length; i++) {
+		const r = convertPMNode(doc.content[i]!, `root:${i}`);
 		if (r) {
 			if (Array.isArray(r)) blocks.push(...r);
 			else blocks.push(r);
@@ -116,7 +126,7 @@ function pmToPortableText(doc: PMNode): PTBlock[] {
 	return blocks;
 }
 
-function convertPMNode(node: PMNode): PTBlock | PTBlock[] | null {
+function convertPMNode(node: PMNode, path: string): PTBlock | PTBlock[] | null {
 	switch (node.type) {
 		case "paragraph": {
 			const { children, markDefs } = convertInline(node.content || []);
@@ -157,9 +167,9 @@ function convertPMNode(node: PMNode): PTBlock | PTBlock[] | null {
 			};
 		}
 		case "bulletList":
-			return convertPMList(node.content || [], "bullet");
+			return convertPMList(node.content || [], "bullet", 1, node.attrs, path);
 		case "orderedList":
-			return convertPMList(node.content || [], "number");
+			return convertPMList(node.content || [], "number", 1, node.attrs, path);
 		case "blockquote": {
 			const blocks: PTTextBlock[] = [];
 			for (const child of node.content || []) {
@@ -245,11 +255,20 @@ function convertPMNode(node: PMNode): PTBlock | PTBlock[] | null {
 	}
 }
 
-function convertPMList(items: PMNode[], listItem: "bullet" | "number"): PTTextBlock[] {
+function convertPMList(
+	items: PMNode[],
+	listItem: "bullet" | "number",
+	level: number,
+	attrs: Record<string, unknown> | undefined,
+	path: string,
+): PTTextBlock[] {
 	const blocks: PTTextBlock[] = [];
-	for (const item of items) {
+	const metadata = listItem === "number" ? readOrderedListMetadata(attrs, path) : undefined;
+	for (let itemIndex = 0; itemIndex < items.length; itemIndex++) {
+		const item = items[itemIndex]!;
 		if (item.type === "listItem") {
-			for (const child of item.content || []) {
+			for (let childIndex = 0; childIndex < (item.content?.length ?? 0); childIndex++) {
+				const child = item.content![childIndex]!;
 				if (child.type === "paragraph") {
 					const { children, markDefs } = convertInline(child.content || []);
 					if (children.length > 0) {
@@ -258,11 +277,23 @@ function convertPMList(items: PMNode[], listItem: "bullet" | "number"): PTTextBl
 							_key: k(),
 							style: "normal",
 							listItem,
-							level: 1,
+							level,
+							...metadata,
 							children,
 							markDefs: markDefs.length > 0 ? markDefs : undefined,
 						});
 					}
+				} else if (child.type === "bulletList" || child.type === "orderedList") {
+					const childListItem = child.type === "bulletList" ? "bullet" : "number";
+					blocks.push(
+						...convertPMList(
+							child.content || [],
+							childListItem,
+							level + 1,
+							child.attrs,
+							`${path}:${itemIndex}:${childIndex}`,
+						),
+					);
 				}
 			}
 		}
@@ -346,7 +377,7 @@ function convertPMMark(
 function portableTextToPM(blocks: PTBlock[]): JSONContent {
 	if (!blocks || blocks.length === 0) return { type: "doc", content: [{ type: "paragraph" }] };
 
-	const content: JSONContent[] = [];
+	const content: PMNode[] = [];
 	let i = 0;
 
 	while (i < blocks.length) {
@@ -358,14 +389,23 @@ function portableTextToPM(blocks: PTBlock[]): JSONContent {
 		if (isPTTextBlock(block) && block.listItem) {
 			const listBlocks: PTTextBlock[] = [];
 			const listType = block.listItem;
+			const runStart = i;
+			const rootId = listType === "number" ? normalizeListId(block.listId) : undefined;
 			while (i < blocks.length) {
 				const cur = blocks[i];
-				if (cur && isPTTextBlock(cur) && cur.listItem === listType) {
+				if (!cur || !isPTTextBlock(cur) || !cur.listItem) break;
+				const level = cur.level || 1;
+				const currentId = cur.listItem === "number" ? normalizeListId(cur.listId) : undefined;
+				const sameIdentity =
+					listType !== "number" ||
+					level > 1 ||
+					(rootId ? currentId === rootId : currentId === undefined);
+				if (level > 1 || (cur.listItem === listType && sameIdentity)) {
 					listBlocks.push(cur);
 					i++;
 				} else break;
 			}
-			content.push(convertPTList(listBlocks, listType));
+			content.push(convertPTList(listBlocks, listType, `root:${runStart}`));
 		} else if (
 			isPTTextBlock(block) &&
 			block.style === "blockquote" &&
@@ -375,7 +415,7 @@ function portableTextToPM(blocks: PTBlock[]): JSONContent {
 			// PT is flat, so a multi-paragraph quote is stored as a run of
 			// blockquote-styled blocks. Mirrors the grouping in
 			// content/converters/portable-text-to-prosemirror.ts; without it
-			// merges revert on reload in the inline editor too (#1884).
+			// merges revert on reload in the inline editor too.
 			const quoteBlocks: PTTextBlock[] = [];
 			while (i < blocks.length) {
 				const cur = blocks[i];
@@ -407,10 +447,13 @@ function portableTextToPM(blocks: PTBlock[]): JSONContent {
 		}
 	}
 
-	return { type: "doc", content: content.length > 0 ? content : [{ type: "paragraph" }] };
+	return normalizeProseMirrorOrderedListJson({
+		type: "doc",
+		content: content.length > 0 ? content : [{ type: "paragraph" }],
+	});
 }
 
-function convertPTBlock(block: PTBlock): JSONContent | null {
+function convertPTBlock(block: PTBlock): PMNode | null {
 	if (isPTTextBlock(block)) {
 		const { style = "normal", children, markDefs = [], textAlign } = block;
 		const pmContent = convertPTSpans(children, markDefs);
@@ -530,23 +573,118 @@ function convertPTBlock(block: PTBlock): JSONContent | null {
 	};
 }
 
-function convertPTList(items: PTTextBlock[], listType: "bullet" | "number"): JSONContent {
+function convertPTList(
+	items: PTTextBlock[],
+	listType: "bullet" | "number",
+	context: string,
+): PMNode {
+	const rootItems: PMNode[] = [];
+	let index = 0;
+
+	while (index < items.length) {
+		const item = items[index]!;
+		const level = item.level || 1;
+		if (level === 1) {
+			const nestedItems: PTTextBlock[] = [];
+			index++;
+			while (index < items.length && (items[index]!.level || 1) > 1) {
+				nestedItems.push(items[index]!);
+				index++;
+			}
+			rootItems.push(
+				convertPTListItem(item, nestedItems, listType, `${context}:${rootItems.length}`),
+			);
+		} else {
+			rootItems.push(convertPTListItem(item, [], listType, `${context}:${rootItems.length}`));
+			index++;
+		}
+	}
+
+	const firstItem = items[0]!;
+	const listId =
+		normalizeListId(firstItem.listId) ?? deriveLegacyListId(`${context}:${firstItem._key}`);
+	const listStart = normalizeListStart(firstItem.listStart);
+	const metadata =
+		listType === "number"
+			? {
+					listId,
+					...(listStart === undefined ? {} : { listStart }),
+				}
+			: undefined;
 	return {
 		type: listType === "bullet" ? "bulletList" : "orderedList",
-		content: items.map((item) => ({
-			type: "listItem",
-			content: [
-				{
-					type: "paragraph",
-					content: convertPTSpans(item.children, item.markDefs || []),
-				},
-			],
-		})),
+		attrs: metadata ? { ...metadata, start: metadata.listStart ?? 1 } : undefined,
+		content: rootItems,
 	};
 }
 
-function convertPTSpans(spans: PTSpan[], markDefs: PTMarkDef[]): JSONContent[] {
-	const nodes: JSONContent[] = [];
+function belongsToNestedPTGroup(
+	item: PTTextBlock,
+	minLevel: number,
+	parentListType: "bullet" | "number",
+	anchorType: "bullet" | "number",
+	anchorId: string | undefined,
+): boolean {
+	if ((item.level || 2) > minLevel) return true;
+	if ((item.listItem || parentListType) !== anchorType) return false;
+	if (anchorType !== "number") return true;
+	const itemId = normalizeListId(item.listId);
+	return anchorId ? itemId === anchorId : itemId === undefined;
+}
+
+function convertPTListItem(
+	item: PTTextBlock,
+	nestedItems: PTTextBlock[],
+	parentListType: "bullet" | "number",
+	context: string,
+): PMNode {
+	const content: PMNode[] = [
+		{
+			type: "paragraph",
+			content: convertPTSpans(item.children, item.markDefs || []),
+		},
+	];
+
+	if (nestedItems.length > 0) {
+		let minLevel = Infinity;
+		for (const nestedItem of nestedItems) {
+			const level = nestedItem.level || 2;
+			if (level < minLevel) minLevel = level;
+		}
+
+		let index = 0;
+		while (index < nestedItems.length) {
+			const groupStart = index;
+			const anchorType = nestedItems[index]!.listItem || parentListType;
+			const anchorId =
+				anchorType === "number" ? normalizeListId(nestedItems[index]!.listId) : undefined;
+			const nestedGroup: PTTextBlock[] = [];
+			do {
+				nestedGroup.push(nestedItems[index]!);
+				index++;
+			} while (
+				index < nestedItems.length &&
+				belongsToNestedPTGroup(nestedItems[index]!, minLevel, parentListType, anchorType, anchorId)
+			);
+
+			content.push(
+				convertPTList(
+					nestedGroup.map((nestedItem) => ({
+						...nestedItem,
+						level: (nestedItem.level || 2) - 1,
+					})),
+					anchorType,
+					`${context}:nested:${groupStart}`,
+				),
+			);
+		}
+	}
+
+	return { type: "listItem", content };
+}
+
+function convertPTSpans(spans: PTSpan[], markDefs: PTMarkDef[]): PMNode[] {
+	const nodes: PMNode[] = [];
 	const mdMap = new Map(markDefs.map((md) => [md._key, md]));
 
 	for (const span of spans) {
@@ -556,7 +694,7 @@ function convertPTSpans(spans: PTSpan[], markDefs: PTMarkDef[]): JSONContent[] {
 			const text = parts[i];
 			if (text && text.length > 0) {
 				const marks = convertPTMarks(span.marks || [], mdMap);
-				const node: JSONContent = {
+				const node: PMNode = {
 					type: "text",
 					text,
 				};
@@ -1869,7 +2007,7 @@ export function InlinePortableTextEditor({
 		async (options?: { keepalive?: boolean }) => {
 			// A pagehide flush must not be skipped: an in-flight blur save is
 			// cancelled by the navigation, so the keepalive request is the only
-			// one that can still land (#1582).
+			// one that can still land.
 			if (savingRef.current && !options?.keepalive) return;
 
 			const current = JSON.stringify(getBlocks());
@@ -1914,8 +2052,8 @@ export function InlinePortableTextEditor({
 	// Flush unsaved edits when the page goes away (browser back/forward,
 	// link click, tab close). The blur handler doesn't cover this: unload
 	// doesn't reliably fire React blur, and a plain fetch started during
-	// unload is cancelled by the navigation — edits were silently lost
-	// (#1582). `keepalive` lets the PUT outlive the page.
+	// unload is cancelled by the navigation — edits were silently lost.
+	// `keepalive` lets the PUT outlive the page.
 	// Caveat: keepalive caps the body at 64KB — a very long document
 	// can still be lost on unload. Upgrade path: debounced autosave
 	// while typing (like the admin editor) so unload flushes are rare.
@@ -1945,7 +2083,9 @@ export function InlinePortableTextEditor({
 				codeBlock: false,
 				// Replaced with CodeMarkExtension so inline code can combine with link/etc.
 				code: false,
+				orderedList: false,
 			}),
+			EmDashOrderedList,
 			CodeMarkExtension,
 			InlineCodeBlockExtension,
 			Image.extend({

package/src/components/OrderedList.astro

@@ -0,0 +1,14 @@
+---
+import type { List, Props as ComponentProps } from "astro-portabletext/types";
+import { normalizeListStart } from "../content/converters/numbered-list.js";
+
+type OrderedListNode = List & { start?: unknown };
+type Props = ComponentProps<OrderedListNode>;
+
+const { node, index: _index, isInline: _isInline, ...attrs } = Astro.props;
+const start = normalizeListStart(node.start) ?? 1;
+---
+
+<ol {...attrs} start={start === 1 ? undefined : start}>
+	<slot />
+</ol>