emdash 0.37.0 → 0.39.0

package/src/database/repositories/revision.ts

@@ -1,11 +1,16 @@
-import { sql, type Kysely } from "kysely";
+import { sql, type Kysely, type Selectable } from "kysely";
 import { monotonicFactory } from "ulidx";
 
+import { ContentDatetimeNormalizer } from "../content-datetime.js";
 import type { Database, RevisionTable } from "../types.js";
 import { validateIdentifier } from "../validate.js";
 
 const monotonic = monotonicFactory();
 
+export function createRevisionId(): string {
+	return monotonic();
+}
+
 export interface Revision {
 	id: string;
 	collection: string;
@@ -22,6 +27,12 @@ export interface CreateRevisionInput {
 	authorId?: string;
 }
 
+export function normalizeRevisionLimit(value: unknown): number {
+	const numeric = Number(value);
+	if (!Number.isFinite(numeric)) return 50;
+	return Math.max(1, Math.min(Math.trunc(numeric), 100));
+}
+
 /**
  * Revision repository for version history
  *
@@ -29,19 +40,24 @@ export interface CreateRevisionInput {
  * Used when collection has `supports: ["revisions"]` enabled.
  */
 export class RevisionRepository {
-	constructor(private db: Kysely<Database>) {}
+	private readonly datetimes: ContentDatetimeNormalizer;
+
+	constructor(private db: Kysely<Database>) {
+		this.datetimes = new ContentDatetimeNormalizer(db);
+	}
 
 	/**
 	 * Create a new revision
 	 */
 	async create(input: CreateRevisionInput): Promise<Revision> {
-		const id = monotonic();
+		const id = createRevisionId();
+		const data = await this.datetimes.normalizeData(input.collection, input.data);
 
 		const row: Omit<RevisionTable, "created_at"> = {
 			id,
 			collection: input.collection,
 			entry_id: input.entryId,
-			data: JSON.stringify(input.data),
+			data: JSON.stringify(data),
 			author_id: input.authorId ?? null,
 		};
 
@@ -52,26 +68,30 @@ export class RevisionRepository {
 			throw new Error("Failed to create revision");
 		}
 
+		await this.queuePruning(input.collection, input.entryId, id);
+
+		return revision;
+	}
+
+	async queuePruning(collection: string, entryId: string, revisionId: string): Promise<void> {
 		try {
 			await this.db
 				.insertInto("_emdash_revision_prune_queue")
 				.values({
-					collection: input.collection,
-					entry_id: input.entryId,
-					revision_id: id,
+					collection,
+					entry_id: entryId,
+					revision_id: revisionId,
 				})
 				.onConflict((conflict) =>
-					conflict.columns(["collection", "entry_id"]).doUpdateSet({ revision_id: id }),
+					conflict.columns(["collection", "entry_id"]).doUpdateSet({ revision_id: revisionId }),
 				)
 				.execute();
 		} catch (error) {
 			console.error(
-				`[revisions] Failed to queue revision pruning for ${input.collection}/${input.entryId}:`,
+				`[revisions] Failed to queue revision pruning for ${collection}/${entryId}:`,
 				error,
 			);
 		}
-
-		return revision;
 	}
 
 	/**
@@ -84,7 +104,7 @@ export class RevisionRepository {
 			.where("id", "=", id)
 			.executeTakeFirst();
 
-		return row ? this.rowToRevision(row) : null;
+		return row ? this.normalizeRow(row) : null;
 	}
 
 	/**
@@ -110,7 +130,71 @@ export class RevisionRepository {
 		}
 
 		const rows = await query.execute();
-		return rows.map((row) => this.rowToRevision(row));
+		const data = await this.datetimes.normalizeDataMany(
+			collection,
+			rows.map((row) => JSON.parse(row.data)),
+		);
+		return rows.map((row, index) => {
+			const normalized = data[index];
+			if (!normalized) throw new Error("Failed to normalize revision data");
+			return this.rowToRevision(row, normalized);
+		});
+	}
+
+	/** Read revisions only when the owning content row is visible in the same statement snapshot. */
+	async findVisibleByEntry(
+		collection: string,
+		entryId: string,
+		options: { limit?: number } = {},
+	): Promise<Revision[]> {
+		validateIdentifier(collection, "collection");
+		const tableName = `ec_${collection}`;
+		const limit = normalizeRevisionLimit(options.limit);
+		const result = await sql<Selectable<RevisionTable>>`
+			SELECT revisions.* FROM revisions
+			WHERE revisions.collection = ${collection}
+			AND revisions.entry_id = ${entryId}
+			AND EXISTS (
+				SELECT 1 FROM ${sql.ref(tableName)} AS content
+				WHERE content.id = ${entryId}
+				AND content.deleted_at IS NULL
+			)
+			ORDER BY revisions.id DESC
+			LIMIT ${limit}
+		`.execute(this.db);
+		const data = await this.datetimes.normalizeDataMany(
+			collection,
+			result.rows.map((row) => JSON.parse(row.data)),
+		);
+		return result.rows.map((row, index) => {
+			const normalized = data[index];
+			if (!normalized) throw new Error("Failed to normalize revision data");
+			return this.rowToRevision(row, normalized);
+		});
+	}
+
+	/** Read one revision only when its owning content row is visible in the same statement snapshot. */
+	async findVisibleById(
+		collection: string,
+		entryId: string,
+		revisionId: string,
+	): Promise<Revision | null> {
+		validateIdentifier(collection, "collection");
+		const tableName = `ec_${collection}`;
+		const result = await sql<Selectable<RevisionTable>>`
+			SELECT revisions.* FROM revisions
+			WHERE revisions.id = ${revisionId}
+			AND revisions.collection = ${collection}
+			AND revisions.entry_id = ${entryId}
+			AND EXISTS (
+				SELECT 1 FROM ${sql.ref(tableName)} AS content
+				WHERE content.id = ${entryId}
+				AND content.deleted_at IS NULL
+			)
+			LIMIT 1
+		`.execute(this.db);
+		const row = result.rows[0];
+		return row ? this.normalizeRow(row) : null;
 	}
 
 	/**
@@ -126,7 +210,7 @@ export class RevisionRepository {
 			.limit(1)
 			.executeTakeFirst();
 
-		return row ? this.rowToRevision(row) : null;
+		return row ? this.normalizeRow(row) : null;
 	}
 
 	/**
@@ -256,19 +340,34 @@ export class RevisionRepository {
 	/**
 	 * Convert database row to Revision object
 	 */
-	private rowToRevision(row: {
+	private async normalizeRow(row: {
 		id: string;
 		collection: string;
 		entry_id: string;
 		data: string;
 		author_id: string | null;
 		created_at: string;
-	}): Revision {
+	}): Promise<Revision> {
+		const data = await this.datetimes.normalizeData(row.collection, JSON.parse(row.data));
+		return this.rowToRevision(row, data);
+	}
+
+	private rowToRevision(
+		row: {
+			id: string;
+			collection: string;
+			entry_id: string;
+			data: string;
+			author_id: string | null;
+			created_at: string;
+		},
+		data: Record<string, unknown>,
+	): Revision {
 		return {
 			id: row.id,
 			collection: row.collection,
 			entryId: row.entry_id,
-			data: JSON.parse(row.data),
+			data,
 			authorId: row.author_id,
 			createdAt: row.created_at,
 		};

package/src/database/repositories/taxonomy.ts

@@ -215,6 +215,18 @@ export class TaxonomyRepository {
 		return row ? this.rowToTaxonomy(row) : null;
 	}
 
+	/** Resolve either a locale row id or a locale-agnostic translation group. */
+	async findByIdOrTranslationGroup(id: string): Promise<Taxonomy | null> {
+		const row = await this.db
+			.selectFrom("taxonomies")
+			.selectAll()
+			.where((eb) => eb.or([eb("id", "=", id), eb("translation_group", "=", id)]))
+			.orderBy("locale", "asc")
+			.orderBy("id", "asc")
+			.executeTakeFirst();
+		return row ? this.rowToTaxonomy(row) : null;
+	}
+
 	/**
 	 * Find a term by (name, slug). When `locale` is provided, filter by it.
 	 * When omitted, returns the lowest-locale-code match (deterministic across
@@ -612,6 +624,28 @@ export class TaxonomyRepository {
 		invalidateTaxonomyObjectCache();
 	}
 
+	/** Remove already-resolved term groups without replacing concurrent assignments. */
+	async detachGroupsFromEntry(
+		collection: string,
+		entryId: string,
+		taxonomyGroups: string[],
+	): Promise<number> {
+		const uniqueGroups = [...new Set(taxonomyGroups)];
+		if (uniqueGroups.length === 0) return 0;
+		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);
+		if (removed > 0) invalidateTaxonomyObjectCache();
+		return removed;
+	}
+
 	/**
 	 * Taxonomy terms assigned to a content entry, resolved into a specific locale.
 	 * Terms whose translation_group lacks a row in the requested locale are
@@ -749,7 +783,15 @@ export class TaxonomyRepository {
 	async clearEntryTerms(collection: string, entryId: string): Promise<number> {
 		const entryGroup = await this.resolveEntryTranslationGroup(collection, entryId);
 		if (!entryGroup) return 0;
+		return this.clearEntryGroupTerms(collection, entryGroup);
+	}
 
+	/**
+	 * Remove every term assignment held by an entry translation group. Takes the
+	 * group rather than an entry id, so it still works after the group's last
+	 * row has been deleted.
+	 */
+	async clearEntryGroupTerms(collection: string, entryGroup: string): Promise<number> {
 		const result = await this.db
 			.deleteFrom("content_taxonomies")
 			.where("collection", "=", collection)

package/src/database/repositories/types.ts

@@ -23,6 +23,8 @@ export interface CreateContentInput {
 	primaryBylineId?: string | null;
 	locale?: string;
 	translationOf?: string;
+	/** Field columns selected atomically from `translationOf` during the insert. */
+	inheritFields?: string[];
 	publishedAt?: string | null;
 	/** Override created_at (ISO 8601). Used by importers to preserve original dates. */
 	createdAt?: string | null;
@@ -34,7 +36,10 @@ export interface UpdateContentInput {
 	slug?: string | null;
 	publishedAt?: string | null;
 	scheduledAt?: string | null;
+	/** Entry owner (`ec_{collection}.author_id`). */
 	authorId?: string | null;
+	/** Revision author, separate from entry ownership. */
+	revisionAuthorId?: string | null;
 	primaryBylineId?: string | null;
 }
 

package/src/database/types.ts

@@ -396,6 +396,7 @@ export interface DeviceCodeTable {
 export interface OptionTable {
 	name: string;
 	value: string; // JSON
+	revision: Generated<string>;
 }
 
 export interface AuditLogTable {
@@ -433,12 +434,14 @@ export interface CollectionTable {
 	date_field: string | null; // field slug (datetime) for the admin list Date column (NULL = default)
 	url_pattern: string | null; // URL pattern with {slug} placeholder (e.g. "/blog/{slug}")
 	routable: Generated<number>; // 0 or 1 — published entries require a slug when enabled
-	hidden: Generated<number>; // 0 or 1 — omit the auto-generated admin sidebar entry
+	hidden: Generated<number>; // 0 or 1 — omit the auto-generated sidebar entry and dashboard quick action
 	sort_order: number | null; // explicit admin sidebar position; NULL = alphabetical fallback
+	nav_group: string | null; // admin sidebar folder label; NULL = inline
 	comments_enabled: Generated<number>; // 0 or 1
 	comments_moderation: Generated<string>; // 'all' | 'first_time' | 'none'
 	comments_closed_after_days: Generated<number>; // 0 = never close
 	comments_auto_approve_users: Generated<number>; // 0 or 1
+	edit_locking: Generated<number>; // 0 or 1; take an edit lock when an entry is opened
 	created_at: Generated<string>;
 	updated_at: Generated<string>;
 }
@@ -482,6 +485,7 @@ export interface PluginStorageTable {
 	collection: string;
 	id: string;
 	data: string; // JSON
+	revision: Generated<string>;
 	created_at: Generated<string>;
 	updated_at: Generated<string>;
 }
@@ -677,6 +681,7 @@ export interface Database {
 	_emdash_comments: CommentTable;
 	_emdash_comment_reactions: CommentReactionTable;
 	_emdash_redirects: RedirectTable;
+	_emdash_redirect_write_lock: RedirectWriteLockTable;
 	_emdash_404_log: NotFoundLogTable;
 	_emdash_bylines: BylineTable;
 	_emdash_content_bylines: ContentBylineTable;
@@ -686,6 +691,7 @@ export interface Database {
 	_emdash_relations: RelationTable;
 	_emdash_content_references: ContentReferenceTable;
 	_emdash_rate_limits: RateLimitTable;
+	_emdash_entry_locks: EntryLockTable;
 }
 
 export type MediaRow = {
@@ -720,10 +726,20 @@ export interface RedirectTable {
 	last_hit_at: string | null;
 	group_name: string | null;
 	auto: number; // boolean: system-generated from slug change
+	config_revision: string;
+	source_guard: number;
+	write_generation: number;
 	created_at: string;
 	updated_at: string;
 }
 
+export interface RedirectWriteLockTable {
+	id: number;
+	token: string;
+	expires_at: number;
+	generation: number;
+}
+
 export interface NotFoundLogTable {
 	id: string;
 	path: string;
@@ -860,3 +876,12 @@ export interface RateLimitTable {
 	window: string; // ISO timestamp truncated to window size
 	count: number;
 }
+
+export interface EntryLockTable {
+	collection: string;
+	entry_id: string; // ID in the ec_* table
+	user_id: string;
+	token: string; // identifies the holder's editing session, one per tab
+	acquired_at: string; // ISO 8601 with milliseconds
+	expires_at: string; // ISO 8601 with milliseconds
+}

package/src/datetime-normalization.ts

@@ -0,0 +1,311 @@
+import { z } from "zod";
+
+export type DatetimeNormalizationKind = "canonical" | "offset" | "naive";
+
+export type DatetimeNormalizationErrorCode =
+	| "invalid"
+	| "invalid_timezone"
+	| "offset_required"
+	| "ambiguous"
+	| "nonexistent";
+
+export class DatetimeNormalizationError extends Error {
+	constructor(
+		public readonly code: DatetimeNormalizationErrorCode,
+		public readonly value: unknown,
+		public readonly timezone: string,
+	) {
+		const detail =
+			code === "ambiguous"
+				? "occurs more than once because of a daylight-saving transition"
+				: code === "nonexistent"
+					? "does not exist because of a daylight-saving transition"
+					: code === "invalid_timezone"
+						? `uses an invalid site timezone (${timezone})`
+						: code === "offset_required"
+							? "must include Z or an explicit UTC offset"
+							: "is not a valid ISO 8601 datetime";
+		super(`Datetime ${JSON.stringify(value)} ${detail}`);
+		this.name = "DatetimeNormalizationError";
+	}
+}
+
+export interface DatetimeFieldDescriptor {
+	slug: string;
+	type: "datetime" | "repeater";
+	datetimeSubFields?: readonly string[];
+}
+
+export interface NormalizedDatetime {
+	value: string;
+	kind: DatetimeNormalizationKind;
+}
+
+export interface NormalizedContentDatetimes {
+	value: Record<string, unknown>;
+	changedCount: number;
+	naiveCount: number;
+}
+
+interface LocalDatetimeParts {
+	year: number;
+	month: number;
+	day: number;
+	hour: number;
+	minute: number;
+	second: number;
+	millisecond: number;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+const NAIVE_DATETIME_PATTERN =
+	/^(\d{4})-(\d{2})-(\d{2})(?:[T ](\d{2}):(\d{2})(?::(\d{2})(?:\.(\d{1,3}))?)?)?$/;
+const EXPLICIT_OFFSET_PATTERN = /(?:Z|[+-]\d{2}:?\d{2})$/i;
+const EXPLICIT_DATETIME_SCHEMA = z.iso
+	.datetime({ offset: true })
+	.or(z.iso.datetime({ offset: true, precision: -1 }));
+const OFFSET_SAMPLE_RANGE_MS = 48 * 60 * 60 * 1000;
+const OFFSET_SAMPLE_STEP_MS = 6 * 60 * 60 * 1000;
+
+function parseNaiveDatetime(value: string): LocalDatetimeParts | null {
+	const match = NAIVE_DATETIME_PATTERN.exec(value);
+	if (!match) return null;
+	const parts: LocalDatetimeParts = {
+		year: Number(match[1]),
+		month: Number(match[2]),
+		day: Number(match[3]),
+		hour: Number(match[4] ?? 0),
+		minute: Number(match[5] ?? 0),
+		second: Number(match[6] ?? 0),
+		millisecond: Number((match[7] ?? "0").padEnd(3, "0")),
+	};
+	const check = new Date(
+		Date.UTC(
+			parts.year,
+			parts.month - 1,
+			parts.day,
+			parts.hour,
+			parts.minute,
+			parts.second,
+			parts.millisecond,
+		),
+	);
+	if (
+		check.getUTCFullYear() !== parts.year ||
+		check.getUTCMonth() + 1 !== parts.month ||
+		check.getUTCDate() !== parts.day ||
+		check.getUTCHours() !== parts.hour ||
+		check.getUTCMinutes() !== parts.minute ||
+		check.getUTCSeconds() !== parts.second ||
+		check.getUTCMilliseconds() !== parts.millisecond
+	) {
+		return null;
+	}
+	return parts;
+}
+
+function zonedFormatter(timezone: string, value: unknown): Intl.DateTimeFormat {
+	try {
+		return new Intl.DateTimeFormat("en-US-u-ca-iso8601-nu-latn", {
+			timeZone: timezone,
+			year: "numeric",
+			month: "2-digit",
+			day: "2-digit",
+			hour: "2-digit",
+			minute: "2-digit",
+			second: "2-digit",
+			hourCycle: "h23",
+		});
+	} catch {
+		throw new DatetimeNormalizationError("invalid_timezone", value, timezone);
+	}
+}
+
+function zonedParts(
+	formatter: Intl.DateTimeFormat,
+	epochMs: number,
+): Omit<LocalDatetimeParts, "millisecond"> {
+	const values: Record<string, number> = {};
+	for (const part of formatter.formatToParts(new Date(epochMs))) {
+		if (part.type !== "literal") values[part.type] = Number(part.value);
+	}
+	return {
+		year: values.year ?? 0,
+		month: values.month ?? 0,
+		day: values.day ?? 0,
+		hour: values.hour ?? 0,
+		minute: values.minute ?? 0,
+		second: values.second ?? 0,
+	};
+}
+
+function timezoneOffsetMs(formatter: Intl.DateTimeFormat, epochMs: number): number {
+	const wholeSecond = Math.floor(epochMs / 1000) * 1000;
+	const parts = zonedParts(formatter, wholeSecond);
+	return (
+		Date.UTC(parts.year, parts.month - 1, parts.day, parts.hour, parts.minute, parts.second) -
+		wholeSecond
+	);
+}
+
+function sameLocalDatetime(
+	formatter: Intl.DateTimeFormat,
+	epochMs: number,
+	expected: LocalDatetimeParts,
+): boolean {
+	const actual = zonedParts(formatter, epochMs);
+	return (
+		actual.year === expected.year &&
+		actual.month === expected.month &&
+		actual.day === expected.day &&
+		actual.hour === expected.hour &&
+		actual.minute === expected.minute &&
+		actual.second === expected.second &&
+		new Date(epochMs).getUTCMilliseconds() === expected.millisecond
+	);
+}
+
+function resolveNaiveDatetime(value: string, timezone: string, parts: LocalDatetimeParts): string {
+	const formatter = zonedFormatter(timezone, value);
+	const localEpoch = Date.UTC(
+		parts.year,
+		parts.month - 1,
+		parts.day,
+		parts.hour,
+		parts.minute,
+		parts.second,
+		parts.millisecond,
+	);
+	const offsets = new Set<number>();
+	for (
+		let sample = localEpoch - OFFSET_SAMPLE_RANGE_MS;
+		sample <= localEpoch + OFFSET_SAMPLE_RANGE_MS;
+		sample += OFFSET_SAMPLE_STEP_MS
+	) {
+		offsets.add(timezoneOffsetMs(formatter, sample));
+	}
+
+	const candidates = new Set<number>();
+	for (const offset of offsets) {
+		const candidate = localEpoch - offset;
+		if (sameLocalDatetime(formatter, candidate, parts)) candidates.add(candidate);
+	}
+	if (candidates.size === 0) {
+		throw new DatetimeNormalizationError("nonexistent", value, timezone);
+	}
+	if (candidates.size > 1) {
+		throw new DatetimeNormalizationError("ambiguous", value, timezone);
+	}
+	const candidate = candidates.values().next().value;
+	if (candidate === undefined) {
+		throw new DatetimeNormalizationError("nonexistent", value, timezone);
+	}
+	return new Date(candidate).toISOString();
+}
+
+export function normalizeDatetime(value: unknown, timezone: string): NormalizedDatetime {
+	if (value instanceof Date) {
+		if (Number.isNaN(value.getTime())) {
+			throw new DatetimeNormalizationError("invalid", value, timezone);
+		}
+		return { value: value.toISOString(), kind: "offset" };
+	}
+	if (typeof value !== "string") {
+		throw new DatetimeNormalizationError("invalid", value, timezone);
+	}
+	if (value.startsWith('"') && value.endsWith('"')) {
+		try {
+			const unquoted: unknown = JSON.parse(value);
+			if (typeof unquoted === "string") {
+				const normalized = normalizeDatetime(unquoted, timezone);
+				return {
+					value: normalized.value,
+					kind: normalized.kind === "naive" ? "naive" : "offset",
+				};
+			}
+		} catch {
+			throw new DatetimeNormalizationError("invalid", value, timezone);
+		}
+	}
+
+	const naive = parseNaiveDatetime(value);
+	if (naive) {
+		return { value: resolveNaiveDatetime(value, timezone, naive), kind: "naive" };
+	}
+	if (!EXPLICIT_OFFSET_PATTERN.test(value)) {
+		throw new DatetimeNormalizationError("invalid", value, timezone);
+	}
+	if (!EXPLICIT_DATETIME_SCHEMA.safeParse(value).success) {
+		throw new DatetimeNormalizationError("invalid", value, timezone);
+	}
+	const parsed = new Date(value);
+	if (Number.isNaN(parsed.getTime())) {
+		throw new DatetimeNormalizationError("invalid", value, timezone);
+	}
+	const normalized = parsed.toISOString();
+	return { value: normalized, kind: value === normalized ? "canonical" : "offset" };
+}
+
+export function normalizeExplicitDatetime(value: unknown): string {
+	const normalized = normalizeDatetime(value, "UTC");
+	if (normalized.kind === "naive") {
+		throw new DatetimeNormalizationError("offset_required", value, "UTC");
+	}
+	return normalized.value;
+}
+
+export function normalizeContentDatetimes(
+	data: Record<string, unknown>,
+	fields: readonly DatetimeFieldDescriptor[],
+	timezone: string,
+): NormalizedContentDatetimes {
+	let value = data;
+	let changedCount = 0;
+	let naiveCount = 0;
+	const write = (slug: string, next: unknown) => {
+		if (value === data) value = { ...data };
+		value[slug] = next;
+	};
+
+	for (const field of fields) {
+		const current = data[field.slug];
+		if (current === null || current === undefined || current === "") continue;
+		if (field.type === "datetime") {
+			const normalized = normalizeDatetime(current, timezone);
+			if (normalized.kind === "naive") naiveCount++;
+			if (!Object.is(normalized.value, current)) {
+				changedCount++;
+				write(field.slug, normalized.value);
+			}
+			continue;
+		}
+
+		if (!Array.isArray(current) || !field.datetimeSubFields?.length) continue;
+		let rows = current;
+		for (const [index, row] of current.entries()) {
+			if (!isRecord(row)) continue;
+			let nextRow = row;
+			for (const subField of field.datetimeSubFields) {
+				const nested = nextRow[subField];
+				if (nested === null || nested === undefined || nested === "") continue;
+				const normalized = normalizeDatetime(nested, timezone);
+				if (normalized.kind === "naive") naiveCount++;
+				if (!Object.is(normalized.value, nested)) {
+					changedCount++;
+					if (nextRow === row) nextRow = { ...nextRow };
+					nextRow[subField] = normalized.value;
+				}
+			}
+			if (nextRow !== row) {
+				if (rows === current) rows = [...current];
+				rows[index] = nextRow;
+			}
+		}
+		if (rows !== current) write(field.slug, rows);
+	}
+
+	return { value, changedCount, naiveCount };
+}