emdash 0.32.0 → 0.33.0

package/src/content/converters/numbered-list.ts

@@ -0,0 +1,148 @@
+import type { ProseMirrorDocument, ProseMirrorNode } from "./types.js";
+
+export const MAX_ORDERED_LIST_START = 2_147_483_647;
+
+export interface OrderedListMetadata {
+	listId: string;
+	listStart: number;
+}
+
+export function normalizeListId(value: unknown): string | undefined {
+	if (typeof value !== "string") return undefined;
+	const normalized = value.trim();
+	return normalized.length > 0 && normalized.length <= 128 ? normalized : undefined;
+}
+
+export function normalizeListStart(value: unknown): number | undefined {
+	return typeof value === "number" &&
+		Number.isInteger(value) &&
+		value >= 1 &&
+		value <= MAX_ORDERED_LIST_START
+		? value
+		: undefined;
+}
+
+export function deriveLegacyListId(seed: string): string {
+	const readable = `legacy:${seed}`;
+	if (readable.length <= 128) return readable;
+	let hash = 2_166_136_261;
+	for (let i = 0; i < seed.length; i++) {
+		hash ^= seed.charCodeAt(i);
+		hash = Math.imul(hash, 16_777_619);
+	}
+	return `legacy:${seed.slice(0, 96)}:${(hash >>> 0).toString(36)}:${seed.length.toString(36)}`;
+}
+
+export function readOrderedListMetadata(
+	attrs: Record<string, unknown> | undefined,
+	fallbackId: string,
+): OrderedListMetadata {
+	return {
+		listId: normalizeListId(attrs?.listId) ?? deriveLegacyListId(fallbackId),
+		listStart: normalizeListStart(attrs?.listStart) ?? normalizeListStart(attrs?.start) ?? 1,
+	};
+}
+
+interface ProseMirrorListDescriptor {
+	node: ProseMirrorNode;
+	path: string;
+	depth: number;
+	context: string;
+}
+
+function collectProseMirrorOrderedLists(doc: ProseMirrorDocument): ProseMirrorListDescriptor[] {
+	const lists: ProseMirrorListDescriptor[] = [];
+	const visit = (node: ProseMirrorNode, path: string, depth: number, context: string) => {
+		if (node.type === "orderedList") lists.push({ node, path, depth, context });
+		for (const [index, child] of (node.content ?? []).entries()) {
+			const childPath = `${path}:${index}`;
+			visit(
+				child,
+				childPath,
+				depth + 1,
+				child.type === "listItem" ? `listItem:${childPath}` : context,
+			);
+		}
+	};
+	for (const [index, node] of doc.content.entries()) {
+		visit(node, `root:${index}`, 0, "root");
+	}
+	return lists;
+}
+
+function cloneProseMirrorNode(node: ProseMirrorNode): ProseMirrorNode {
+	return {
+		...node,
+		attrs: node.attrs ? { ...node.attrs } : undefined,
+		content: node.content?.map(cloneProseMirrorNode),
+		marks: node.marks?.map((mark) => ({
+			...mark,
+			attrs: mark.attrs ? { ...mark.attrs } : undefined,
+		})),
+	};
+}
+
+function createRepairId(sourceId: string, scope: string, attempt: number): string {
+	const base = deriveLegacyListId(`repair:${sourceId}:${scope}`);
+	const suffix = `:${attempt.toString(36)}`;
+	return `${base.slice(0, 128 - suffix.length)}${suffix}`;
+}
+
+export function normalizeProseMirrorOrderedListJson(doc: ProseMirrorDocument): ProseMirrorDocument {
+	const normalized = {
+		...doc,
+		content: doc.content.map(cloneProseMirrorNode),
+	};
+	const canonicalBySourceScope = new Map<string, string>();
+	const assignedCanonicalIds = new Set<string>();
+	const lists = collectProseMirrorOrderedLists(normalized).map((list) => {
+		const sourceId =
+			normalizeListId(list.node.attrs?.listId) ??
+			deriveLegacyListId(`pm-json:${list.path}:${list.depth}:${list.context}`);
+		const scope = JSON.stringify([list.depth, list.context]);
+		const sourceScope = JSON.stringify([sourceId, scope]);
+		let listId = canonicalBySourceScope.get(sourceScope);
+		if (!listId) {
+			if (!assignedCanonicalIds.has(sourceId)) {
+				listId = sourceId;
+			} else {
+				let attempt = 0;
+				do {
+					listId = createRepairId(sourceId, scope, attempt++);
+				} while (assignedCanonicalIds.has(listId));
+			}
+			canonicalBySourceScope.set(sourceScope, listId);
+			assignedCanonicalIds.add(listId);
+		}
+		return {
+			...list,
+			listId,
+			scopeKey: JSON.stringify([listId, list.depth, list.context]),
+		};
+	});
+
+	const bases = new Map<string, number>();
+	for (const list of lists) {
+		const listStart = normalizeListStart(list.node.attrs?.listStart);
+		if (listStart !== undefined && !bases.has(list.scopeKey)) {
+			bases.set(list.scopeKey, listStart);
+		}
+	}
+	for (const list of lists) {
+		if (!bases.has(list.scopeKey)) {
+			bases.set(list.scopeKey, normalizeListStart(list.node.attrs?.start) ?? 1);
+		}
+	}
+
+	const counts = new Map<string, number>();
+	for (const list of lists) {
+		const listStart = bases.get(list.scopeKey)!;
+		const count = counts.get(list.scopeKey) ?? 0;
+		const start = normalizeListStart(listStart + count) ?? 1;
+		const directItemCount =
+			list.node.content?.filter((node) => node.type === "listItem").length ?? 0;
+		counts.set(list.scopeKey, count + directItemCount);
+		list.node.attrs = { ...list.node.attrs, listId: list.listId, listStart, start };
+	}
+	return normalized;
+}

