@jrpool/kilotest 46.1.2 → 47.0.1

package/web/tutorialAI/tutorialAI.test.ts

@@ -0,0 +1,192 @@
+/*
+  tutorialAI.test.ts
+  Unit tests for web/tutorialAI/index.ts, covering the answer and handleComment exports.
+*/
+
+// IMPORTS
+
+import {test, before, after} from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+// ENVIRONMENT
+
+const testDir = path.join(import.meta.dirname, '../../test/fixtures/comments');
+process.env.TUTORIAL_AI_COMMENTS_PATH = path.join(testDir, 'tutorialAI.json');
+
+import {answer, handleComment} from './index.ts';
+
+// CONSTANTS
+
+const getCommentsPath = () => process.env.TUTORIAL_AI_COMMENTS_PATH || path.join(import.meta.dirname, '../../db/comments/tutorialAI.json');
+
+// SETUP AND TEARDOWN
+
+before(async () => {
+  await fs.mkdir(testDir, {recursive: true});
+  await fs.writeFile(getCommentsPath(), '[]\n');
+});
+
+after(async () => {
+  // Cleanup is handled by index.test.ts since multiple test files use this shared directory.
+});
+
+// TESTS
+
+test('answer returns the AI tutorial page with status ok', async () => {
+  const result = await answer();
+  assert.equal(result.status, 'ok');
+  assert.ok(result.answerPage);
+  assert.ok(result.answerPage.length > 0);
+});
+
+test('handleComment returns an error for empty content', async () => {
+  const result = await handleComment('');
+  assert.equal(result.status, 'error');
+  assert.equal(result.message, 'No content provided');
+});
+
+test('handleComment returns an error for non-string content', async () => {
+  const result = await handleComment(null);
+  assert.equal(result.status, 'error');
+  assert.equal(result.message, 'No content provided');
+});
+
+test('handleComment returns an error for content that is empty after sanitization', async () => {
+  const result = await handleComment(`${' '.repeat(10)}<script></script>${' '.repeat(10)}`);
+  assert.equal(result.status, 'error');
+  assert.equal(result.message, 'Comment is empty after sanitization');
+});
+
+test('handleComment returns an error for a comment shorter than 20 characters', async () => {
+  const result = await handleComment('short');
+  assert.equal(result.status, 'error');
+  assert.equal(result.message, 'Your comment was shorter than 20 characters');
+});
+
+test('handleComment returns an error for a comment longer than 1000 characters', async () => {
+  const result = await handleComment('x'.repeat(1001));
+  assert.equal(result.status, 'error');
+  assert.equal(result.message, 'Your comment was longer than 1000 characters');
+});
+
+test('handleComment returns an error for a comment repeating one submitted within the last 1000 seconds', {timeout: 500}, async () => {
+  await fs.writeFile(getCommentsPath(), '[]\n');
+  const content = 'This is a duplicate comment.';
+  const firstResult = await handleComment(content);
+  assert.equal(firstResult.status, 'ok');
+  const secondResult = await handleComment(content);
+  assert.equal(secondResult.status, 'error');
+  assert.equal(
+    secondResult.message,
+    'Your comment repeats a recently submitted one, but you are welcome to submit a different comment'
+  );
+});
+
+test('handleComment saves a sanitized comment and returns ok', {timeout: 500}, async () => {
+  await fs.writeFile(getCommentsPath(), '[]\n');
+  const result = await handleComment('This is a <b>test</b> comment.');
+  assert.equal(result.status, 'ok');
+  const comments = JSON.parse(await fs.readFile(getCommentsPath(), 'utf8'));
+  assert.equal(comments.length, 1);
+  assert.equal(comments[0].content, 'This is a test comment.');
+  assert.ok(comments[0].dateTime);
+});
+
+test('handleComment strips HTML tags and control characters', {timeout: 500}, async () => {
+  await fs.writeFile(getCommentsPath(), '[]\n');
+  const result = await handleComment('<img src=x onerror=alert(1)>\x00\x07Hello');
+  assert.equal(result.status, 'ok');
+  const comments = JSON.parse(await fs.readFile(getCommentsPath(), 'utf8'));
+  assert.equal(comments[0].content, 'Hello');
+});
+
+test('handleComment accepts a comment of exactly 1000 characters', {timeout: 500}, async () => {
+  await fs.writeFile(getCommentsPath(), '[]\n');
+  const maxComment = 'x'.repeat(1000);
+  const result = await handleComment(maxComment);
+  assert.equal(result.status, 'ok');
+  const comments = JSON.parse(await fs.readFile(getCommentsPath(), 'utf8'));
+  assert.equal(comments[0].content.length, 1000);
+});
+
+test('handleComment creates comments.json when it does not exist', {timeout: 500}, async () => {
+  await fs.unlink(getCommentsPath()).catch(() => {});
+  const result = await handleComment('Test comment for missing file');
+  assert.equal(result.status, 'ok');
+  const comments = JSON.parse(await fs.readFile(getCommentsPath(), 'utf8'));
+  assert.equal(comments.length, 1);
+  assert.equal(comments[0].content, 'Test comment for missing file');
+});
+
+test('handleComment creates the comments directory when it does not exist', {timeout: 500}, async () => {
+  const savedEnv = process.env.TUTORIAL_AI_COMMENTS_PATH;
+  const missingDirPath = path.join(testDir, 'new-subdir', 'tutorialAI.json');
+  process.env.TUTORIAL_AI_COMMENTS_PATH = missingDirPath;
+  try {
+    const result = await handleComment('Test comment for missing directory');
+    assert.equal(result.status, 'ok');
+    const comments = JSON.parse(await fs.readFile(missingDirPath, 'utf8'));
+    assert.equal(comments[0].content, 'Test comment for missing directory');
+  } finally {
+    process.env.TUTORIAL_AI_COMMENTS_PATH = savedEnv;
+    await fs.rm(path.dirname(missingDirPath), {recursive: true, force: true});
+  }
+});
+
+test('getCommentsPath uses environment variable when set', {timeout: 500}, async () => {
+  const envValue = process.env.TUTORIAL_AI_COMMENTS_PATH;
+  assert.ok(envValue);
+  assert.ok(getCommentsPath().includes('test/fixtures/comments'));
+});
+
+test('getCommentsPath falls back to default path when environment variable is not set', {timeout: 500}, async () => {
+  const savedEnv = process.env.TUTORIAL_AI_COMMENTS_PATH;
+  delete process.env.TUTORIAL_AI_COMMENTS_PATH;
+  try {
+    const path = getCommentsPath();
+    assert.ok(path.includes('db/comments'));
+    assert.ok(path.includes('tutorialAI.json'));
+  } finally {
+    process.env.TUTORIAL_AI_COMMENTS_PATH = savedEnv;
+  }
+});
+
+test('handleComment uses fallback path when environment variable is not set', {timeout: 500}, async () => {
+  const savedEnv = process.env.TUTORIAL_AI_COMMENTS_PATH;
+  const defaultPath = path.join(import.meta.dirname, '../../db/comments/tutorialAI.json');
+  const backupPath = defaultPath + '.backup';
+
+  // Backup the default comments file if it exists.
+  let hadDefault = false;
+  try {
+    const content = await fs.readFile(defaultPath, 'utf8');
+    await fs.writeFile(backupPath, content);
+    hadDefault = true;
+  } catch {
+    // File doesn't exist, that's fine.
+  }
+
+  delete process.env.TUTORIAL_AI_COMMENTS_PATH;
+  try {
+    // Write a test file to the default location.
+    await fs.mkdir(path.dirname(defaultPath), {recursive: true});
+    await fs.writeFile(defaultPath, '[]\n');
+    const result = await handleComment('Test with fallback path');
+    assert.equal(result.status, 'ok');
+    const comments = JSON.parse(await fs.readFile(defaultPath, 'utf8'));
+    assert.equal(comments.length, 1);
+    assert.equal(comments[0].content, 'Test with fallback path');
+  } finally {
+    // Restore the original state.
+    if (hadDefault) {
+      const backup = await fs.readFile(backupPath, 'utf8');
+      await fs.writeFile(defaultPath, backup);
+      await fs.unlink(backupPath);
+    } else {
+      await fs.unlink(defaultPath).catch(() => {});
+    }
+    process.env.TUTORIAL_AI_COMMENTS_PATH = savedEnv;
+  }
+});

