@morphemecms/cms 0.5.0 → 0.7.0

package/src/eyebrowState.test.mjs

@@ -0,0 +1,78 @@
+// Tests for src/eyebrowState.mjs: where the labels are in the document, and the keys in a label. Run: node --test packages/editor/lib/*.test.mjs packages/editor/src/*.test.mjs
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { Schema } from '@milkdown/kit/prose/model';
+import { EditorState, TextSelection } from '@milkdown/kit/prose/state';
+import { enterInLabel, hasLabel, labelledHeading, looseLabels, toggleLabel } from './eyebrowState.mjs';
+
+const schema = new Schema({
+  nodes: {
+    doc: { content: 'block+' },
+    paragraph: { group: 'block', content: 'text*' },
+    heading: { group: 'block', content: 'text*', attrs: { level: { default: 2 } } },
+    eyebrow: { group: 'block', content: 'text*' },
+    text: {},
+  },
+});
+const node = (type, text, attrs) => schema.node(type, attrs, text ? [schema.text(text)] : []);
+// A label (0–7), its heading (7–14) and a paragraph (14–17).
+const labelled = () => schema.node('doc', null, [node('eyebrow', 'Label'), node('heading', 'Title'), node('paragraph', 'x')]);
+const stateAt = (doc, pos) => EditorState.create({ doc, selection: TextSelection.create(doc, pos) });
+
+test('a label before its heading is not loose', () => assert.deepEqual(looseLabels(labelled()), []));
+test('a label without a heading after it is loose', () => {
+  const doc = schema.node('doc', null, [node('eyebrow', 'Label'), node('paragraph', 'x'), node('eyebrow', 'End')]);
+  assert.deepEqual(looseLabels(doc), [0, 10]);
+});
+test('Enter in a label goes to the start of its heading', () => {
+  let next;
+  assert.equal(
+    enterInLabel(stateAt(labelled(), 3), (tr) => (next = tr)),
+    true,
+  );
+  assert.equal(next.selection.from, 8);
+  assert.equal(next.doc.childCount, 3);
+});
+test('Enter elsewhere is not the label’s', () =>
+  assert.equal(
+    enterInLabel(stateAt(labelled(), 9), () => {}),
+    false,
+  ));
+
+// A view as the menu uses it: its state, and dispatch.
+const viewOf = (state) => ({
+  state,
+  dispatch(tr) {
+    this.state = this.state.apply(tr);
+  },
+});
+const plain = () => schema.node('doc', null, [node('heading', 'Title', { level: 3 }), node('paragraph', 'x')]);
+
+test('the heading the cursor is in', () => assert.deepEqual(labelledHeading(stateAt(labelled(), 9)), { pos: 7, level: 2 }));
+test('the heading after the label the cursor is in', () => assert.deepEqual(labelledHeading(stateAt(labelled(), 3)), { pos: 7, level: 2 }));
+test('no heading in a paragraph', () => assert.equal(labelledHeading(stateAt(labelled(), 15)), null));
+test('whether it has a label', () => {
+  assert.equal(hasLabel(stateAt(labelled(), 9)), true);
+  assert.equal(hasLabel(stateAt(plain(), 2)), false);
+});
+test('adds an empty label with the cursor in it', () => {
+  const view = viewOf(stateAt(plain(), 2));
+  toggleLabel(view);
+  assert.equal(view.state.doc.child(0).type.name, 'eyebrow');
+  assert.equal(view.state.doc.child(0).content.size, 0);
+  assert.equal(view.state.doc.child(1).textContent, 'Title');
+  assert.equal(view.state.selection.from, 1);
+});
+test('takes the label away, from the heading or from the label', () => {
+  for (const pos of [9, 3]) {
+    const view = viewOf(stateAt(labelled(), pos));
+    toggleLabel(view);
+    assert.equal(view.state.doc.child(0).type.name, 'heading');
+    assert.equal(view.state.doc.childCount, 2);
+  }
+});
+test('does nothing in a paragraph', () => {
+  const view = viewOf(stateAt(labelled(), 15));
+  toggleLabel(view);
+  assert.equal(view.state.doc.childCount, 3);
+});