package/src/content/converters/portable-text-to-prosemirror.ts

@@ -5,6 +5,12 @@
  */
 
 import { sanitizeGalleryImages } from "./gallery.js";
+import {
+	deriveLegacyListId,
+	normalizeProseMirrorOrderedListJson,
+	normalizeListId,
+	normalizeListStart,
+} from "./numbered-list.js";
 import type {
 	ProseMirrorDocument,
 	ProseMirrorNode,
@@ -48,12 +54,20 @@ export function portableTextToProsemirror(blocks: PortableTextBlock[]): ProseMir
 			// child).
 			const listBlocks: PortableTextTextBlock[] = [];
 			const listType = block.listItem;
+			const runStart = i;
+			const rootId = listType === "number" ? normalizeListId(block.listId) : undefined;
 
 			while (i < blocks.length) {
 				const current = blocks[i];
 				if (!isTextBlock(current) || !current.listItem) break;
 				const level = current.level || 1;
-				if (level > 1 || current.listItem === listType) {
+				const currentId =
+					current.listItem === "number" ? normalizeListId(current.listId) : undefined;
+				const sameRootIdentity =
+					listType !== "number" ||
+					level > 1 ||
+					(rootId ? currentId === rootId : currentId === undefined);
+				if (level > 1 || (current.listItem === listType && sameRootIdentity)) {
 					listBlocks.push(current);
 					i++;
 				} else {
@@ -61,14 +75,14 @@ export function portableTextToProsemirror(blocks: PortableTextBlock[]): ProseMir
 				}
 			}
 
-			content.push(convertList(listBlocks, listType));
+			content.push(convertList(listBlocks, listType, `root:${runStart}`));
 		} else if (isTextBlock(block) && block.style === "blockquote") {
 			// Collect a blockquote "run": Portable Text is flat, so a
 			// multi-paragraph quote is stored as consecutive blocks with
 			// style "blockquote" (that's what the Gutenberg importer emits
 			// and what prosemirrorToPortableText serializes back to).
 			// Without this grouping each paragraph became its own quote
-			// node, and editor merges reverted on reload (#1884).
+			// node, and editor merges reverted on reload.
 			const quoteBlocks: PortableTextTextBlock[] = [];
 			while (i < blocks.length) {
 				const current = blocks[i];
@@ -102,12 +116,38 @@ export function portableTextToProsemirror(blocks: PortableTextBlock[]): ProseMir
 		}
 	}
 
-	return {
+	return normalizeProseMirrorOrderedListJson({
 		type: "doc",
 		content: content.length > 0 ? content : [{ type: "paragraph" }],
+	});
+}
+
+function getListMetadata(
+	item: PortableTextTextBlock,
+	fallbackSeed: string,
+): { listId: string; listStart?: number } {
+	const listId = normalizeListId(item.listId) ?? deriveLegacyListId(fallbackSeed);
+	const listStart = normalizeListStart(item.listStart);
+	return {
+		listId,
+		...(listStart === undefined ? {} : { listStart }),
 	};
 }
 
+function belongsToNestedGroup(
+	item: PortableTextTextBlock,
+	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;
+}
+
 /**
  * Type guard for text blocks
  */
@@ -249,6 +289,7 @@ function convertTextBlock(block: PortableTextTextBlock): ProseMirrorNode | null
 function convertList(
 	items: PortableTextTextBlock[],
 	listType: "bullet" | "number",
+	context: string,
 ): ProseMirrorNode {
 	// Group items by level
 	const rootItems: ProseMirrorNode[] = [];
@@ -268,16 +309,22 @@ function convertList(
 				i++;
 			}
 
-			rootItems.push(convertListItem(item, nestedItems, listType));
+			rootItems.push(
+				convertListItem(item, nestedItems, listType, `${context}:${rootItems.length}`),
+			);
 		} else {
 			// Orphan nested item - treat as root
-			rootItems.push(convertListItem(item, [], listType));
+			rootItems.push(convertListItem(item, [], listType, `${context}:${rootItems.length}`));
 			i++;
 		}
 	}
 