package/web/{tutorial → tutorialWeb}/index.html

@@ -314,7 +314,7 @@
           <p>We shall look for this single issue on a single web page. It is the home page of a JavaScript-rendered WordPress site belonging to a nonprofit organization. It was tested in May 2026.</p>
           <p>The page contains a form for requesting a guide published by the organization. This form is not present in the raw HTML that the server delivers, but is injected into the page by a JavaScript plugin after the browser has loaded and executed the page scripts. The form contains one visible user-facing input field. Here is a screenshot of the form:</p>
           <img
-            src="/tutorial/images/newsletter-form.png"
+            src="/tutorialWeb/images/newsletter-form.png"
             alt="Career-guide request form containing an input with placeholder text Enter your email and a button labelled Get the career guide"
             width="602"
             height="57"
@@ -444,17 +444,18 @@
         <h2>Suggest improvements</h2>
         <p>Please submit suggestions for improving this tutorial below. The Kilotest managers will review them.</p>
         <form id="comment-form" novalidate>
-          <p id="comment-label">Your suggestions (up to 500 characters):</p>
+          <p id="comment-label">Your suggestions (20–1000 characters):</p>
           <textarea
             id="comment-text"
             name="content"
-            maxlength="500"
+            maxlength="1000"
+            minlength="20"
             rows="5"
             autocomplete="off"
             aria-labelledby="comment-label"
             aria-describedby="char-count-msg"
           ></textarea>