package/src/fileRecords.d.mts

@@ -0,0 +1,115 @@
+/**
+ * The record in a file's text, or null when the text is not a record.
+ * @param {string} text
+ * @returns {FileRecord | null}
+ */
+export function parseRecord(text: string): FileRecord | null;
+/**
+ * The records directly in a folder, sorted by path. Files that are not records are left out.
+ * @param {{ path: string; oid: string; text: string }[]} files
+ * @param {string} folder
+ * @returns {StoredRecord[]}
+ */
+export function recordsIn(files: {
+    path: string;
+    oid: string;
+    text: string;
+}[], folder: string): StoredRecord[];
+/**
+ * The problems in the record files directly in a folder. Paths are compared and returned with `/`.
+ * `shape`: not a record. `overlap`: a slug is both chosen and removed. `duplicate`: a later record has the same address.
+ * @param {{ path: string; text: string }[]} files
+ * @param {string} folder
+ * @returns {RecordProblem[]}
+ */
+export function recordProblems(files: {
+    path: string;
+    text: string;
+}[], folder: string): RecordProblem[];
+/**
+ * The record of a file address, or undefined.
+ * @param {StoredRecord[]} records
+ * @param {string} src
+ * @returns {StoredRecord | undefined}
+ */
+export function recordFor(records: StoredRecord[], src: string): StoredRecord | undefined;
+/**
+ * The path of a record file.
+ * @param {string} folder
+ * @param {string} id
+ * @returns {string}
+ */
+export function recordPath(folder: string, id: string): string;
+/**
+ * A new record id: 8 characters from a-z and 0-9, not in `taken`.
+ * @param {ReadonlySet<string>} taken
+ * @param {() => number} [random]
+ * @returns {string}
+ */
+export function newRecordId(taken: ReadonlySet<string>, random?: () => number): string;
+/**
+ * The text of a record file: keys in order, 2-space JSON, newline at the end.
+ * @param {FileRecord} record
+ * @returns {string}
+ */
+export function recordText(record: FileRecord): string;
+/**
+ * The changes that bring the records to the updated ones: delete when empty, update when the text differs,
+ * create under a new id when there was no record.
+ * @param {StoredRecord[]} records
+ * @param {string} folder
+ * @param {{ src: string; next: FileRecord }[]} updates
+ * @param {() => number} [random]
+ * @returns {RecordChange[]}
+ */
+export function writeRecords(records: StoredRecord[], folder: string, updates: {
+    src: string;
+    next: FileRecord;
+}[], random?: () => number): RecordChange[];
+/**
+ * The change that moves a record to a new file address (same file, same id), or null when there is no record.
+ * @param {StoredRecord[]} records
+ * @param {string} from
+ * @param {string} to
+ * @returns {RecordChange | null}
+ */
+export function renameRecord(records: StoredRecord[], from: string, to: string): RecordChange | null;
+/**
+ * The change that deletes the record of a file address, or null when there is no record.
+ * @param {StoredRecord[]} records
+ * @param {string} src
+ * @returns {RecordChange | null}
+ */
+export function deleteRecord(records: StoredRecord[], src: string): RecordChange | null;
+/**
+ * The deleted entry that holds the record of a deleted file: its text is a record for `src` and it was deleted at `at`.
+ * Null when a live record already has `src`, or when no entry matches.
+ * @template {{ path: string; text: string; at: Date | string }} D
+ * @param {string} src
+ * @param {Date | string} at
+ * @param {D[]} deleted
+ * @param {StoredRecord[]} live
+ * @returns {D | null}
+ */
+export function deletedRecordFor<D extends {
+    path: string;
+    text: string;
+    at: Date | string;
+}>(src: string, at: Date | string, deleted: D[], live: StoredRecord[]): D | null;
+export function isRecordPath(path: string, folder: string): boolean;
+export type FileRecord = import("./fileTags.mjs").FileRecord;
+export type StoredRecord = {
+    path: string;
+    oid: string;
+    record: FileRecord;
+};
+export type RecordChange = {
+    path: string;
+    content: string | null;
+    oid: string | null;
+};
+export type RecordProblem = {
+    path: string;
+    problem: "shape" | "overlap" | "duplicate";
+    value?: string;
+};

