emdash 1.1.0 → 1.2.0

package/src/content/converters/portable-text-identity.ts

@@ -72,6 +72,7 @@ export const PortableTextIdentityExtension = Extension.create({
 					"htmlBlock",
 					"iframeBlock",
 					"image",
+					"videoBlock",
 					"horizontalRule",
 					"gallery",
 					PORTABLE_TEXT_BLOCK_NODE,

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

@@ -41,6 +41,7 @@ import type {
 	PortableTextCodeBlock,
 	PortableTextIframeBlock,
 } from "./types.js";
+import { isPortableTextVideoBlock, videoNodeAttrs } from "./video.js";
 
 function generateKey(): string {
 	return Math.random().toString(36).substring(2, 11);
@@ -304,6 +305,12 @@ function convertBlock(
 		const { _type, _key, ...attrs } = block;
 		return { type: "iframeBlock", attrs: identityAttrs(attrs, _key, preserveIdentity) };
 	}
+	if (isPortableTextVideoBlock(block)) {
+		return {
+			type: "videoBlock",
+			attrs: identityAttrs(videoNodeAttrs(block), block._key, preserveIdentity),
+		};
+	}
 	if (block._type === "break") {
 		return {
 			type: "horizontalRule",

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

@@ -37,7 +37,9 @@ import type {
 	PortableTextCodeBlock,
 	PortableTextHtmlBlock,
 	PortableTextIframeBlock,
+	PortableTextVideoBlock,
 } from "./types.js";
+import { videoBlockFields } from "./video.js";
 
 /**
  * Generate a unique key for Portable Text blocks
@@ -121,6 +123,9 @@ function convertNode(
 		case "image":
 			return convertImage(node);
 
+		case "videoBlock":
+			return convertVideo(node);
+
 		case "gallery":
 			return convertGallery(node);
 
@@ -381,6 +386,17 @@ function convertIframeBlock(node: ProseMirrorNode): PortableTextIframeBlock {
 	return block;
 }
 
+/**
+ * Convert video block to Portable Text
+ */
+function convertVideo(node: ProseMirrorNode): PortableTextVideoBlock {
+	return {
+		_type: "video",
+		_key: portableTextKeyFromAttrs(node.attrs) ?? generateKey(),
+		...videoBlockFields(node.attrs ?? {}),
+	};
+}
+
 function isFrameDimension(value: unknown): value is number {
 	return typeof value === "number" && Number.isInteger(value) && value >= 1 && value <= 10_000;
 }

package/src/content/converters/types.ts

@@ -180,6 +180,27 @@ export interface PortableTextIframeBlock {
 	allowFullscreen?: boolean;
 }
 
+/**
+ * Video block (a Media Library video, or a media provider's)
+ */
+export interface PortableTextVideoBlock {
+	_type: "video";
+	_key: string;
+	/** Absent while the block is empty, before an editor adds a video to it. */
+	asset?: {
+		/** Media Library id, or the provider's asset id */
+		_ref: string;
+		/** File URL of a Media Library video, which needs it to play */
+		url?: string;
+		/** Provider ID for external media (e.g., "cloudflare-stream"); omitted for the Media Library */
+		provider?: string;
+	};
+	caption?: string;
+	/** Size in pixels, in whole numbers. Gives the player its aspect ratio before the video loads. */
+	width?: number;
+	height?: number;
+}
+
 /**
  * Unknown/custom block (preserved for plugin compatibility)
  */
@@ -199,6 +220,7 @@ export type PortableTextBlock =
 	| PortableTextCodeBlock
 	| PortableTextHtmlBlock
 	| PortableTextIframeBlock
+	| PortableTextVideoBlock
 	| PortableTextTableBlock
 	| PortableTextUnknownBlock;
 

package/src/content/converters/video.ts

@@ -0,0 +1,77 @@
+/**
+ * The editor's video block: its shape, and its ProseMirror attributes.
+ * Keep in sync with the admin editor's `VideoNode`.
+ */
+
+import type { PortableTextVideoBlock } from "./types.js";
+
+type FieldCheck = (value: unknown) => boolean;
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+	typeof value === "object" && value !== null && !Array.isArray(value);
+const isString = (value: unknown) => typeof value === "string";
+const isDimension = (value: unknown): value is number =>
+	typeof value === "number" && Number.isInteger(value) && value >= 1;
+
+const hasOnly = (record: Record<string, unknown>, fields: Map<string, FieldCheck>) =>
+	Object.entries(record).every(
+		([key, value]) => value === undefined || (fields.get(key)?.(value) ?? false),
+	);
+
+const ASSET_FIELDS = new Map<string, FieldCheck>([
+	["_ref", isString],
+	["url", isString],
+	["provider", isString],
+]);
+
+const isAsset = (value: unknown) =>
+	isRecord(value) && typeof value._ref === "string" && hasOnly(value, ASSET_FIELDS);
+
+const VIDEO_FIELDS = new Map<string, FieldCheck>([
+	["_type", () => true],
+	["_key", () => true],
+	["asset", isAsset],
+	["caption", isString],
+	["width", isDimension],
+	["height", isDimension],
+]);
+
+/**
+ * Whether a block is the editor's own video block. A `video` block with other
+ * fields, or values of other types, belongs to a plugin.
+ */
+export function isPortableTextVideoBlock(block: unknown): block is PortableTextVideoBlock {
+	return isRecord(block) && block._type === "video" && hasOnly(block, VIDEO_FIELDS);
+}
+
+/** ProseMirror attributes of a `videoBlock` node. */
+export function videoNodeAttrs(block: PortableTextVideoBlock): Record<string, unknown> {
+	return {
+		src: block.asset?.url ?? "",
+		mediaId: block.asset?._ref ?? null,
+		provider: block.asset?.provider,
+		caption: block.caption ?? "",
+		width: block.width,
+		height: block.height,
+	};
+}
+
+/** A `videoBlock` node's Portable Text fields, writing optional fields only when set. */
+export function videoBlockFields(
+	attrs: Record<string, unknown>,
+): Omit<PortableTextVideoBlock, "_type" | "_key"> {
+	const { src, mediaId, provider, caption, width, height } = attrs;
+	const asset: NonNullable<PortableTextVideoBlock["asset"]> = {
+		_ref: typeof mediaId === "string" ? mediaId : "",
+	};
+	if (typeof src === "string" && src) asset.url = src;
+	if (typeof provider === "string" && provider && provider !== "local") asset.provider = provider;
+	// An empty block has no media id, file or provider.
+	const empty = typeof mediaId !== "string" && !asset.url && !asset.provider;
+	return {
+		...(empty ? {} : { asset }),
+		...(typeof caption === "string" && caption ? { caption } : {}),
+		...(isDimension(width) ? { width } : {}),
+		...(isDimension(height) ? { height } : {}),
+	};
+}

package/src/database/datetime-storage.ts

@@ -430,13 +430,13 @@ export async function normalizeDatetimeStorage(
 	db: Kysely<Database>,
 ): Promise<DatetimeStorageReport> {
 	const preflight = await scan(db, false);
-	console.error(`[datetime migration] ${formatDatetimeStorageReport(preflight)}`);
 	if (preflight.manualReviewCount > 0 || preflight.inspectionErrorCount > 0) {
 		throw new Error(
 			`Datetime migration requires manual review:\n${formatDatetimeStorageReport(preflight)}`,
 		);
 	}
 	if (preflight.noncanonicalCount === 0) return preflight;
+	console.info(`[datetime migration] ${formatDatetimeStorageReport(preflight)}`);
 	await scan(db, true);
 	const verified = await scan(db, false);
 	if (

package/src/database/migrations/runner.ts

@@ -253,6 +253,18 @@ export class MigrationLockHeldError extends Error {
 	}
 }
 
+/**
+ * Thrown when the migrator reports an error while applying pending migrations.
+ * Callers with failure backoff apply it. Errors from the applied-migration
+ * count check before the migrator runs are not wrapped and stay retryable.
+ */
+export class MigrationFailedError extends Error {
+	constructor(message: string) {
+		super(message);
+		this.name = "MigrationFailedError";
+	}
+}
+
 /** Custom migration table name */
 const MIGRATION_TABLE = "_emdash_migrations";
 
@@ -551,7 +563,7 @@ export async function runMigrations(
 		}
 
 		const failedSuffix = failedMigration ? ` (migration: ${failedMigration.migrationName})` : "";
-		throw new Error(`Migration failed: ${msg || "unknown error"}${failedSuffix}`);
+		throw new MigrationFailedError(`Migration failed: ${msg || "unknown error"}${failedSuffix}`);
 	}
 
 	return { applied };

package/src/database/repositories/comment.ts

@@ -8,6 +8,20 @@ import { encodeCursor, decodeCursor, type FindManyResult } from "./types.js";
 /** Matches LIKE wildcard characters and the escape character itself */
 const LIKE_ESCAPE_RE = /[%_\\]/g;
 
+const DEFAULT_COMMENT_LIMIT = 50;
+const MAX_COMMENT_LIMIT = 100;
+
+/**
+ * Normalize a caller-supplied page size to a whole number in [1, MAX].
+ * A fractional value reaching SQLite's `LIMIT` errors, and a negative one
+ * disables the cap; non-finite input falls back to the default.
+ */
+function clampLimit(limit: number | undefined): number {
+	const n = Math.floor(Number(limit));
+	if (!Number.isFinite(n)) return DEFAULT_COMMENT_LIMIT;
+	return Math.min(Math.max(n, 1), MAX_COMMENT_LIMIT);
+}
+
 // ---------------------------------------------------------------------------
 // Types
 // ---------------------------------------------------------------------------
@@ -147,7 +161,7 @@ export class CommentRepository {
 		contentId: string,
 		options: { status?: CommentStatus; limit?: number; cursor?: string } = {},
 	): Promise<FindManyResult<Comment>> {
-		const limit = Math.max(1, Math.min(options.limit || 50, 100));
+		const limit = clampLimit(options.limit);
 
 		let query = this.db
 			.selectFrom("_emdash_comments")
@@ -195,7 +209,7 @@ export class CommentRepository {
 		status: CommentStatus,
 		options: { collection?: string; search?: string; limit?: number; cursor?: string } = {},
 	): Promise<FindManyResult<Comment>> {
-		const limit = Math.max(1, Math.min(options.limit || 50, 100));
+		const limit = clampLimit(options.limit);
 
 		let query = this.db.selectFrom("_emdash_comments").selectAll().where("status", "=", status);
 
@@ -246,7 +260,7 @@ export class CommentRepository {
 
 	/** List non-trashed comments for capability-gated plugin administration. */
 	async findForPlugin(options: PluginCommentFindOptions = {}): Promise<FindManyResult<Comment>> {
-		const limit = Math.max(1, Math.min(options.limit ?? 50, 100));
+		const limit = clampLimit(options.limit);
 		let query = this.db.selectFrom("_emdash_comments").selectAll().where("status", "!=", "trash");
 
 		if (options.status) query = query.where("status", "=", options.status);

package/src/database/repositories/content.ts

@@ -299,6 +299,16 @@ function getTableName(type: string): string {
 	return `ec_${type}`;
 }
 
+function assertPageOffset(offset: number | undefined, cursor: string | undefined): void {
+	if (offset === undefined) return;
+	if (cursor !== undefined) {
+		throw new EmDashValidationError("cursor and offset cannot be used together");
+	}
+	if (!Number.isSafeInteger(offset) || offset < 0) {
+		throw new EmDashValidationError("offset must be a non-negative integer");
+	}
+}
+
 /**
  * Serialize a value for database storage
  * Objects/arrays are JSON-stringified
@@ -837,6 +847,7 @@ export class ContentRepository {
 	): Promise<FindManyResult<ContentItem>> {
 		const tableName = getTableName(type);
 		const limit = Math.max(1, Math.min(options.limit || 50, 100));
+		assertPageOffset(options.offset, options.cursor);
 
 		// Determine ordering
 		const orderField = options.orderBy?.field || "createdAt";
@@ -951,7 +962,11 @@ export class ContentRepository {
 		if (indexedOrderFilter?.kind !== "null") {
 			query = query.orderBy(dbField as any, safeOrderDirection === "ASC" ? "asc" : "desc");
 		}
-		query = query.orderBy("id", safeOrderDirection === "ASC" ? "asc" : "desc").limit(limit + 1);
+		query = query.orderBy("id", safeOrderDirection === "ASC" ? "asc" : "desc");
+		query =
+			options.offset === undefined
+				? query.limit(limit + 1)
+				: query.limit(limit).offset(options.offset);
 
 		// Run the page fetch and the unbounded count together — the UI needs
 		// both to render a stable denominator (kept on every page intentionally),
@@ -1694,6 +1709,7 @@ export class ContentRepository {
 	): Promise<FindManyResult<ContentItem & { deletedAt: string }>> {
 		const tableName = getTableName(type);
 		const limit = Math.max(1, Math.min(options.limit || 50, 100));
+		assertPageOffset(options.offset, options.cursor);
 
 		// Determine ordering - default to most recently deleted
 		const orderField = options.orderBy?.field || "deletedAt";
@@ -1734,8 +1750,11 @@ export class ContentRepository {
 
 		query = query
 			.orderBy(dbField as any, safeOrderDirection === "ASC" ? "asc" : "desc")
-			.orderBy("id", safeOrderDirection === "ASC" ? "asc" : "desc")
-			.limit(limit + 1);
+			.orderBy("id", safeOrderDirection === "ASC" ? "asc" : "desc");
+		query =
+			options.offset === undefined
+				? query.limit(limit + 1)
+				: query.limit(limit).offset(options.offset);
 
 		const rows = await query.execute();
 		const hasMore = rows.length > limit;

package/src/database/repositories/plugin-storage.ts

@@ -36,6 +36,7 @@ import type {
 	ConditionalWriteResult,
 	ConditionalDeleteResult,
 } from "../../plugins/types.js";
+import { chunks, SQL_BATCH_SIZE } from "../../utils/chunks.js";
 import { pluginDataWriteExpr, pluginDataUpdateGuard } from "../dialect-helpers.js";
 import { withTransaction } from "../transaction.js";
 import type { Database } from "../types.js";
@@ -271,18 +272,20 @@ export class PluginStorageRepository<T = unknown> implements StorageCollection<T
 	async getMany(ids: string[]): Promise<Map<string, T>> {
 		if (ids.length === 0) return new Map();
 
-		const rows = await this.db
-			.selectFrom("_plugin_storage")
-			.select(["id", "data"])
-			.where("plugin_id", "=", this.pluginId)
-			.where("collection", "=", this.collection)
-			.where("id", "in", ids)
-			.execute();
-
 		const result = new Map<string, T>();
-		for (const row of rows) {
-			// eslint-disable-next-line typescript/no-unsafe-type-assertion -- JSON.parse returns any; generic callers provide T
-			result.set(row.id, JSON.parse(row.data) as T);
+		for (const batch of chunks(ids, SQL_BATCH_SIZE)) {
+			const rows = await this.db
+				.selectFrom("_plugin_storage")
+				.select(["id", "data"])
+				.where("plugin_id", "=", this.pluginId)
+				.where("collection", "=", this.collection)
+				.where("id", "in", batch)
+				.execute();
+
+			for (const row of rows) {
+				// eslint-disable-next-line typescript/no-unsafe-type-assertion -- JSON.parse returns any; generic callers provide T
+				result.set(row.id, JSON.parse(row.data) as T);
+			}
 		}
 		return result;
 	}
@@ -330,14 +333,20 @@ export class PluginStorageRepository<T = unknown> implements StorageCollection<T
 	async deleteMany(ids: string[]): Promise<number> {
 		if (ids.length === 0) return 0;
 
-		const result = await this.db
-			.deleteFrom("_plugin_storage")
-			.where("plugin_id", "=", this.pluginId)
-			.where("collection", "=", this.collection)
-			.where("id", "in", ids)
-			.executeTakeFirst();
-
-		return Number(result.numDeletedRows ?? 0);
+		return withTransaction(this.db, async (trx) => {
+			let deleted = 0;
+			for (const batch of chunks(ids, SQL_BATCH_SIZE)) {
+				const result = await trx
+					.deleteFrom("_plugin_storage")
+					.where("plugin_id", "=", this.pluginId)
+					.where("collection", "=", this.collection)
+					.where("id", "in", batch)
+					.executeTakeFirst();
+
+				deleted += Number(result.numDeletedRows ?? 0);
+			}
+			return deleted;
+		});
 	}
 
 	/**

package/src/database/repositories/redirect.ts

@@ -474,7 +474,11 @@ export class RedirectRepository {
 	 */
 	async matchPath(path: string): Promise<RedirectMatch | null> {
 		// 1. Exact match (fast, indexed)
-		const exact = await this.findExactMatch(path);
+		let exact = await this.findExactMatch(path);
+		if (!exact && path.length > 1) {
+			const alt = path.endsWith("/") ? path.slice(0, -1) : `${path}/`;
+			exact = await this.findExactMatch(alt);
+		}
 		if (exact && isSiteRelativeDestination(exact.destination)) {
 			return { redirect: exact, resolvedDestination: exact.destination };
 		}
@@ -638,7 +642,7 @@ export class RedirectRepository {
 	 *
 	 * This is called from the public redirect middleware on every 404 and
 	 * must never throw for an unauthenticated caller — failures bubble up to
-	 * the middleware, which swallows them.
+	 * the middleware, which catches and logs them.
 	 */
 	async log404(entry: {
 		path: string;
@@ -688,6 +692,24 @@ export class RedirectRepository {
 	 * Called by scheduled system cleanup, never by the anonymous request path.
 	 */
 	async cleanup404Log(): Promise<number> {
+		// Cheap precheck: the expensive DELETE is only needed once the table
+		// has grown past MAX_404_LOG_ROWS. Counting a bounded sample avoids
+		// the full-table ORDER BY/NOT IN scan on the overwhelming majority
+		// of cron ticks when there is nothing to evict.
+		const probe = await this.db
+			.selectFrom(
+				this.db
+					.selectFrom("_emdash_404_log")
+					.select(sql`1`.as("one"))
+					.limit(MAX_404_LOG_ROWS + 1)
+					.as("sample"),
+			)
+			.select(({ fn }) => fn.countAll<number>().as("count"))
+			.executeTakeFirstOrThrow();
+		if (Number(probe.count) <= MAX_404_LOG_ROWS) {
+			return 0;
+		}
+
 		// Keep the newest rows in one statement. Deriving the victims inside the
 		// DELETE makes overlapping cleanup runs idempotent: each statement
 		// evaluates the current newest set instead of acting on a stale count.

package/src/database/repositories/taxonomy.ts

@@ -2,6 +2,7 @@ import { sql, type Kysely, type Selectable } from "kysely";
 import { ulid } from "ulidx";
 
 import { invalidateTaxonomyObjectCache } from "../../object-cache/index.js";
+import { chunks, SQL_BATCH_SIZE } from "../../utils/chunks.js";
 import { slugify } from "../../utils/slugify.js";
 import { withTransaction } from "../transaction.js";
 import type { Database, TaxonomyTable } from "../types.js";
@@ -19,6 +20,8 @@ export interface SiblingPosition {
  * statement inside D1's 100-parameter ceiling.
  */
 const GROUPS_PER_UPDATE = 32;
+/** Rows per `content_taxonomies` insert. Each row binds three parameters. */
+const ASSIGNMENTS_PER_INSERT = 32;
 const NUMERIC_SUFFIX_PATTERN = /^\d+$/;
 
 /** Deal the listed groups back out over the slots they hold, in the order given. */
@@ -618,8 +621,8 @@ export class TaxonomyRepository {
 	}
 
 	/**
-	 * Attach already-resolved term translation groups in one insert and return
-	 * the number of assignments that did not already exist.
+	 * Attach already-resolved term translation groups and return the number of
+	 * assignments that did not already exist.
 	 */
 	async attachGroupsToEntry(
 		collection: string,
@@ -631,22 +634,60 @@ export class TaxonomyRepository {
 		const entryGroup = await this.resolveEntryTranslationGroup(collection, entryId);
 		if (!entryGroup) return 0;
 
-		const result = await this.db
-			.insertInto("content_taxonomies")
-			.values(
-				uniqueGroups.map((taxonomy_id) => ({
-					collection,
-					entry_id: entryGroup,
-					taxonomy_id,
-				})),
-			)
-			.onConflict((oc) => oc.doNothing())
-			.executeTakeFirst();
-		const inserted = Number(result.numInsertedOrUpdatedRows ?? 0n);
+		const inserted = await this.insertAssignments(collection, entryGroup, uniqueGroups);
 		if (inserted > 0) invalidateTaxonomyObjectCache();
 		return inserted;
 	}
 
+	private async insertAssignments(
+		collection: string,
+		entryGroup: string,
+		taxonomyGroups: string[],
+	): Promise<number> {
+		let inserted = 0;
+		try {
+			for (const batch of chunks(taxonomyGroups, ASSIGNMENTS_PER_INSERT)) {
+				// oxlint-disable-next-line no-await-in-loop -- one statement per D1-safe batch
+				const result = await this.db
+					.insertInto("content_taxonomies")
+					.values(batch.map((taxonomy_id) => ({ collection, entry_id: entryGroup, taxonomy_id })))
+					.onConflict((oc) => oc.doNothing())
+					.executeTakeFirst();
+				inserted += Number(result.numInsertedOrUpdatedRows ?? 0n);
+			}
+		} catch (error) {
+			// Earlier batches are already written.
+			if (inserted > 0) invalidateTaxonomyObjectCache();
+			throw error;
+		}
+		return inserted;
+	}
+
+	private async deleteAssignments(
+		collection: string,
+		entryGroup: string,
+		taxonomyGroups: string[],
+	): Promise<number> {
+		let removed = 0;
+		try {
+			for (const batch of chunks(taxonomyGroups, SQL_BATCH_SIZE)) {
+				// oxlint-disable-next-line no-await-in-loop -- one statement per D1-safe batch
+				const result = await this.db
+					.deleteFrom("content_taxonomies")
+					.where("collection", "=", collection)
+					.where("entry_id", "=", entryGroup)
+					.where("taxonomy_id", "in", batch)
+					.executeTakeFirst();
+				removed += Number(result.numDeletedRows ?? 0n);
+			}
+		} catch (error) {
+			// Earlier batches are already deleted.
+			if (removed > 0) invalidateTaxonomyObjectCache();
+			throw error;
+		}
+		return removed;
+	}
+
 	async detachFromEntry(collection: string, entryId: string, taxonomyId: string): Promise<void> {
 		const [entryGroup, taxonomyGroup] = await Promise.all([
 			this.resolveEntryTranslationGroup(collection, entryId),
@@ -674,13 +715,7 @@ export class TaxonomyRepository {
 		const entryGroup = await this.resolveEntryTranslationGroup(collection, entryId);
 		if (!entryGroup) return 0;
 
-		const result = await this.db
-			.deleteFrom("content_taxonomies")
-			.where("collection", "=", collection)
-			.where("entry_id", "=", entryGroup)
-			.where("taxonomy_id", "in", uniqueGroups)
-			.executeTakeFirst();
-		const removed = Number(result.numDeletedRows ?? 0n);
+		const removed = await this.deleteAssignments(collection, entryGroup, uniqueGroups);
 		if (removed > 0) invalidateTaxonomyObjectCache();
 		return removed;
 	}
@@ -792,31 +827,13 @@ export class TaxonomyRepository {
 		const currentGroups = new Set(current.map((r) => r.group));
 
 		const toRemove = [...currentGroups].filter((g) => !newGroups.has(g));
-		if (toRemove.length > 0) {
-			await this.db
-				.deleteFrom("content_taxonomies")
-				.where("collection", "=", collection)
-				.where("entry_id", "=", entryGroup)
-				.where("taxonomy_id", "in", toRemove)
-				.execute();
-		}
-
 		const toAdd = [...newGroups].filter((g) => !currentGroups.has(g));
-		if (toAdd.length > 0) {
-			await this.db
-				.insertInto("content_taxonomies")
-				.values(
-					toAdd.map((taxonomy_id) => ({
-						collection,
-						entry_id: entryGroup,
-						taxonomy_id,
-					})),
-				)
-				.onConflict((oc) => oc.doNothing())
-				.execute();
+		try {
+			if (toRemove.length > 0) await this.deleteAssignments(collection, entryGroup, toRemove);
+			if (toAdd.length > 0) await this.insertAssignments(collection, entryGroup, toAdd);
+		} finally {
+			if (toRemove.length > 0 || toAdd.length > 0) invalidateTaxonomyObjectCache();
 		}
-
-		if (toRemove.length > 0 || toAdd.length > 0) invalidateTaxonomyObjectCache();
 	}
 
 	async clearEntryTerms(collection: string, entryId: string): Promise<number> {
@@ -921,8 +938,6 @@ export class TaxonomyRepository {
 	async countEntriesForTerms(translationGroups: string[]): Promise<Map<string, number>> {
 		if (translationGroups.length === 0) return new Map();
 
-		const { chunks, SQL_BATCH_SIZE } = await import("../../utils/chunks.js");
-
 		const counts = new Map<string, number>();
 		for (const chunk of chunks(translationGroups, SQL_BATCH_SIZE)) {
 			const rows = await this.db

package/src/database/repositories/types.ts

@@ -223,6 +223,8 @@ export interface FindManyOptions {
 	sortableExtras?: string[];
 	limit?: number;
 	cursor?: string; // Base64-encoded JSON: {orderValue: string, id: string}
+	/** Rows to skip before the page, for numbered pages. Cannot be combined with `cursor`. */
+	offset?: number;
 }
 
 export interface FindManyResult<T> {