-          <p class="char-count" id="char-count-msg"><span id="char-remaining">500</span> characters remaining</p>
+          <p class="char-count" id="char-count-msg"><span id="char-remaining">1000</span> characters remaining</p>
           <button type="submit" id="comment-submit">Submit suggestions</button>
         </form>
         <div role="status" id="comment-diagnosis" aria-live="polite" aria-atomic="true" class="comment-diagnosis"></div>
@@ -593,9 +594,9 @@
       const commentSubmit = document.getElementById('comment-submit');
 
       commentText.addEventListener('input', function () {
-        const remaining = 500 - this.value.length;
+        const remaining = 1000 - this.value.length;
         charRemaining.textContent = remaining;
-        charCountMsg.className = remaining <= 50 ? 'char-count low' : 'char-count';
+        charCountMsg.className = remaining <= 100 ? 'char-count low' : 'char-count';
       });
 
       document.getElementById('comment-form').addEventListener('submit', async function (e) {
@@ -610,7 +611,7 @@
         }
         commentSubmit.disabled = true;
         try {
-          const response = await fetch('/tutorialComment.html', {
+          const response = await fetch('/tutorialWebComment.html', {
             method: 'POST',
             headers: {'Content-Type': 'application/json'},
             body: JSON.stringify({content})
@@ -621,7 +622,7 @@
             commentFeedback.textContent =
               'Thank you! Your suggestion has been saved and will be reviewed by the tutorial authors.';
             this.reset();
-            charRemaining.textContent = '500';
+            charRemaining.textContent = '1000';
             charCountMsg.className = 'char-count';
           } else {
             commentFeedback.className = 'comment-diagnosis error';

package/web/tutorialWeb/index.ts

@@ -0,0 +1,78 @@
+/*
+  index.ts
+  Serves the web tutorial and saves web tutorial comments.
+*/
+
+// IMPORTS
+
+import {sendAlert} from '../../alerts.ts';
+import {checkCommentDuplicate, checkCommentLength, getJSON, getNowStamp} from '../../util.ts';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+// FUNCTIONS (helpers)
+
+const getCommentsPath = () => process.env.TUTORIAL_WEB_COMMENTS_PATH || path.join(import.meta.dirname, '../../db/comments/tutorialWeb.json');
+
+// FUNCTIONS
+
+// Strips HTML tags and control characters, trims, and limits to 1000 characters.
+const sanitize = (str: string) => str
+  .replace(/<[^>]*>/g, '')
+  .replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g, '')
+  .trim()
+  .slice(0, 1000);
+
+// Returns the tutorial page.
+export const answer = async () => {
+  const answerPage = await fs.readFile(path.join(import.meta.dirname, 'index.html'), 'utf8');
+  return {
+    status: 'ok',
+    answerPage
+  };
+};
+// Sanitizes and saves a tutorial comment to comments.json.
+export const handleComment = async (content: unknown) => {
+  if (!content || typeof content !== 'string') {
+    return {status: 'error', message: 'No content provided'};
+  }
+  // If the raw comment's length is invalid:
+  const lengthCheck = checkCommentLength(content);
+  if (lengthCheck.status === 'error') {
+    // Report this.
+    return lengthCheck;
+  }
+  const commentsPath = getCommentsPath();
+  let comments: any[] = [];
+  try {
+    // Get the existing comments.
+    const existing = await fs.readFile(commentsPath, 'utf8');
+    comments = JSON.parse(existing);
+  }
+  // If there are none:
+  catch {
+    // Initialize a comments array.
+  }
+  const sanitized = sanitize(content);
+  if (!sanitized) {
+    return {status: 'error', message: 'Comment is empty after sanitization'};
+  }
+  // If the sanitized comment duplicates one recently stored:
+  const duplicateCheck = checkCommentDuplicate(comments, sanitized);
+  if (duplicateCheck.status === 'error') {
+    // Report this.
+    return duplicateCheck;
+  }
+  // Add the comment to the existing ones.
+  comments.push({
+    timeStamp: getNowStamp(),
+    content: sanitized
+  });
+  // Ensure the comments directory exists.
+  await fs.mkdir(path.dirname(commentsPath), {recursive: true});
+  // Save the revised comments.
+  await fs.writeFile(commentsPath, getJSON(comments));
+  // Send an alert to the manager.
+  await sendAlert('New web tutorial comment received', 'A new web tutorial comment has been received.');
+  return {status: 'ok'};
+};

package/web/tutorialWeb/tutorialWeb.test.ts

@@ -0,0 +1,195 @@
+/*
+  tutorial.test.ts
+  Unit tests for web/tutorial/index.ts, covering the answer and handleComment exports.
+*/
+
+// IMPORTS
+
+import {test, before, after} from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+// ENVIRONMENT
+
+const testDir = path.join(import.meta.dirname, '../../test/fixtures/comments');
+process.env.TUTORIAL_WEB_COMMENTS_PATH = path.join(testDir, 'tutorialWeb.json');
+
+import {answer, handleComment} from './index.ts';
+
+// CONSTANTS
+
+const getCommentsPath = () => process.env.TUTORIAL_WEB_COMMENTS_PATH || path.join(import.meta.dirname, '../../db/comments/tutorialWeb.json');
+
+// SETUP AND TEARDOWN
+
+before(async () => {
+  await fs.mkdir(testDir, {recursive: true});
+  await fs.writeFile(getCommentsPath(), '[]\n');
+});
+
+after(async () => {
+  // Cleanup is handled by index.test.ts since multiple test files use this shared directory.
+});
+
+// TESTS
+
+test('answer returns the tutorial page with status ok', async () => {
+  const result = await answer();
+  assert.equal(result.status, 'ok');
+  assert.ok(result.answerPage);
+  assert.ok(result.answerPage.length > 0);
+});
+
+test('handleComment returns an error for empty content', async () => {
+  const result = await handleComment('');
+  assert.equal(result.status, 'error');
+  assert.equal(result.message, 'No content provided');
+});
+
+test('handleComment returns an error for non-string content', async () => {
+  const result = await handleComment(null);
+  assert.equal(result.status, 'error');
+  assert.equal(result.message, 'No content provided');
+});
+
+test('handleComment returns an error for content that is empty after sanitization', async () => {
+  // Padded with spaces (stripped by sanitize's trim) to clear the 20-character length check
+  // on the raw content, isolating the empty-after-sanitization path from the length check.
+  const result = await handleComment(`${' '.repeat(10)}<script></script>${' '.repeat(10)}`);
+  assert.equal(result.status, 'error');
+  assert.equal(result.message, 'Comment is empty after sanitization');
+});
+
+test('handleComment returns an error for a comment shorter than 20 characters', async () => {
+  const result = await handleComment('short');
+  assert.equal(result.status, 'error');
+  assert.equal(result.message, 'Your comment was shorter than 20 characters');
+});
+
+test('handleComment returns an error for a comment longer than 1000 characters', async () => {
+  const result = await handleComment('x'.repeat(1001));
+  assert.equal(result.status, 'error');
+  assert.equal(result.message, 'Your comment was longer than 1000 characters');
+});
+
+test('handleComment returns an error for a comment repeating one submitted within the last 1000 seconds', {timeout: 500}, async () => {
+  await fs.writeFile(getCommentsPath(), '[]\n');
+  const content = 'This is a duplicate comment.';
+  const firstResult = await handleComment(content);
+  assert.equal(firstResult.status, 'ok');
+  const secondResult = await handleComment(content);
+  assert.equal(secondResult.status, 'error');
+  assert.equal(
+    secondResult.message,
+    'Your comment repeats a recently submitted one, but you are welcome to submit a different comment'
+  );
+});
+
+test('handleComment saves a sanitized comment and returns ok', {timeout: 500}, async () => {
+  // Replace comments with an empty array for a clean test.
+  await fs.writeFile(getCommentsPath(), '[]\n');
+  const result = await handleComment('This is a <b>test</b> comment.');
+  assert.equal(result.status, 'ok');
+  const comments = JSON.parse(await fs.readFile(getCommentsPath(), 'utf8'));
+  assert.equal(comments.length, 1);
+  assert.equal(comments[0].content, 'This is a test comment.');
+  assert.ok(comments[0].timeStamp);
+});
+
+test('handleComment strips HTML tags and control characters', {timeout: 500}, async () => {
+  await fs.writeFile(getCommentsPath(), '[]\n');
+  const result = await handleComment('<img src=x onerror=alert(1)>\x00\x07Hello');
+  assert.equal(result.status, 'ok');
+  const comments = JSON.parse(await fs.readFile(getCommentsPath(), 'utf8'));
+  assert.equal(comments[0].content, 'Hello');
+});
+
+test('handleComment accepts a comment of exactly 1000 characters', {timeout: 500}, async () => {
+  await fs.writeFile(getCommentsPath(), '[]\n');
+  const maxComment = 'x'.repeat(1000);
+  const result = await handleComment(maxComment);
+  assert.equal(result.status, 'ok');
+  const comments = JSON.parse(await fs.readFile(getCommentsPath(), 'utf8'));
+  assert.equal(comments[0].content.length, 1000);
+});
+
+test('handleComment creates comments.json when it does not exist', {timeout: 500}, async () => {
+  await fs.unlink(getCommentsPath()).catch(() => {});
+  const result = await handleComment('Test comment for missing file');
+  assert.equal(result.status, 'ok');
+  const comments = JSON.parse(await fs.readFile(getCommentsPath(), 'utf8'));
+  assert.equal(comments.length, 1);
+  assert.equal(comments[0].content, 'Test comment for missing file');
+});
+
+test('handleComment creates the comments directory when it does not exist', {timeout: 500}, async () => {
+  const savedEnv = process.env.TUTORIAL_WEB_COMMENTS_PATH;
+  const missingDirPath = path.join(testDir, 'new-subdir', 'tutorialWeb.json');
+  process.env.TUTORIAL_WEB_COMMENTS_PATH = missingDirPath;
+  try {
+    const result = await handleComment('Test comment for missing directory');
+    assert.equal(result.status, 'ok');
+    const comments = JSON.parse(await fs.readFile(missingDirPath, 'utf8'));
+    assert.equal(comments[0].content, 'Test comment for missing directory');
+  } finally {
+    process.env.TUTORIAL_WEB_COMMENTS_PATH = savedEnv;
+    await fs.rm(path.dirname(missingDirPath), {recursive: true, force: true});
+  }
+});
+
+test('getCommentsPath uses environment variable when set', {timeout: 500}, async () => {
+  const envValue = process.env.TUTORIAL_WEB_COMMENTS_PATH;
+  assert.ok(envValue);
+  assert.ok(getCommentsPath().includes('test/fixtures/comments'));
+});
+
+test('getCommentsPath falls back to default path when environment variable is not set', {timeout: 500}, async () => {
+  const savedEnv = process.env.TUTORIAL_WEB_COMMENTS_PATH;
+  delete process.env.TUTORIAL_WEB_COMMENTS_PATH;
+  try {
+    const path = getCommentsPath();
+    assert.ok(path.includes('db/comments'));
+    assert.ok(path.includes('tutorialWeb.json'));
+  } finally {
+    process.env.TUTORIAL_WEB_COMMENTS_PATH = savedEnv;
+  }
+});
+
+test('handleComment uses fallback path when environment variable is not set', {timeout: 500}, async () => {
+  const savedEnv = process.env.TUTORIAL_WEB_COMMENTS_PATH;
+  const defaultPath = path.join(import.meta.dirname, '../../db/comments/tutorialWeb.json');
+  const backupPath = defaultPath + '.backup';
+
+  // Backup the default comments file if it exists.
+  let hadDefault = false;
+  try {
+    const content = await fs.readFile(defaultPath, 'utf8');
+    await fs.writeFile(backupPath, content);
+    hadDefault = true;
+  } catch {
+    // File doesn't exist, that's fine.
+  }
+
+  delete process.env.TUTORIAL_WEB_COMMENTS_PATH;
+  try {
+    // Write a test file to the default location.
+    await fs.mkdir(path.dirname(defaultPath), {recursive: true});
+    await fs.writeFile(defaultPath, '[]\n');
+    const result = await handleComment('Test with fallback path');
+    assert.equal(result.status, 'ok');
+    const comments = JSON.parse(await fs.readFile(defaultPath, 'utf8'));
+    assert.equal(comments.length, 1);
+    assert.equal(comments[0].content, 'Test with fallback path');
+  } finally {
+    // Restore the original state.
+    if (hadDefault) {
+      const backup = await fs.readFile(backupPath, 'utf8');
+      await fs.writeFile(defaultPath, backup);
+      await fs.unlink(backupPath);
+    } else {
+      await fs.unlink(defaultPath).catch(() => {});
+    }
+    process.env.TUTORIAL_WEB_COMMENTS_PATH = savedEnv;
+  }
+});

package/web/unhideReportForm/{index.js → index.ts}

@@ -1,18 +1,18 @@
 /*
-  index.js
+  index.ts
   Serves a form for unhiding a report.
 */
 
 // IMPORTS
 
-const {hiddenReportsPath, reportsPath} = require('../../util');
-const fs = require('fs/promises');
-const path = require('path');
+import {hiddenReportsPath, populateTemplate, reportsPath} from '../../util.ts';
+import fs from 'node:fs/promises';
+import path from 'node:path';
 
 // FUNCTIONS
 
 // Returns a form for unhiding a report.
-exports.answer = async (_, search) => {
+export const answer = async (_: any, search: string) => {
   const searchParams = new URLSearchParams(search);
   const authCode = searchParams?.get('authCode');
   const jobName = searchParams?.get('report');
@@ -25,7 +25,7 @@ exports.answer = async (_, search) => {
         // Move the report to the reports directory.
         await fs.rename(path.join(hiddenReportsPath(), fileName), path.join(reportsPath(), fileName));
       }
-      catch (error) {
+      catch (error: any) {
         // Return why.
         return {
           status: 'error',
@@ -43,7 +43,7 @@ exports.answer = async (_, search) => {
     }
   }
   // Initialize an array of data on reports to be unhidden.
-  const reportsData = [];
+  const reportsData: any[] = [];
   // Get the names of the hidden report files.
   const hiddenReportFileNames = await fs.readdir(hiddenReportsPath());
   // For each hidden report:
@@ -54,41 +54,37 @@ exports.answer = async (_, search) => {
     const report = JSON.parse(reportJSON);
     const {id, target} = report;
     const [timeStamp, jobID] = id.split('-');
-    const {what} = target;
+    const {what: description} = target;
     // Add its data to the array.
     reportsData.push({
-      what,
+      description,
       timeStamp,
       jobID
     });
   }
   // Sort the data by page name and then by time stamp.
   reportsData.sort((a, b) => {
-    if (a.what === b.what) {
+    if (a.description === b.description) {
       return a.timeStamp.localeCompare(b.timeStamp);
     }
-    return a.what.localeCompare(b.what, 'en', {sensitivity: 'base'});
+    return a.description.localeCompare(b.description, 'en', {sensitivity: 'base'});
   });
-  const lines = [];
+  const lines: string[] = [];
   const margin = ' '.repeat(12);
   // For each report:
   reportsData.forEach(data => {
-    const {jobID, timeStamp, what} = data;
-    const specString = `${what} (job <code>${jobID}</code> at ${timeStamp})`;
+    const {jobID, timeStamp, description} = data;
+    const specString = `${description} (job <code>${jobID}</code> at ${timeStamp})`;
     // Add a line with a radio button to unhide it.
     lines.push(
       `${margin}<p><input type="radio" name="report" value="${timeStamp}-${jobID}"> ${specString}</p>`
     );
   });
-  const query = {
+  const query: Record<string, string> = {
     reports: lines.join('\n'),
   };
-  // Get the unhiding form template.
-  let answerPage = await fs.readFile(path.join(__dirname, 'index.html'), 'utf8');
-  // Replace its placeholders.
-  Object.keys(query).forEach(param => {
-    answerPage = answerPage.replace(new RegExp(`__${param}__`, 'g'), query[param]);
-  });
+  // Get the populated unhiding form template.
+  const answerPage = await populateTemplate(import.meta.dirname, query);
   // Return the populated page.
   return {
     status: 'ok',