package/src/fileRecords.mjs

@@ -0,0 +1,224 @@
+// The file records (src/data/files/<id>.json): which tags a file in Filer has and which were removed from it, one record per file address.
+// Reads them from the editor's files, gives the changes (as env.commit takes them) a save, rename or delete makes, checks them, and finds the record of a deleted file. Pure, so node --test can run it.
+// Uses fileTags.mjs (isEmpty).
+import { isEmpty } from './fileTags.mjs';
+
+/**
+ * @typedef {import('./fileTags.mjs').FileRecord} FileRecord
+ * @typedef {{ path: string; oid: string; record: FileRecord }} StoredRecord
+ * @typedef {{ path: string; content: string | null; oid: string | null }} RecordChange
+ * @typedef {{ path: string; problem: 'shape' | 'overlap' | 'duplicate'; value?: string }} RecordProblem
+ */
+
+const ALPHABET = 'abcdefghijklmnopqrstuvwxyz0123456789';
+
+/** @param {unknown} list */
+const isStringArray = (list) => Array.isArray(list) && list.every((item) => typeof item === 'string');
+
+/**
+ * The record in a file's text, or null when the text is not a record.
+ * @param {string} text
+ * @returns {FileRecord | null}
+ */
+export function parseRecord(text) {
+  let data;
+  try {
+    data = JSON.parse(text);
+  } catch {
+    return null;
+  }
+  if (!data || typeof data !== 'object' || Array.isArray(data)) return null;
+  if (typeof data.src !== 'string' || !data.src.startsWith('/')) return null;
+  const categories = data.categories === undefined ? [] : data.categories;
+  const removed = data.removed === undefined ? [] : data.removed;
+  if (!isStringArray(categories) || !isStringArray(removed)) return null;
+  return { src: data.src, categories: [...categories], removed: [...removed] };
+}
+
+/**
+ * Whether a path is a .json file directly in the folder (no subfolders).
+ * @param {string} path
+ * @param {string} folder
+ * @returns {boolean}
+ */
+export const isRecordPath = (path, folder) => {
+  const prefix = `${folder}/`;
+  if (!path.startsWith(prefix)) return false;
+  const name = path.slice(prefix.length);
+  return !name.includes('/') && name.endsWith('.json');
+};
+
+/**
+ * Sorts by path.
+ * @template {{ path: string }} T
+ * @param {T[]} items
+ * @returns {T[]}
+ */
+const byPath = (items) => items.sort((a, b) => (a.path < b.path ? -1 : a.path > b.path ? 1 : 0));
+
+/**
+ * The records directly in a folder, sorted by path. Files that are not records are left out.
+ * @param {{ path: string; oid: string; text: string }[]} files
+ * @param {string} folder
+ * @returns {StoredRecord[]}
+ */
+export function recordsIn(files, folder) {
+  const out = [];
+  for (const file of files) {
+    if (!isRecordPath(file.path, folder)) continue;
+    const record = parseRecord(file.text);
+    if (record) out.push({ path: file.path, oid: file.oid, record });
+  }
+  return byPath(out);
+}
+
+/**
+ * The problems in the record files directly in a folder. Paths are compared and returned with `/`.
+ * `shape`: not a record. `overlap`: a slug is both chosen and removed. `duplicate`: a later record has the same address.
+ * @param {{ path: string; text: string }[]} files
+ * @param {string} folder
+ * @returns {RecordProblem[]}
+ */
+export function recordProblems(files, folder) {
+  /** @type {RecordProblem[]} */
+  const problems = [];
+  /** @type {{ path: string; record: FileRecord }[]} */
+  const valid = [];
+  for (const file of files) {
+    const path = file.path.replace(/\\/g, '/');
+    if (!isRecordPath(path, folder)) continue;
+    const record = parseRecord(file.text);
+    if (!record) {
+      problems.push({ path, problem: 'shape' });
+      continue;
+    }
+    const both = record.categories.find((tag) => record.removed.includes(tag));
+    if (both !== undefined) problems.push({ path, problem: 'overlap', value: both });
+    valid.push({ path, record });
+  }
+  /** @type {Set<string>} */
+  const seen = new Set();
+  for (const { path, record } of byPath(valid)) {
+    if (seen.has(record.src)) problems.push({ path, problem: 'duplicate', value: record.src });
+    seen.add(record.src);
+  }
+  return problems;
+}
+
+/**
+ * The record of a file address, or undefined.
+ * @param {StoredRecord[]} records
+ * @param {string} src
+ * @returns {StoredRecord | undefined}
+ */
+export function recordFor(records, src) {
+  return records.find((stored) => stored.record.src === src);
+}
+
+/**
+ * The path of a record file.
+ * @param {string} folder
+ * @param {string} id
+ * @returns {string}
+ */
+export function recordPath(folder, id) {
+  return `${folder}/${id}.json`;
+}
+
+/**
+ * A new record id: 8 characters from a-z and 0-9, not in `taken`.
+ * @param {ReadonlySet<string>} taken
+ * @param {() => number} [random]
+ * @returns {string}
+ */
+export function newRecordId(taken, random = Math.random) {
+  for (;;) {
+    let id = '';
+    for (let i = 0; i < 8; i++) id += ALPHABET[Math.floor(random() * ALPHABET.length)];
+    if (!taken.has(id)) return id;
+  }
+}
+
+/**
+ * The text of a record file: keys in order, 2-space JSON, newline at the end.
+ * @param {FileRecord} record
+ * @returns {string}
+ */
+export function recordText(record) {
+  return `${JSON.stringify({ src: record.src, categories: record.categories, removed: record.removed }, null, 2)}\n`;
+}
+
+/** @param {string} path */
+const idOf = (path) => path.slice(path.lastIndexOf('/') + 1).replace(/\.json$/, '');
+
+/**
+ * The changes that bring the records to the updated ones: delete when empty, update when the text differs,
+ * create under a new id when there was no record.
+ * @param {StoredRecord[]} records
+ * @param {string} folder
+ * @param {{ src: string; next: FileRecord }[]} updates
+ * @param {() => number} [random]
+ * @returns {RecordChange[]}
+ */
+export function writeRecords(records, folder, updates, random = Math.random) {
+  const taken = new Set(records.map((stored) => idOf(stored.path)));
+  /** @type {RecordChange[]} */
+  const changes = [];
+  for (const { src, next } of updates) {
+    const existing = recordFor(records, src);
+    if (existing) {
+      if (isEmpty(next)) {
+        changes.push({ path: existing.path, content: null, oid: existing.oid });
+        continue;
+      }
+      const content = recordText(next);
+      if (content !== recordText(existing.record)) changes.push({ path: existing.path, content, oid: existing.oid });
+    } else if (!isEmpty(next)) {
+      const id = newRecordId(taken, random);
+      taken.add(id);
+      changes.push({ path: recordPath(folder, id), content: recordText(next), oid: null });
+    }
+  }
+  return changes;
+}
+
+/**
+ * The change that moves a record to a new file address (same file, same id), or null when there is no record.
+ * @param {StoredRecord[]} records
+ * @param {string} from
+ * @param {string} to
+ * @returns {RecordChange | null}
+ */
+export function renameRecord(records, from, to) {
+  const existing = recordFor(records, from);
+  if (!existing) return null;
+  return { path: existing.path, content: recordText({ ...existing.record, src: to }), oid: existing.oid };
+}
+
+/**
+ * The change that deletes the record of a file address, or null when there is no record.
+ * @param {StoredRecord[]} records
+ * @param {string} src
+ * @returns {RecordChange | null}
+ */
+export function deleteRecord(records, src) {
+  const existing = recordFor(records, src);
+  if (!existing) return null;
+  return { path: existing.path, content: null, oid: existing.oid };
+}
+
+/**
+ * The deleted entry that holds the record of a deleted file: its text is a record for `src` and it was deleted at `at`.
+ * Null when a live record already has `src`, or when no entry matches.
+ * @template {{ path: string; text: string; at: Date | string }} D
+ * @param {string} src
+ * @param {Date | string} at
+ * @param {D[]} deleted
+ * @param {StoredRecord[]} live
+ * @returns {D | null}
+ */
+export function deletedRecordFor(src, at, deleted, live) {
+  if (recordFor(live, src)) return null;
+  const instant = +new Date(at);
+  return deleted.find((entry) => +new Date(entry.at) === instant && parseRecord(entry.text)?.src === src) ?? null;
+}