+	const metadata =
+		listType === "number" ? getListMetadata(items[0], `${context}:${items[0]._key}`) : undefined;
+
 	return {
 		type: listType === "bullet" ? "bulletList" : "orderedList",
+		attrs: metadata ? { ...metadata, start: metadata.listStart ?? 1 } : undefined,
 		content: rootItems,
 	};
 }
@@ -289,6 +336,7 @@ function convertListItem(
 	item: PortableTextTextBlock,
 	nestedItems: PortableTextTextBlock[],
 	parentListType: "bullet" | "number",
+	context: string,
 ): ProseMirrorNode {
 	const content: ProseMirrorNode[] = [];
 
@@ -319,6 +367,7 @@ function convertListItem(
 		let j = 0;
 		while (j < nestedItems.length) {
 			const anchorType: "bullet" | "number" = nestedItems[j].listItem || parentListType;
+			const anchorId = anchorType === "number" ? normalizeListId(nestedItems[j].listId) : undefined;
 			const nestedGroup: PortableTextTextBlock[] = [];
 
 			do {
@@ -326,8 +375,7 @@ function convertListItem(
 				j++;
 			} while (
 				j < nestedItems.length &&
-				((nestedItems[j].level || 2) > minLevel ||
-					(nestedItems[j].listItem || parentListType) === anchorType)
+				belongsToNestedGroup(nestedItems[j], minLevel, parentListType, anchorType, anchorId)
 			);
 
 			if (nestedGroup.length > 0) {
@@ -336,7 +384,9 @@ function convertListItem(
 					...ni,
 					level: (ni.level || 2) - 1,
 				}));
-				content.push(convertList(adjustedGroup, anchorType));
+				content.push(
+					convertList(adjustedGroup, anchorType, `${context}:nested:${j - nestedGroup.length}`),
+				);
 			}
 		}
 	}

package/src/content/converters/prosemirror-to-portable-text.ts

@@ -5,6 +5,7 @@
  */
 
 import { sanitizeGalleryImages } from "./gallery.js";