package/src/fileRecords.test.mjs

@@ -0,0 +1,224 @@
+// Tests for src/fileRecords.mjs. Run: node --test packages/editor/src/fileRecords.test.mjs
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import {
+  deletedRecordFor,
+  deleteRecord,
+  newRecordId,
+  parseRecord,
+  recordFor,
+  recordProblems,
+  recordsIn,
+  recordText,
+  renameRecord,
+  writeRecords,
+} from './fileRecords.mjs';
+
+const F = 'src/data/files';
+const S = '/images/uploads/2026/10/andromeda.webp';
+const G = '/images/uploads/2026/10/galaxy.webp';
+
+/** A stored record as read from the repo. @param {string} path @param {{ src: string; categories: string[]; removed: string[] }} record */
+const stored = (path, record) => ({ path, oid: 'o1', record });
+
+/** A random source that gives 0 eight times, then 0.99 eight times. */
+const zeroThenNines = () => {
+  let n = 0;
+  return () => (n++ < 8 ? 0 : 0.99);
+};
+
+test('parseRecord reads a record with its lists', () => {
+  assert.deepEqual(parseRecord('{"src":"/a.webp","categories":["seo"],"removed":[]}'), {
+    src: '/a.webp',
+    categories: ['seo'],
+    removed: [],
+  });
+});
+
+test('parseRecord reads missing lists as empty', () => {
+  assert.deepEqual(parseRecord('{"src":"/a.webp"}'), { src: '/a.webp', categories: [], removed: [] });
+});
+
+test('parseRecord rejects a src that does not start with a slash', () => {
+  assert.equal(parseRecord('{"src":"a.webp"}'), null);
+});
+
+test('parseRecord rejects a list that is not an array of strings', () => {
+  assert.equal(parseRecord('{"src":"/a","categories":"seo"}'), null);
+});
+
+test('parseRecord rejects text that is not JSON', () => {
+  assert.equal(parseRecord('['), null);
+});
+
+test('recordsIn keeps only the record files directly in the folder', () => {
+  const valid = '{"src":"/a.webp","categories":[],"removed":[]}';
+  const files = [
+    { path: `${F}/ab12cd34.json`, oid: 'o1', text: valid },
+    { path: `${F}/sub/x.json`, oid: 'o2', text: valid },
+    { path: `${F}/bad.json`, oid: 'o3', text: '{' },
+    { path: 'src/data/categories/seo.json', oid: 'o4', text: valid },
+  ];
+  const records = recordsIn(files, F);
+  assert.deepEqual(
+    records.map((r) => r.path),
+    [`${F}/ab12cd34.json`],
+  );
+  assert.equal(records[0].oid, 'o1');
+});
+
+test('recordFor finds the record of a file address', () => {
+  const records = [stored(`${F}/aaaaaaaa.json`, { src: S, categories: ['seo'], removed: [] })];
+  assert.equal(recordFor(records, S), records[0]);
+  assert.equal(recordFor(records, '/other.webp'), undefined);
+});
+
+test('newRecordId gives 8 characters from the first try when none is taken', () => {
+  assert.equal(
+    newRecordId(new Set(), () => 0),
+    'aaaaaaaa',
+  );
+});
+
+test('newRecordId draws again when the id is taken', () => {
+  assert.equal(newRecordId(new Set(['aaaaaaaa']), zeroThenNines()), '99999999');
+});
+
+test('newRecordId with Math.random gives 8 lower case letters or digits', () => {
+  assert.match(newRecordId(new Set()), /^[a-z0-9]{8}$/);
+});
+
+test('recordText writes the keys in order, 2-space JSON, with a newline at the end', () => {
+  assert.equal(
+    recordText({ src: '/a.webp', categories: ['seo'], removed: [] }),
+    '{\n  "src": "/a.webp",\n  "categories": [\n    "seo"\n  ],\n  "removed": []\n}\n',
+  );
+});
+
+test('writeRecords creates a record for a new file address under a new id', () => {
+  const next = { src: S, categories: ['seo'], removed: [] };
+  assert.deepEqual(
+    writeRecords([], F, [{ src: S, next }], () => 0),
+    [{ path: `${F}/aaaaaaaa.json`, content: recordText(next), oid: null }],
+  );
+});
+
+test('writeRecords updates a record whose lists changed', () => {
+  const records = [stored(`${F}/aaaaaaaa.json`, { src: S, categories: ['seo'], removed: [] })];
+  const next = { src: S, categories: [], removed: ['seo'] };
+  assert.deepEqual(writeRecords(records, F, [{ src: S, next }]), [{ path: `${F}/aaaaaaaa.json`, content: recordText(next), oid: 'o1' }]);
+});
+
+test('writeRecords changes nothing when the record is the same', () => {
+  const records = [stored(`${F}/aaaaaaaa.json`, { src: S, categories: ['seo'], removed: [] })];
+  const next = { src: S, categories: ['seo'], removed: [] };
+  assert.deepEqual(writeRecords(records, F, [{ src: S, next }]), []);
+});
+
+test('writeRecords deletes a record whose lists are now empty', () => {
+  const records = [stored(`${F}/aaaaaaaa.json`, { src: S, categories: ['seo'], removed: [] })];
+  const next = { src: S, categories: [], removed: [] };
+  assert.deepEqual(writeRecords(records, F, [{ src: S, next }]), [{ path: `${F}/aaaaaaaa.json`, content: null, oid: 'o1' }]);
+});
+
+test('writeRecords changes nothing when there is no record and the lists are empty', () => {
+  const next = { src: S, categories: [], removed: [] };
+  assert.deepEqual(writeRecords([], F, [{ src: S, next }]), []);
+});
+
+test('writeRecords gives two new file addresses two different ids', () => {
+  const a = { src: S, categories: ['seo'], removed: [] };
+  const b = { src: G, categories: ['seo'], removed: [] };
+  // A constant 0 would give the same id again and loop forever, so the second id draws 0.99 values.
+  const changes = writeRecords(
+    [],
+    F,
+    [
+      { src: S, next: a },
+      { src: G, next: b },
+    ],
+    zeroThenNines(),
+  );
+  assert.deepEqual(
+    changes.map((c) => c.path),
+    [`${F}/aaaaaaaa.json`, `${F}/99999999.json`],
+  );
+});
+
+test('renameRecord keeps the id and the lists and sets the new address', () => {
+  const records = [stored(`${F}/aaaaaaaa.json`, { src: S, categories: ['seo'], removed: ['x'] })];
+  assert.deepEqual(renameRecord(records, S, G), {
+    path: `${F}/aaaaaaaa.json`,
+    content: recordText({ src: G, categories: ['seo'], removed: ['x'] }),
+    oid: 'o1',
+  });
+});
+
+test('renameRecord gives null when there is no record', () => {
+  const records = [stored(`${F}/aaaaaaaa.json`, { src: S, categories: ['seo'], removed: [] })];
+  assert.equal(renameRecord(records, '/x.webp', '/y.webp'), null);
+});
+
+test('deleteRecord deletes the record of the address', () => {
+  const records = [stored(`${F}/aaaaaaaa.json`, { src: S, categories: ['seo'], removed: [] })];
+  assert.deepEqual(deleteRecord(records, S), { path: `${F}/aaaaaaaa.json`, content: null, oid: 'o1' });
+});
+
+test('deleteRecord gives null when there is no record', () => {
+  assert.equal(deleteRecord([], S), null);
+});
+
+const P = `${F}/aaa.json`;
+const valid = (src) => JSON.stringify({ src, categories: [], removed: [] });
+
+test('recordProblems gives nothing for a valid record', () => {
+  assert.deepEqual(recordProblems([{ path: P, text: valid(S) }], F), []);
+});
+
+test('recordProblems reports a record without a slash-led src as shape', () => {
+  assert.deepEqual(recordProblems([{ path: P, text: '{"src":"a.webp"}' }], F), [{ path: P, problem: 'shape' }]);
+});
+
+test('recordProblems reports a slug that is both chosen and removed as overlap', () => {
+  const text = '{"src":"/a.webp","categories":["seo"],"removed":["seo"]}';
+  assert.deepEqual(recordProblems([{ path: P, text }], F), [{ path: P, problem: 'overlap', value: 'seo' }]);
+});
+
+test('recordProblems reports the later of two records for one address as duplicate', () => {
+  const files = [
+    { path: `${F}/aaa.json`, text: valid('/a.webp') },
+    { path: `${F}/bbb.json`, text: valid('/a.webp') },
+  ];
+  assert.deepEqual(recordProblems(files, F), [{ path: `${F}/bbb.json`, problem: 'duplicate', value: '/a.webp' }]);
+});
+
+test('recordProblems reads backslash paths and returns them with slashes', () => {
+  const files = [{ path: 'src\\data\\files\\aaa.json', text: '{"src":"a"}' }];
+  assert.deepEqual(recordProblems(files, F), [{ path: 'src/data/files/aaa.json', problem: 'shape' }]);
+});
+
+test('recordProblems ignores files outside the folder', () => {
+  assert.deepEqual(recordProblems([{ path: 'src/data/categories/seo.json', text: '{"src":"a"}' }], F), []);
+});
+
+test('deletedRecordFor finds the deleted entry of a file at the time it was deleted', () => {
+  const at = new Date('2026-11-03T10:00:00Z');
+  const deleted = [{ path: `${F}/x.json`, text: valid(S), at }];
+  assert.equal(deletedRecordFor(S, '2026-11-03T10:00:00Z', deleted, []), deleted[0]);
+});
+
+test('deletedRecordFor gives null when the deletion time differs by one second', () => {
+  const deleted = [{ path: `${F}/x.json`, text: valid(S), at: new Date('2026-11-03T10:00:00Z') }];
+  assert.equal(deletedRecordFor(S, '2026-11-03T10:00:01Z', deleted, []), null);
+});
+
+test('deletedRecordFor gives null when a live record already has the address', () => {
+  const deleted = [{ path: `${F}/x.json`, text: valid(S), at: new Date('2026-11-03T10:00:00Z') }];
+  const live = [stored(`${F}/aaaaaaaa.json`, { src: S, categories: [], removed: [] })];
+  assert.equal(deletedRecordFor(S, '2026-11-03T10:00:00Z', deleted, live), null);
+});
+
+test('deletedRecordFor gives null for an entry of another address', () => {
+  const deleted = [{ path: `${F}/x.json`, text: valid(G), at: new Date('2026-11-03T10:00:00Z') }];
+  assert.equal(deletedRecordFor(S, '2026-11-03T10:00:00Z', deleted, []), null);
+});

package/src/fileTagFilter.d.mts

@@ -0,0 +1,30 @@
+/**
+ * @typedef {import('./fileRecords.mjs').StoredRecord} StoredRecord
+ */
+/**
+ * The tags of each file, keyed by file address (src). Records with no tags are left out.
+ * @param {StoredRecord[]} records
+ * @returns {Map<string, string[]>}
+ */
+export function tagIndex(records: StoredRecord[]): Map<string, string[]>;
+/**
+ * The filter's choices: the tags (in their order) that some file in the index has, plus the chosen tag when it is among the tags.
+ * @template {{ value: string; label: string }} O
+ * @param {Map<string, string[]>} index
+ * @param {O[]} tags
+ * @param {string} chosen
+ * @returns {O[]}
+ */
+export function tagFilterOptions<O extends {
+    value: string;
+    label: string;
+}>(index: Map<string, string[]>, tags: O[], chosen: string): O[];
+/**
+ * The files that have a tag, in their order. With an empty tag, all files are kept.
+ * @param {string[]} srcs
+ * @param {Map<string, string[]>} index
+ * @param {string} tag
+ * @returns {string[]}
+ */
+export function withTag(srcs: string[], index: Map<string, string[]>, tag: string): string[];
+export type StoredRecord = import("./fileRecords.mjs").StoredRecord;