+import { readOrderedListMetadata, type OrderedListMetadata } from "./numbered-list.js";
 import type {
 	ProseMirrorDocument,
 	ProseMirrorNode,
@@ -36,8 +37,8 @@ export function prosemirrorToPortableText(doc: ProseMirrorDocument): PortableTex
 
 	const blocks: PortableTextBlock[] = [];
 
-	for (const node of doc.content) {
-		const converted = convertNode(node);
+	for (const [i, node] of doc.content.entries()) {
+		const converted = convertNode(node, `root:${i}`);
 		if (converted) {
 			if (Array.isArray(converted)) {
 				blocks.push(...converted);
@@ -53,7 +54,10 @@ export function prosemirrorToPortableText(doc: ProseMirrorDocument): PortableTex
 /**
  * Convert a single ProseMirror node to Portable Text block(s)
  */
-function convertNode(node: ProseMirrorNode): PortableTextBlock | PortableTextBlock[] | null {
+function convertNode(
+	node: ProseMirrorNode,
+	path: string,
+): PortableTextBlock | PortableTextBlock[] | null {
 	switch (node.type) {
 		case "paragraph":
 			return convertParagraph(node);
@@ -62,10 +66,10 @@ function convertNode(node: ProseMirrorNode): PortableTextBlock | PortableTextBlo
 			return convertHeading(node);
 
 		case "bulletList":
-			return convertList(node, "bullet");
+			return convertList(node, "bullet", path);
 
 		case "orderedList":
-			return convertList(node, "number");
+			return convertList(node, "number", path);
 
 		case "blockquote":
 			return convertBlockquote(node);
@@ -175,12 +179,14 @@ function convertHeading(node: ProseMirrorNode): PortableTextTextBlock | null {
 function convertList(
 	node: ProseMirrorNode,
 	listItem: "bullet" | "number",
+	path: string,
 ): PortableTextTextBlock[] {
 	const blocks: PortableTextTextBlock[] = [];
+	const metadata = listItem === "number" ? readOrderedListMetadata(node.attrs, path) : undefined;
 
-	for (const item of node.content || []) {
+	for (const [i, item] of (node.content ?? []).entries()) {
 		if (item.type === "listItem") {
-			const itemBlocks = convertListItem(item, listItem, 1);
+			const itemBlocks = convertListItem(item, listItem, 1, `${path}:${i}`, metadata);
 			blocks.push(...itemBlocks);
 		}
 	}
@@ -195,10 +201,12 @@ function convertListItem(
 	item: ProseMirrorNode,
 	listItem: "bullet" | "number",
 	level: number,
+	path: string,
+	metadata?: OrderedListMetadata,
 ): PortableTextTextBlock[] {
 	const blocks: PortableTextTextBlock[] = [];
 
-	for (const child of item.content || []) {
+	for (const [i, child] of (item.content ?? []).entries()) {
 		if (child.type === "paragraph") {
 			const { children, markDefs } = convertInlineContent(child.content || []);
 
@@ -209,14 +217,15 @@ function convertListItem(
 					style: "normal",
 					listItem,
 					level,
+					...metadata,
 					children,
 					markDefs: markDefs.length > 0 ? markDefs : undefined,
 				});
 			}
 		} else if (child.type === "bulletList") {
-			blocks.push(...convertListItemNested(child, "bullet", level + 1));
+			blocks.push(...convertListItemNested(child, "bullet", level + 1, `${path}:${i}`));
 		} else if (child.type === "orderedList") {
-			blocks.push(...convertListItemNested(child, "number", level + 1));
+			blocks.push(...convertListItemNested(child, "number", level + 1, `${path}:${i}`));
 		}
 	}
 
@@ -230,12 +239,14 @@ function convertListItemNested(
 	node: ProseMirrorNode,
 	listItem: "bullet" | "number",
 	level: number,
+	path: string,
 ): PortableTextTextBlock[] {
 	const blocks: PortableTextTextBlock[] = [];
+	const metadata = listItem === "number" ? readOrderedListMetadata(node.attrs, path) : undefined;
 
-	for (const item of node.content || []) {
+	for (const [i, item] of (node.content ?? []).entries()) {
 		if (item.type === "listItem") {
-			blocks.push(...convertListItem(item, listItem, level));
+			blocks.push(...convertListItem(item, listItem, level, `${path}:${i}`, metadata));
 		}
 	}
 

package/src/content/converters/types.ts

@@ -41,6 +41,8 @@ export interface PortableTextTextBlock {
 	style?: "normal" | "h1" | "h2" | "h3" | "h4" | "h5" | "h6" | "blockquote";
 	listItem?: "bullet" | "number";
 	level?: number;
+	listId?: string;
+	listStart?: number;
 	children: PortableTextSpan[];
 	markDefs?: PortableTextMarkDef[];
 	textAlign?: "left" | "center" | "right" | "justify";

package/src/content/portable-text-lists.ts

@@ -0,0 +1,205 @@
+import {
+	deriveLegacyListId,
+	normalizeListId,
+	normalizeListStart,
+} from "./converters/numbered-list.js";
+
+type ListNestingMode = "html" | "direct";
+type PortableTextNode = Record<string, unknown>;
+
+interface PortableTextListBlock extends PortableTextNode {
+	_type: "block";
+	children: unknown[];
+	level?: number;
+	listId?: unknown;
+	listItem: string;
+	listStart?: unknown;
+}
+
+export interface PortableTextListNode extends PortableTextNode {
+	_type: "@list";
+	_key: string;
+	children: PortableTextNode[];
+	level: number;
+	listItem: string;
+	mode: ListNestingMode;
+	start?: number;
+}
+
+interface ListDescriptor {
+	node: PortableTextListNode;
+	directItems: Array<{
+		original: PortableTextListBlock;
+		rendered: PortableTextListBlock;
+	}>;
+	level: number;
+	parentContext: string;
+	sourceId: string | undefined;
+	segment: number;
+}
+
+interface ParentItem {
+	context: string;
+	list: ListDescriptor;
+	rendered: PortableTextListBlock;
+}
+
+function isListBlock(node: PortableTextNode): node is PortableTextListBlock {
+	return (
+		node._type === "block" && typeof node.listItem === "string" && Array.isArray(node.children)
+	);
+}
+
+function readLevel(value: unknown): number {
+	return typeof value === "number" && Number.isInteger(value) && value >= 1 ? value : 1;
+}
+
+function findParentItem(items: Map<number, ParentItem>, level: number): ParentItem | undefined {
+	let nearestLevel = 0;
+	let nearest: ParentItem | undefined;
+	for (const [candidate, item] of items) {
+		if (candidate < level && candidate > nearestLevel) {
+			nearestLevel = candidate;
+			nearest = item;
+		}
+	}
+	return nearest;
+}
+
+function matchesList(
+	descriptor: ListDescriptor | undefined,
+	listItem: string,
+	sourceId: string | undefined,
+	parentContext: string,
+): descriptor is ListDescriptor {
+	return (
+		descriptor !== undefined &&
+		descriptor.node.listItem === listItem &&
+		descriptor.parentContext === parentContext &&
+		(listItem !== "number" || descriptor.sourceId === sourceId)
+	);
+}
+
+function buildListTree(
+	blocks: PortableTextNode[],
+	mode: ListNestingMode,
+): { tree: PortableTextNode[]; descriptors: ListDescriptor[] } {
+	const tree: PortableTextNode[] = [];
+	const descriptors: ListDescriptor[] = [];
+	const activeLists = new Map<number, ListDescriptor>();
+	const lastItems = new Map<number, ParentItem>();
+	let segment = 0;
+
+	for (let index = 0; index < blocks.length; index++) {
+		const block = blocks[index];
+		if (!isListBlock(block)) {
+			tree.push(block);
+			activeLists.clear();
+			lastItems.clear();
+			continue;
+		}
+
+		const level = readLevel(block.level);
+		for (const activeLevel of activeLists.keys()) {
+			if (activeLevel > level) activeLists.delete(activeLevel);
+		}
+		for (const itemLevel of lastItems.keys()) {
+			if (itemLevel > level) lastItems.delete(itemLevel);
+		}
+
+		const parent = findParentItem(lastItems, level);
+		const parentContext = parent?.context ?? "root";
+		const sourceId = block.listItem === "number" ? normalizeListId(block.listId) : undefined;
+		let descriptor = activeLists.get(level);
+		if (!matchesList(descriptor, block.listItem, sourceId, parentContext)) {
+			const node: PortableTextListNode = {
+				_type: "@list",
+				_key: `${typeof block._key === "string" ? block._key : index}-parent`,
+				children: [],
+				level,
+				listItem: block.listItem,
+				mode,
+			};
+			descriptor = {
+				node,
+				directItems: [],
+				level,
+				parentContext,
+				sourceId,
+				segment: segment++,
+			};
+			descriptors.push(descriptor);
+			activeLists.set(level, descriptor);
+			if (!parent) {
+				tree.push(node);
+			} else if (mode === "direct") {
+				parent.list.node.children.push(node);
+			} else {
+				parent.rendered.children.push(node);
+			}
+		}
+
+		const rendered = { ...block, children: [...block.children] };
+		descriptor.node.children.push(rendered);
+		descriptor.directItems.push({ original: block, rendered });
+		lastItems.set(level, {
+			context: `${parentContext}/item:${index}`,
+			list: descriptor,
+			rendered,
+		});
+	}
+
+	return { tree, descriptors };
+}
+
+function applyNumbering(descriptors: ListDescriptor[]): void {
+	const bases = new Map<string, number>();
+	const scopeKeys = new Map<ListDescriptor, string>();
+	for (const descriptor of descriptors) {
+		if (descriptor.node.listItem !== "number") continue;
+		const identity =
+			descriptor.sourceId ??
+			deriveLegacyListId(
+				`render:${descriptor.segment}:${descriptor.level}:${descriptor.parentContext}`,
+			);
+		const scope = JSON.stringify([identity, descriptor.level, descriptor.parentContext]);
+		scopeKeys.set(descriptor, scope);
+		if (!descriptor.sourceId || bases.has(scope)) continue;
+		for (const { original } of descriptor.directItems) {
+			const base = normalizeListStart(original.listStart);
+			if (base === undefined) continue;
+			bases.set(scope, base);
+			break;
+		}
+	}
+
+	const counts = new Map<string, number>();
+	for (const descriptor of descriptors) {
+		if (descriptor.node.listItem !== "number") continue;
+		const scope = scopeKeys.get(descriptor)!;
+		const base = bases.get(scope) ?? 1;
+		const count = counts.get(scope) ?? 0;
+		descriptor.node.start = normalizeListStart(base + count) ?? 1;
+		counts.set(scope, count + descriptor.directItems.length);
+	}
+}
+
+function preprocessLists(
+	blocks: PortableTextNode[],
+	mode: ListNestingMode,
+): { tree: PortableTextNode[]; descriptors: ListDescriptor[] } {
+	const result = buildListTree(blocks, mode);
+	applyNumbering(result.descriptors);
+	return result;
+}
+
+export function clonePortableTextValue<T>(value: T): T {
+	return structuredClone(value);
+}
+
+export function buildPortableTextListTree(
+	blocks: PortableTextNode[],
+	mode: ListNestingMode = "html",
+): PortableTextNode[] {
+	return preprocessLists(blocks, mode).tree;
+}

package/src/database/dialect-helpers.ts

@@ -107,35 +107,16 @@ export function currentTimestampValue(db: Kysely<any>): RawBuilder<string> {
 
 /**
  * Build WHERE clause for status filtering on a content table.
- * When filtering for 'published' status, also include scheduled content
- * whose scheduled_at time has passed (treating it as effectively published).
- *
- * Visibility is computed, not flipped by cron, so a literal
- * `status = 'published'` comparison undercounts scheduled-and-due entries —
- * every "publicly visible" filter must go through this helper.
+ * Scheduled content becomes public only after the publication sweep commits
+ * the row with a literal `published` status.
  */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any -- accepts any Kysely instance
 export function buildStatusCondition(
-	db: Kysely<any>,
+	_db: Kysely<any>,
 	status: string,
 	tablePrefix?: string,
 ): ReturnType<typeof sql> {
 	const statusField = tablePrefix ? `${tablePrefix}.status` : "status";
-	const scheduledAtField = tablePrefix ? `${tablePrefix}.scheduled_at` : "scheduled_at";
-
-	if (status === "published") {
-		// Include both published content AND scheduled content past its publish time.
-		// scheduled_at is stored as text (ISO 8601). On Postgres, we must cast it
-		// to timestamptz for the comparison with CURRENT_TIMESTAMP to work.
-		const scheduledAtExpr = isPostgres(db)
-			? sql`${sql.ref(scheduledAtField)}::timestamptz`
-			: sql.ref(scheduledAtField);
-		const nowExpr = isPostgres(db)
-			? currentTimestampValue(db)
-			: sql`strftime('%Y-%m-%dT%H:%M:%fZ', 'now')`;
-		return sql`(${sql.ref(statusField)} = 'published' OR (${sql.ref(statusField)} = 'scheduled' AND ${scheduledAtExpr} <= ${nowExpr}))`;
-	}
-
 	return sql`${sql.ref(statusField)} = ${status}`;
 }