diff --git a/lib/data/command-tuples-at-mode-task-lookup.js b/lib/data/command-tuples-at-mode-task-lookup.js
index b8a54f2dc..625dcb7f6 100644
--- a/lib/data/command-tuples-at-mode-task-lookup.js
+++ b/lib/data/command-tuples-at-mode-task-lookup.js
@@ -31,4 +31,28 @@ function createCommandTuplesATModeTaskLookup(commands) {
   return data;
 }
 
-exports.createCommandTuplesATModeTaskLookup = createCommandTuplesATModeTaskLookup;
+function createAtCommandTuplesATSettingsTestIdLookupByPresentationNumber(commands) {
+  return commands.reduce((carry, command) => {
+    const commandTask = carry[command.testId] || {};
+    const commandTaskMode = commandTask[command.target.at.settings || 'defaultMode'] || {};
+    const commandTaskModeAT = commandTaskMode[command.target.at.key] || [];
+    const commandTuples = command.commands.map(({ id, presentationNumber }) => [
+      `${id}|${presentationNumber}`,
+    ]);
+    return {
+      ...carry,
+      [command.testId]: {
+        ...commandTask,
+        [command.target.at.settings || 'defaultMode']: {
+          ...commandTaskMode,
+          [command.target.at.key]: [...commandTaskModeAT, ...commandTuples],
+        },
+      },
+    };
+  }, {});
+}
+
+module.exports = {
+  createCommandTuplesATModeTaskLookup,
+  createAtCommandTuplesATSettingsTestIdLookupByPresentationNumber,
+};
diff --git a/lib/data/parse-command-csv-row.js b/lib/data/parse-command-csv-row.js
index 6cc5c1e2c..0265cfa65 100644
--- a/lib/data/parse-command-csv-row.js
+++ b/lib/data/parse-command-csv-row.js
@@ -67,4 +67,194 @@ function parseCommandCSVRow(commandRow) {
   };
 }
 
-exports.parseCommandCSVRow = parseCommandCSVRow;
+function flattenObject(obj, parentKey = '') {
+  const flattened = {};
+
+  for (const key in obj) {
+    if (typeof obj[key] === 'object') {
+      const subObject = flattenObject(obj[key], parentKey + key + '.');
+      Object.assign(flattened, subObject);
+    } else {
+      flattened[parentKey + key] = obj[key];
+    }
+  }
+
+  return flattened;
+}
+
+function sanitizeWhitespace(value) {
+  return value.replace(/\s+/g, ' ').trim();
+}
+
+function sanitizeCommand(command) {
+  return {
+    ...command,
+    command: sanitizeWhitespace(command.command),
+  };
+}
+
+function findValueByKey(keyMappings, keyToFindText) {
+  const keyToFind = keyToFindText.replace(/\s+/g, ' ').trim();
+  const keyMap = Object.keys(keyMappings);
+
+  // Need to specially handle VO modifier key combination
+  if (keyToFind === 'vo')
+    return findValuesByKeys(keyMappings, [keyMappings['modifierAliases.vo']])[0];
+
+  if (keyToFind.includes('modifiers.') || keyToFind.includes('keys.')) {
+    const parts = keyToFind.split('.');
+    const keyToCheck = parts[parts.length - 1]; // value after the '.'
+
+    if (keyMappings[keyToFind])
+      return {
+        value: keyMappings[keyToFind],
+        key: keyToCheck,
+      };
+
+    return null;
+  }
+
+  for (const key of keyMap) {
+    const parts = key.split('.');
+    const parentKey = parts[0];
+    const keyToCheck = parts[parts.length - 1]; // value after the '.'
+
+    if (keyToCheck === keyToFind) {
+      if (parentKey === 'modifierAliases') {
+        return findValueByKey(keyMappings, `modifiers.${keyMappings[key]}`);
+      } else if (parentKey === 'keyAliases') {
+        return findValueByKey(keyMappings, `keys.${keyMappings[key]}`);
+      }
+
+      return {
+        value: keyMappings[key],
+        key: keyToCheck,
+      };
+    }
+  }
+
+  // Return null if the key is not found
+  return null;
+}
+
+function findValuesByKeys(commandsMapping, keysToFind = []) {
+  const result = [];
+
+  const patternSepWithReplacement = (keyToFind, pattern, replacement) => {
+    if (keyToFind.includes(pattern)) {
+      let value = '';
+      let validKeys = true;
+      const keys = keyToFind.split(pattern);
+
+      for (const key of keys) {
+        const keyResult = findValueByKey(commandsMapping, key);
+        if (keyResult) value = value ? `${value}${replacement}${keyResult.value}` : keyResult.value;
+        else validKeys = false;
+      }
+      if (validKeys) return { value, key: keyToFind };
+    }
+
+    return null;
+  };
+
+  const patternSepHandler = keyToFind => {
+    let value = '';
+
+    if (keyToFind.includes(' ') && keyToFind.includes('+')) {
+      const keys = keyToFind.split(' ');
+      for (let [index, key] of keys.entries()) {
+        const keyToFindResult = findValueByKey(commandsMapping, key);
+        if (keyToFindResult) keys[index] = keyToFindResult.value;
+        if (key.includes('+')) keys[index] = patternSepWithReplacement(key, '+', '+').value;
+      }
+      value = keys.join(' then ');
+
+      return { value, key: keyToFind };
+    } else if (keyToFind.includes(' ')) return patternSepWithReplacement(keyToFind, ' ', ' then ');
+    else if (keyToFind.includes('+')) return patternSepWithReplacement(keyToFind, '+', '+');
+  };
+
+  for (const keyToFind of keysToFind) {
+    if (keyToFind.includes(' ') || keyToFind.includes('+')) {
+      result.push(patternSepHandler(keyToFind));
+    } else {
+      const keyToFindResult = findValueByKey(commandsMapping, keyToFind);
+      if (keyToFindResult) result.push(keyToFindResult);
+    }
+  }
+
+  return result;
+}
+
+function parseCommandCSVRowV2({ commands }, commandsJson) {
+  const commandsParsed = [];
+  const flattenedCommandsJson = flattenObject(commandsJson);
+
+  function createParsedCommand(command, atTargetInfo) {
+    const commandIds = command.command.split(' ');
+    const commandKVs = findValuesByKeys(flattenedCommandsJson, [command.command]);
+
+    const assertionExceptions = command.assertionExceptions.length
+      ? sanitizeWhitespace(command.assertionExceptions).split(' ')
+      : [];
+
+    const commands = commandKVs.map(e => ({
+      id: e.key,
+      keystroke: e.value,
+      keypresses: e.value.split(' then ').map((e, index) => ({
+        id: commandIds[index],
+        keystroke: e,
+      })),
+      presentationNumber: Number(command.presentationNumber),
+      assertionExceptions,
+    }));
+
+    // Also account for 'modeless' AT configurations with 'defaultMode'
+    const settingsValue = command.settings || 'defaultMode';
+
+    const foundCommandIndex = commandsParsed.findIndex(
+      e =>
+        e.testId === command.testId &&
+        e.target.at.key === atTargetInfo.key &&
+        e.target.at.settings === settingsValue &&
+        (e.commands.length
+          ? e.commands.every(
+              ({ presentationNumber }) =>
+                parseInt(presentationNumber) === parseInt(command.presentationNumber)
+            )
+          : true)
+    );
+
+    // Add new parsed command since none exist
+    if (foundCommandIndex < 0) {
+      commandsParsed.push({
+        testId: command.testId,
+        target: {
+          at: {
+            ...atTargetInfo,
+            settings: settingsValue,
+          },
+        },
+        commands,
+      });
+    } else {
+      commandsParsed[foundCommandIndex].commands.push(...commands);
+    }
+  }
+
+  const generateCommandsParsed = (commands, key) => {
+    for (const command of commands) createParsedCommand(command, { key });
+  };
+
+  commands.forEach(command =>
+    generateCommandsParsed(command.commands.map(sanitizeCommand), command.atKey)
+  );
+
+  return commandsParsed;
+}
+
+module.exports = {
+  parseCommandCSVRow,
+  parseCommandCSVRowV2,
+  flattenObject,
+};
diff --git a/lib/data/parse-support.js b/lib/data/parse-support.js
index 5aed27cd4..ed19102e3 100644
--- a/lib/data/parse-support.js
+++ b/lib/data/parse-support.js
@@ -22,6 +22,8 @@ function parseSupport(supportRaw) {
         ats: [at],
       })),
     ],
+    testPlanStrings: supportRaw.testPlanStrings,
+    references: supportRaw.references,
   };
 }
 
diff --git a/lib/data/parse-test-csv-row.js b/lib/data/parse-test-csv-row.js
index 66304e200..c0138e46e 100644
--- a/lib/data/parse-test-csv-row.js
+++ b/lib/data/parse-test-csv-row.js
@@ -84,4 +84,179 @@ function parseTestCSVRow(testRow) {
   };
 }
 
-exports.parseTestCSVRow = parseTestCSVRow;
+function isEmptyObject(object) {
+  return object && Object.keys(object).length === 0;
+}
+
+function parseTestCSVRowV2({ tests, assertions, scripts, commands }) {
+  const testsParsed = [];
+
+  // Create containers for all potentially found presentationNumbers; empty ones will be filtered out at the end.
+  // For eg. in the case where an {at-key}-commands.csv is missing.
+  // This also maintains the order for testRow.presentationNumber
+  for (let i = 0; i < tests.length; i++) {
+    testsParsed.push({});
+  }
+
+  function createParsedTest(arrPosition, test, command, atTargetInfo) {
+    // Create setupScript object
+    const setupScript = test.setupScript
+      ? scripts.find(script => test.setupScript === script.setupScript) // { setupScript, setupScriptDescription }
+      : undefined;
+
+    // Create assertions value
+    const assertionsValue = test.assertions
+      ? test.assertions.split(' ').map(assertion => {
+          // TODO: Return error if foundAssertion undefined
+          const foundAssertion = assertions.find(e => e.assertionId === assertion);
+          return foundAssertion
+            ? { ...foundAssertion, priority: Number(foundAssertion.priority) }
+            : {};
+        })
+      : undefined;
+
+    // Create references values
+    let referencesValue = assertionsValue
+      ? assertionsValue.flatMap(assertion => assertion.refIds.trim().split(' '))
+      : [];
+    referencesValue = referencesValue.filter(e => e !== '');
+
+    if (referencesValue.length) {
+      // Remove duplicates
+      referencesValue = [...new Set(referencesValue)];
+
+      // Format to [ { refId: '' } ]
+      referencesValue = referencesValue.map(refId => {
+        return { refId };
+      });
+    }
+
+    // Also account for 'modeless' AT configurations with 'defaultMode'
+    // TODO: Account for a list of settings as described by https://github.com/w3c/aria-at/wiki/Test-Format-Definition-V2#settings
+    const settingsValue = command.settings || 'defaultMode';
+
+    if (isEmptyObject(testsParsed[arrPosition])) {
+      testsParsed[arrPosition] = {
+        testId: test.testId,
+        title: test.title,
+        references: referencesValue,
+        presentationNumber: Number(test.presentationNumber),
+        target: {
+          ats: [
+            {
+              ...atTargetInfo,
+              settings: settingsValue,
+            },
+          ],
+        },
+        setupScript: setupScript
+          ? {
+              script: setupScript.setupScript,
+              scriptDescription: setupScript.setupScriptDescription,
+            }
+          : setupScript,
+        instructions: test.instructions,
+        assertions: assertionsValue,
+      };
+    } else {
+      if (
+        !testsParsed[arrPosition].target.ats.find(
+          e => e.key === atTargetInfo.key && e.settings === settingsValue
+        )
+      )
+        testsParsed[arrPosition].target.ats.push({
+          ...atTargetInfo,
+          settings: settingsValue,
+        });
+    }
+  }
+
+  const generateTestsParsed = (commands, key) => {
+    for (const command of commands) {
+      const findTest = test => test.testId === command.testId;
+
+      const test = tests.find(findTest);
+      const testIndex = tests.findIndex(findTest);
+      createParsedTest(testIndex, test, command, { key });
+    }
+  };
+
+  const attachCommandInfo = (commands, key) => {
+    function findCommandInfo({ command, presentationNumber, settings, testId }, commandInfo) {
+      return (
+        testId === commandInfo.testId &&
+        command === commandInfo.command &&
+        settings === commandInfo.settings &&
+        presentationNumber === commandInfo.presentationNumber
+      );
+    }
+
+    for (const command of commands) {
+      testsParsed.forEach(test => {
+        test.assertions?.forEach(assertion => {
+          if (
+            command.testId === test.testId &&
+            test.target.ats.some(
+              at => at.key === key && at.settings === (command.settings || 'defaultMode')
+            )
+          ) {
+            if (!assertion.commandInfo) assertion.commandInfo = {};
+            if (!assertion.commandInfo[key]) assertion.commandInfo[key] = [];
+
+            const commandInfo = {
+              testId: command.testId,
+              command: command.command,
+              settings: command.settings || 'defaultMode',
+              presentationNumber: Number(command.presentationNumber),
+            };
+
+            // assertion level commandInfo, useful for getting assertionExceptions
+            const assertionCommandInfoExists = assertion.commandInfo[key].find(each =>
+              findCommandInfo(each, commandInfo)
+            );
+            if (!assertionCommandInfoExists) {
+              const assertionCommandInfo = {
+                ...commandInfo,
+                assertionExceptions: command.assertionExceptions,
+              };
+              assertion.commandInfo[key].push(assertionCommandInfo);
+            }
+
+            // Test level commandInfo, useful for getting review level information
+            if (!test.commandsInfo) test.commandsInfo = {};
+            if (!test.commandsInfo[key]) test.commandsInfo[key] = [];
+            const testCommandInfoExists = test.commandsInfo[key].find(each =>
+              findCommandInfo(each, commandInfo)
+            );
+
+            if (!testCommandInfoExists) test.commandsInfo[key].push(commandInfo);
+          }
+        });
+      });
+    }
+  };
+
+  // Maintain the order of commands by commandRow.presentationNumber
+  const commandsSort = (a, b) =>
+    parseFloat(a.presentationNumber) - parseFloat(b.presentationNumber);
+
+  /*const GENERATE_TESTS = [
+    [jawsCommands, 'jaws'],
+    [nvdaCommands, 'nvda'],
+    [voCommands, 'voiceover_macos'],
+  ];*/
+  const GENERATE_TESTS = commands.map(command => [command.commands, command.atKey]);
+  GENERATE_TESTS.forEach(([commands, key]) => {
+    if (commands.length) generateTestsParsed(commands.sort(commandsSort), key);
+  });
+  GENERATE_TESTS.forEach(([commands, key]) => {
+    if (commands.length) attachCommandInfo(commands.sort(commandsSort), key);
+  });
+
+  return testsParsed.filter(testParsed => Object.keys(testParsed).length);
+}
+
+module.exports = {
+  parseTestCSVRow,
+  parseTestCSVRowV2,
+};
diff --git a/lib/data/process-test-directory-v1.js b/lib/data/process-test-directory-v1.js
new file mode 100644
index 000000000..c286e2c78
--- /dev/null
+++ b/lib/data/process-test-directory-v1.js
@@ -0,0 +1,1386 @@
+/// <reference path="../../types/aria-at-csv.js" />
+/// <reference path="../../types/aria-at-parsed.js" />
+/// <reference path="../../types/aria-at-validated.js" />
+/// <reference path="../../types/aria-at-file.js" />
+/// <reference path="../util/file-record-types.js" />
+
+'use strict';
+
+const path = require('path');
+const { Readable } = require('stream');
+const {
+  types: { isArrayBufferView, isArrayBuffer },
+} = require('util');
+
+const csv = require('csv-parser');
+const fse = require('fs-extra');
+const beautify = require('json-beautify');
+
+const { validate } = require('../util/error');
+const { reindent } = require('../util/lines');
+const { Queryable } = require('../util/queryable');
+const { FileRecordChain } = require('../util/file-record-chain');
+
+const { parseSupport } = require('./parse-support');
+const { parseTestCSVRow } = require('./parse-test-csv-row');
+const { parseCommandCSVRow } = require('./parse-command-csv-row');
+const { createCommandTuplesATModeTaskLookup } = require('./command-tuples-at-mode-task-lookup');
+
+const { renderHTML: renderCollectedTestHtml } = require('./templates/collected-test.html');
+const { createExampleScriptsTemplate } = require('./example-scripts-template');
+
+/**
+ * @param {string} directory - path to directory of data to be used to generate test
+ * @param {object} args={}
+ */
+const processTestDirectory = async ({ directory, args = {} }) => {
+  let VERBOSE_CHECK = false;
+  let VALIDATE_CHECK = false;
+
+  let suppressedMessages = 0;
+
+  /**
+   * @param {string} message - message to be logged
+   * @param {object} [options]
+   * @param {boolean} [options.severe=false] - indicates whether the message should be viewed as an error or not
+   * @param {boolean} [options.force=false] - indicates whether this message should be forced to be outputted regardless of verbosity level
+   */
+  const log = (message, { severe = false, force = false } = {}) => {
+    if (VERBOSE_CHECK || force) {
+      if (severe) console.error(message);
+      else console.log(message);
+    } else {
+      // Output no logs
+      suppressedMessages += 1; // counter to indicate how many messages were hidden
+    }
+  };
+
+  /**
+   * @param {string} message - error message
+   */
+  log.warning = message => log(message, { severe: true, force: true });
+
+  /**
+   * Log error then exit the process.
+   * @param {string} message - error message
+   */
+  log.error = message => {
+    log.warning(message);
+    process.exit(1);
+  };
+
+  // setup from arguments passed to npm script
+  VERBOSE_CHECK = !!args.verbose;
+  VALIDATE_CHECK = !!args.validate;
+
+  const validModes = ['reading', 'interaction', 'item'];
+
+  // cwd; @param rootDirectory is dependent on this file not moving from the `lib/data` folder
+  const libDataDirectory = path.dirname(__filename);
+  const rootDirectory = path.join(libDataDirectory, '../..');
+
+  const testsDirectory = path.join(rootDirectory, 'tests');
+  const testPlanDirectory = path.join(rootDirectory, directory);
+
+  const resourcesDirectory = path.join(testsDirectory, 'resources');
+
+  const supportFilePath = path.join(testsDirectory, 'support.json');
+  const atCommandsCsvFilePath = path.join(testPlanDirectory, 'data', 'commands.csv');
+  const testsCsvFilePath = path.join(testPlanDirectory, 'data', 'testsV1.csv');
+  const referencesCsvFilePath = path.join(testPlanDirectory, 'data', 'referencesV1.csv');
+
+  // build output folders and file paths setup
+  const buildDirectory = path.join(rootDirectory, 'build');
+  const testPlanBuildDirectory = path.join(buildDirectory, directory);
+  const indexFileBuildOutputPath = path.join(testPlanBuildDirectory, 'index.html');
+
+  let backupTestsCsvFile, backupReferencesCsvFile;
+
+  // create build directory if it doesn't exist
+  fse.mkdirSync(buildDirectory, { recursive: true });
+
+  const existingBuildPromise = FileRecordChain.read(buildDirectory, {
+    glob: [
+      '',
+      'tests',
+      `tests/${path.basename(directory)}`,
+      `tests/${path.basename(directory)}/**`,
+      'tests/resources',
+      'tests/resources/*',
+      'tests/support.json',
+    ].join(','),
+  });
+
+  const [testPlanRecord, resourcesOriginalRecord, supportRecord] = await Promise.all(
+    [testPlanDirectory, resourcesDirectory, supportFilePath].map(filepath =>
+      FileRecordChain.read(filepath)
+    )
+  );
+
+  const scriptsRecord = testPlanRecord.find('data/js');
+  const resourcesRecord = resourcesOriginalRecord.filter({ glob: '{aria-at-*,keys,vrender}.mjs' });
+
+  const newBuild = new FileRecordChain({
+    entries: [
+      {
+        name: 'tests',
+        entries: [
+          {
+            name: path.basename(directory),
+            entries: testPlanRecord.filter({ glob: 'reference{,/**}' }).record.entries,
+          },
+          { name: 'resources', ...resourcesRecord.record },
+          { name: 'support.json', ...supportRecord.record },
+        ],
+      },
+    ],
+  });
+
+  const keyDefs = {};
+  const supportJson = JSON.parse(supportRecord.text);
+
+  let allATKeys = supportJson.ats.map(({ key }) => key);
+  let allATNames = supportJson.ats.map(({ name }) => name);
+
+  const validAppliesTo = ['Screen Readers', 'Desktop Screen Readers'].concat(allATKeys);
+
+  if (!testPlanRecord.isDirectory()) {
+    log.error(`The test directory '${testPlanDirectory}' does not exist. Check the path to tests.`);
+  }
+
+  if (!testPlanRecord.find('data/commands.csv').isFile()) {
+    log.error(
+      `The at-commands.csv file does not exist. Please create '${atCommandsCsvFilePath}' file.`
+    );
+  }
+
+  if (!testPlanRecord.find('data/testsV1.csv').isFile()) {
+    // Check if original file can be processed
+    if (!testPlanRecord.find('data/tests.csv').isFile()) {
+      log.error(`The testsV1.csv file does not exist. Please create '${testsCsvFilePath}' file.`);
+    } else {
+      backupTestsCsvFile = 'data/tests.csv';
+    }
+  }
+
+  if (!testPlanRecord.find('data/referencesV1.csv').isFile()) {
+    // Check if original file can be processed
+    if (!testPlanRecord.find('data/references.csv').isFile()) {
+      log.error(
+        `The referencesV1.csv file does not exist. Please create '${referencesCsvFilePath}' file.`
+      );
+    } else {
+      backupReferencesCsvFile = 'data/references.csv';
+    }
+  }
+
+  // get Keys that are defined
+  try {
+    // read contents of the file
+    const keys = resourcesRecord.find('keys.mjs').text;
+
+    // split the contents by new line
+    const lines = keys.split(/\r?\n/);
+
+    // print all lines
+    lines.forEach(line => {
+      let parts1 = line.split(' ');
+      let parts2 = line.split('"');
+
+      if (parts1.length > 3) {
+        let code = parts1[2].trim();
+        keyDefs[code] = parts2[1].trim();
+      }
+    });
+  } catch (err) {
+    log.warning(err);
+  }
+
+  function cleanTask(task) {
+    return task.replace(/'/g, '').replace(/;/g, '').trim().toLowerCase();
+  }
+
+  /**
+   * Create Test File
+   * @param {AriaATCSV.Test} test
+   * @param refs
+   * @param commands
+   * @returns {(string|*[])[]}
+   */
+  function createTestFile(
+    test,
+    refs,
+    commands,
+    { addTestError, emitFile, scriptsRecord, exampleScriptedFilesQueryable }
+  ) {
+    let scripts = [];
+
+    // default setupScript if test has undefined setupScript
+    if (!scriptsRecord.find(`${test.setupScript}.js`).isFile()) test.setupScript = '';
+
+    function getModeValue(value) {
+      let v = value.trim().toLowerCase();
+      if (!validModes.includes(v)) {
+        addTestError(test.testId, '"' + value + '" is not valid value for "mode" property.');
+      }
+      return v;
+    }
+
+    function getTask(t) {
+      let task = cleanTask(t);
+
+      if (typeof commands[task] !== 'object') {
+        addTestError(test.testId, '"' + task + '" does not exist in commands.csv file.');
+      }
+
+      return task;
+    }
+
+    function getAppliesToValues(values) {
+      function checkValue(value) {
+        let v1 = value.trim().toLowerCase();
+        for (let i = 0; i < validAppliesTo.length; i++) {
+          let v2 = validAppliesTo[i];
+          if (v1 === v2.toLowerCase()) {
+            return v2;
+          }
+        }
+        return false;
+      }
+
+      // check for individual assistive technologies
+      let items = values.split(',');
+      let newValues = [];
+      items.filter(item => {
+        let value = checkValue(item);
+        if (!value) {
+          addTestError(test.testId, '"' + item + '" is not valid value for "appliesTo" property.');
+        }
+
+        newValues.push(value);
+      });
+
+      return newValues;
+    }
+
+    /**
+     * Determines priority level (default is 1) of assertion string, then adds it to the collection of assertions for
+     * the test plan
+     * @param {string} a - Assertion string to be evaluated
+     */
+    function addAssertion(a) {
+      let level = '1';
+      let str = a;
+      a = a.trim();
+
+      // matches a 'colon' when preceded by either of the digits 1 OR 2 (SINGLE CHARACTER), at the start of the string
+      let parts = a.split(/(?<=^[1-2]):/g);
+
+      if (parts.length === 2) {
+        level = parts[0];
+        str = parts[1].substring(0);
+        if (level !== '1' && level !== '2') {
+          addTestError(
+            test.testId,
+            "Level value must be 1 or 2, value found was '" +
+              level +
+              "' for assertion '" +
+              str +
+              "' (NOTE: level 2 defined for this assertion)."
+          );
+          level = '2';
+        }
+      }
+
+      if (a.length) {
+        assertions.push([level, str]);
+      }
+    }
+
+    function getReferences(example, testRefs) {
+      let links = '';
+
+      if (typeof example === 'string' && example.length) {
+        links += `<link rel="help" href="${refs.example}">\n`;
+      }
+
+      let items = test.refs.split(' ');
+      items.forEach(function (item) {
+        item = item.trim();
+
+        if (item.length) {
+          if (typeof refs[item] === 'string') {
+            links += `<link rel="help" href="${refs[item]}">\n`;
+          } else {
+            addTestError(test.testId, 'Reference does not exist: ' + item);
+          }
+        }
+      });
+
+      return links;
+    }
+
+    function addSetupScript(scriptName) {
+      let script = '';
+      if (scriptName) {
+        if (!scriptsRecord.find(`${scriptName}.js`).isFile()) {
+          addTestError(test.testId, `Setup script does not exist: ${scriptName}.js`);
+          return '';
+        }
+
+        try {
+          const data = scriptsRecord.find(`${scriptName}.js`).text;
+          const lines = data.split(/\r?\n/);
+          lines.forEach(line => {
+            if (line.trim().length) script += '\t\t\t' + line.trim() + '\n';
+          });
+        } catch (err) {
+          log.warning(err);
+        }
+
+        scripts.push(`\t\t${scriptName}: function(testPageDocument){\n${script}\t\t}`);
+      }
+
+      return script;
+    }
+
+    function getSetupScriptDescription(desc) {
+      let str = '';
+      if (typeof desc === 'string') {
+        let d = desc.trim();
+        if (d.length) {
+          str = d;
+        }
+      }
+
+      return str;
+    }
+
+    function getScripts() {
+      let js = 'var scripts = {\n';
+      js += scripts.join(',\n');
+      js += '\n\t};';
+      return js;
+    }
+
+    let task = getTask(test.task);
+    let appliesTo = getAppliesToValues(test.appliesTo);
+    let mode = getModeValue(test.mode);
+
+    appliesTo.forEach(at => {
+      if (commands[task]) {
+        if (!commands[task][mode][at.toLowerCase()]) {
+          addTestError(
+            test.testId,
+            'command is missing for the combination of task: "' +
+              task +
+              '", mode: "' +
+              mode +
+              '", and AT: "' +
+              at.toLowerCase() +
+              '" '
+          );
+        }
+      }
+    });
+
+    let assertions = [];
+    let id = test.testId;
+    if (parseInt(test.testId) < 10) {
+      id = '0' + id;
+    }
+
+    const cleanTaskName = cleanTask(test.task).replace(/\s+/g, '-');
+    let testFileName = `test-${id}-${cleanTaskName}-${mode}.html`;
+    let testJSONFileName = `test-${id}-${cleanTaskName}-${mode}.json`;
+
+    let testPlanHtmlFileBuildPath = path.join(testPlanBuildDirectory, testFileName);
+    let testPlanJsonFileBuildPath = path.join(testPlanBuildDirectory, testJSONFileName);
+
+    let references = getReferences(refs.example, test.refs);
+    addSetupScript(test.setupScript);
+
+    for (let i = 1; i < 31; i++) {
+      if (!test['assertion' + i]) {
+        continue;
+      }
+      addAssertion(test['assertion' + i]);
+    }
+
+    /** @type {AriaATFile.Behavior} */
+    let testData = {
+      setup_script_description: getSetupScriptDescription(test.setupScriptDescription),
+      setupTestPage: test.setupScript,
+      applies_to: appliesTo,
+      mode: mode,
+      task: task,
+      assertionResponseQuestion: supportJson.testPlanStrings.assertionResponseQuestion,
+      specific_user_instruction: test.instructions,
+      output_assertions: assertions,
+    };
+
+    emitFile(testPlanJsonFileBuildPath, JSON.stringify(testData, null, 2), 'utf8');
+
+    function getTestJson() {
+      return JSON.stringify(testData, null, 2);
+    }
+
+    function getCommandsJson() {
+      return beautify({ [task]: commands[task] }, null, 2, 40);
+    }
+
+    let testHTML = `
+<!DOCTYPE html>
+<meta charset="utf-8">
+<title>${test.title}</title>
+${references}
+<script>
+  ${getScripts()}
+</script>
+<script type="module">
+  import { initialize, verifyATBehavior, displayTestPageAndInstructions } from "../resources/aria-at-harness.mjs";
+
+  new Promise((resolve) => {
+    fetch('../support.json')
+      .then(response => resolve(response.json()))
+    })
+  .then(supportJson => {
+    const testJson = ${getTestJson()};
+    const commandJson = ${getCommandsJson()};
+    initialize(supportJson, commandJson);
+    verifyATBehavior(testJson);
+    displayTestPageAndInstructions(${JSON.stringify(
+      exampleScriptedFilesQueryable.where({ name: test.setupScript ? test.setupScript : '' }).path
+    )});
+  });
+</script>
+  `;
+
+    emitFile(testPlanHtmlFileBuildPath, testHTML, 'utf8');
+
+    /** @type {AriaATFile.CollectedTest} */
+    const collectedTest = {};
+
+    const applies_to_at = [];
+
+    allATKeys.forEach(at => applies_to_at.push(testData.applies_to.indexOf(at) >= 0));
+
+    return [testFileName, applies_to_at];
+  }
+
+  /**
+   * Create an index file for a local server
+   * @param tasks
+   */
+  function createIndexFile(tasks, { emitFile }) {
+    let rows = '';
+    let all_ats = '';
+
+    allATNames.forEach(at => (all_ats += '<th>' + at + '</th>\n'));
+
+    tasks.forEach(function (task) {
+      rows += `<tr><td>${task.id}</td>`;
+      rows += `<td scope="row">${task.title}</td>`;
+      for (let i = 0; i < allATKeys.length; i++) {
+        if (task.applies_to_at[i]) {
+          rows += `<td class="test"><a href="${task.href}?at=${allATKeys[i]}" aria-label="${allATNames[i]} test for task ${task.id}">${allATNames[i]}</a></td>`;
+        } else {
+          rows += `<td class="test none">not included</td>`;
+        }
+      }
+      rows += `<td>${task.script}</td></tr>\n`;
+    });
+
+    let indexHTML = `
+<!DOCTYPE html>
+<meta charset="utf-8">
+<head>
+  <title>Index of Assistive Technology Test Files</title>
+  <style>
+    table {
+      display: table;
+      border-collapse: collapse;
+      border-spacing: 2px;
+      border-color: gray;
+    }
+
+    thead {
+      display: table-row-group;
+      vertical-align: middle;
+      border-bottom: black solid 2px;
+    }
+
+    tbody {
+      display: table-row-group;
+      vertical-align: middle;
+      border-color: gray;
+    }
+
+    tr:nth-child(even) {background: #DDD}
+    tr:nth-child(odd) {background: #FFF}
+
+    tr {
+      display: table-row;
+      vertical-align: inherit;
+      border-color: gray;
+    }
+
+    td {
+      padding: 3px;
+      display: table-cell;
+    }
+
+    td.test {
+      text-align: center;
+    }
+
+    td.none {
+      color: #333;
+    }
+
+    th {
+      padding: 3px;
+      font-weight: bold;
+      display: table-cell;
+    }
+  </style>
+</head>
+<body>
+ <main>
+  <h1>Index of Assistive Technology Test Files</h1>
+  <p>This is useful for viewing the local files on a local web server.</p>
+  <table>
+    <thead>
+      <tr>
+        <th>Task ID</th>
+        <th>Testing Task</th>
+        ${all_ats}
+        <th>Setup Script Reference</th>
+      </tr>
+    </thead>
+    <tbody>
+${rows}
+    </tbody>
+  </table>
+  </main>
+</body>
+`;
+
+    emitFile(indexFileBuildOutputPath, indexHTML, 'utf8');
+  }
+
+  // Process CSV files
+  var refs = {};
+  var errorCount = 0;
+  var errors = '';
+  var indexOfURLs = [];
+  var checkedSourceHtmlScriptFiles = [];
+
+  function addTestError(id, error) {
+    errorCount += 1;
+    errors += '[Test ' + id + ']: ' + error + '\n';
+  }
+
+  function addCommandError({ testId, task }, key) {
+    errorCount += 1;
+    errors += `[Command]: The key reference "${key}" found in "${directory}/data/commands.csv" for "test id ${testId}: ${task}" is invalid. Command may not be defined in "tests/resources/keys.mjs".\n`;
+  }
+
+  const newTestPlan = newBuild.find(`tests/${path.basename(testPlanBuildDirectory)}`);
+  function emitFile(filepath, content) {
+    newTestPlan.add(path.relative(testPlanBuildDirectory, filepath), {
+      buffer: toBuffer(content),
+    });
+  }
+
+  function generateSourceHtmlScriptFile(filePath, content) {
+    // check that test plan's reference html file path is generated file
+    if (
+      filePath.includes('reference') &&
+      (filePath.split(path.sep).pop().match(/\./g) || []).length > 1
+    ) {
+      // generate file at `<root>/tests/<directory>/reference/<path>/<directory>.<script>.html
+      const sourceFilePath = filePath.replace(`build${path.sep}`, '');
+      emitFile(sourceFilePath, content);
+      checkedSourceHtmlScriptFiles.push(sourceFilePath);
+    }
+  }
+
+  // intended to be an internal helper to reduce some code duplication and make logging for csv errors simpler
+  async function readCSVFile(filePath, rowValidator = identity => identity) {
+    const rawCSV = await readCSV(testPlanRecord.find(filePath));
+    let index = 0;
+    function printError(message) {
+      // line number is index+2
+      log.warning(
+        `WARNING: Error parsing ${path.join(testPlanDirectory, filePath)} line ${
+          index + 2
+        }: ${message}`
+      );
+    }
+    try {
+      const firstRowKeysLength = Object.keys(rawCSV[0]).length;
+      for (; index < rawCSV.length; index++) {
+        const keysLength = Object.keys(rawCSV[index]).length;
+        if (keysLength != firstRowKeysLength) {
+          printError(
+            `column number mismatch, please include empty cells to match headers. Expected ${firstRowKeysLength} columns, found ${keysLength}`
+          );
+        }
+        if (!rowValidator(rawCSV[index])) {
+          printError('validator returned false result');
+          return;
+        }
+      }
+    } catch (err) {
+      printError(err);
+      return;
+    }
+    log(`Successfully parsed ${path.join(testPlanDirectory, filePath)}`);
+    return rawCSV;
+  }
+
+  function validateReferencesKeys(row) {
+    if (typeof row.refId !== 'string' || typeof row.value !== 'string') {
+      throw new Error('Row missing refId or value');
+    }
+    return row;
+  }
+
+  const validCommandKeys = /^(?:testId|task|mode|at|command[A-Z])$/;
+  const numericKeyFormat = /^_(\d+)$/;
+  function validateCommandsKeys(row) {
+    // example header:
+    //    testId,task,mode,at,commandA,commandB,commandC,commandD,commandE,commandF
+    for (const key of Object.keys(row)) {
+      if (numericKeyFormat.test(key)) {
+        throw new Error(`Column found without header row, ${+key.substring(1) + 1}`);
+      } else if (!validCommandKeys.test(key)) {
+        throw new Error(`Unknown commands.csv key: ${key} - check header row?`);
+      }
+    }
+    if (
+      !(
+        row.testId?.length &&
+        row.task?.length &&
+        row.mode?.length &&
+        row.at?.length &&
+        row.commandA?.length
+      )
+    ) {
+      throw new Error('Missing one of required testId, task, mode, at, commandA');
+    }
+    return row;
+  }
+
+  const validTestsKeys =
+    /^(?:testId|title|appliesTo|mode|task|setupScript|setupScriptDescription|refs|instructions|assertion(?:[1-9]|[1-2][0-9]|30))$/;
+  function validateTestsKeys(row) {
+    // example header:
+    // testId,title,appliesTo,mode,task,setupScript,setupScriptDescription,refs,instructions,assertion1,assertion2,assertion3,assertion4,assertion5,assertion6,assertion7
+    for (const key of Object.keys(row)) {
+      if (numericKeyFormat.test(key)) {
+        throw new Error(`Column found without header row, ${+key.substring(1) + 1}`);
+      } else if (!validTestsKeys.test(key)) {
+        throw new Error(`Unknown testsV1.csv key: ${key} - check header row?`);
+      }
+    }
+    if (
+      !(
+        row.testId?.length &&
+        row.title?.length &&
+        row.appliesTo?.length &&
+        row.mode?.length &&
+        row.task?.length
+      )
+    ) {
+      throw new Error('Missing one of required testId, title, appliesTo, mode, task');
+    }
+    return row;
+  }
+
+  const [atCommands, refRows, tests] = await Promise.all([
+    readCSVFile('data/commands.csv', validateCommandsKeys),
+    readCSVFile(backupReferencesCsvFile || 'data/referencesV1.csv', validateReferencesKeys),
+    readCSVFile(backupTestsCsvFile || 'data/testsV1.csv', validateTestsKeys),
+  ]);
+
+  for (const row of refRows) {
+    refs[row.refId] = row.value.trim();
+  }
+
+  const scripts = loadScripts(scriptsRecord);
+
+  const commandsParsed = atCommands.map(parseCommandCSVRow);
+  const testsParsed = tests.map(parseTestCSVRow);
+  const referencesParsed = parseReferencesCSV(refRows);
+  const keysParsed = parseKeyMap(keyDefs);
+  const supportParsed = parseSupport(supportJson);
+
+  const keysValidated = validateKeyMap(keysParsed, {
+    addKeyMapError(reason) {
+      errorCount += 1;
+      errors += `[resources/keys.mjs]: ${reason}\n`;
+    },
+  });
+
+  const supportQueryables = {
+    at: Queryable.from('at', supportParsed.ats),
+    atGroup: Queryable.from('atGroup', supportParsed.atGroups),
+  };
+  const keyQueryable = Queryable.from('key', keysValidated);
+  const commandLookups = {
+    key: keyQueryable,
+    support: supportQueryables,
+  };
+  const commandsValidated = commandsParsed.map(command =>
+    validateCommand(command, commandLookups, { addCommandError })
+  );
+
+  const referenceQueryable = Queryable.from('reference', referencesParsed);
+  const examplePathOriginal = referenceQueryable.where({ refId: 'reference' })
+    ? referenceQueryable.where({ refId: 'reference' }).value
+    : '';
+  if (!examplePathOriginal) {
+    log.error(`ERROR: Valid 'reference' value not found in "${directory}/data/referencesV1.csv".`);
+  }
+  const exampleRecord = testPlanRecord.find(examplePathOriginal);
+  if (!exampleRecord.isFile()) {
+    log.error(
+      `ERROR: Invalid 'reference' value path "${examplePathOriginal}" found in "${directory}/data/referencesV1.csv".`
+    );
+  }
+  const testLookups = {
+    command: Queryable.from('command', commandsValidated),
+    mode: Queryable.from('mode', validModes),
+    reference: referenceQueryable,
+    script: Queryable.from('script', scripts),
+    support: supportQueryables,
+  };
+  const testsValidated = testsParsed.map(test =>
+    validateTest(test, testLookups, {
+      addTestError: addTestError.bind(null, test.testId),
+    })
+  );
+
+  /** @type {function(string): string} */
+  const examplePathTemplate = scriptName =>
+    path.join(
+      path.dirname(examplePathOriginal),
+      `${path.basename(examplePathOriginal, '.html')}${scriptName ? `.${scriptName}` : ''}.html`
+    );
+  const exampleTemplate = validate.reportTo(
+    reason => log.warning(`[${examplePathOriginal}]: ${reason.message}`),
+    () => createExampleScriptsTemplate(exampleRecord)
+  );
+  const exampleScriptedFiles = [{ name: '', source: '' }, ...scripts].map(({ name, source }) => ({
+    name,
+    path: examplePathTemplate(name),
+    content: exampleTemplate.render(exampleTemplateParams(name, source)).toString(),
+  }));
+  const exampleScriptedFilesQueryable = Queryable.from('example', exampleScriptedFiles);
+
+  const commandQueryable = Queryable.from('command', commandsValidated);
+  const testsCollected = testsValidated.flatMap(test => {
+    return test.target.at.map(({ key }) =>
+      collectTestData({
+        test,
+        command: commandQueryable.where({
+          testId: test.testId,
+          target: { at: { key } },
+        }),
+        reference: referenceQueryable,
+        example: exampleScriptedFilesQueryable,
+        key: keyQueryable,
+        modeInstructionTemplate: MODE_INSTRUCTION_TEMPLATES_QUERYABLE,
+      })
+    );
+  });
+
+  const files = [
+    ...createScriptFiles(scripts, testPlanBuildDirectory),
+    ...exampleScriptedFiles.map(({ path: pathSuffix, content }) => ({
+      path: path.join('build', 'tests', path.basename(directory), pathSuffix),
+      content,
+    })),
+    ...testsCollected.map(collectedTest =>
+      createCollectedTestFile(collectedTest, testPlanBuildDirectory)
+    ),
+    ...testsCollected.map(collectedTest =>
+      createCollectedTestHtmlFile(collectedTest, testPlanBuildDirectory)
+    ),
+  ];
+  files.forEach(file => {
+    generateSourceHtmlScriptFile(file.path, file.content);
+    return emitFile(file.path, file.content);
+  });
+
+  if (checkedSourceHtmlScriptFiles.length) {
+    const sourceFolder = checkedSourceHtmlScriptFiles[0]
+      .split(path.sep)
+      .slice(0, -1)
+      .join(path.sep);
+    fse.readdirSync(sourceFolder).forEach(function (file) {
+      const filePath = path.join(sourceFolder, file);
+      // check that test plan's reference html file path is generated file
+      if (file.includes('.html') && (file.split(path.sep).pop().match(/\./g) || []).length > 1) {
+        // remove generated html files from source which include scripts which are no longer generated
+        if (!checkedSourceHtmlScriptFiles.includes(filePath)) {
+          fse.rmSync(path.join(sourceFolder, file));
+        }
+      }
+    });
+  }
+
+  const atCommandsMap = createCommandTuplesATModeTaskLookup(commandsValidated);
+  emitFile(
+    path.join(testPlanBuildDirectory, 'commands.json'),
+    beautify(atCommandsMap, null, 2, 40)
+  );
+
+  log('Creating the following test files: ');
+  tests.forEach(function (test) {
+    try {
+      const [url, applies_to_at] = createTestFile(test, refs, atCommandsMap, {
+        addTestError,
+        emitFile,
+        scriptsRecord,
+        exampleScriptedFilesQueryable,
+      });
+
+      indexOfURLs.push({
+        id: test.testId,
+        title: test.title,
+        href: url,
+        script: test.setupScript,
+        applies_to_at: applies_to_at,
+      });
+
+      log('[Test ' + test.testId + ']: ' + url);
+    } catch (err) {
+      log.warning(err);
+    }
+  });
+
+  createIndexFile(indexOfURLs, {
+    emitFile,
+  });
+
+  const existingBuild = await existingBuildPromise;
+  if (!existingBuild.isDirectory()) {
+    log.error(`The destination 'build' directory does not exist.`);
+  }
+
+  const buildChanges = newBuild.changesAfter(existingBuild);
+
+  if (!VALIDATE_CHECK) {
+    await buildChanges.commit(buildDirectory);
+  }
+
+  if (errorCount) {
+    log.warning(
+      `*** ${errorCount} Errors in tests and/or commands in test plan [${directory}] ***`
+    );
+    log.warning(errors);
+  } else {
+    log('No validation errors detected\n');
+  }
+
+  return { isSuccessfulRun: errorCount === 0, suppressedMessages };
+};
+
+exports.processTestDirectory = processTestDirectory;
+
+/**
+ * @param {FileRecord.Record} record
+ * @returns {Promise<string[][]>}
+ */
+function readCSV(record) {
+  const rows = [];
+  return new Promise(resolve => {
+    Readable.from(record.buffer)
+      .pipe(
+        csv({
+          mapHeaders: ({ header, index }) => {
+            if (header.toLowerCase().includes('\ufeff'))
+              console.error(
+                `Unwanted U+FEFF found for key ${header} at index ${index} while processing CSV.`
+              );
+            return header.replace(/^\uFEFF/g, '');
+          },
+          mapValues: ({ header, value }) => {
+            if (value.toLowerCase().includes('\ufeff'))
+              console.error(
+                `Unwanted U+FEFF found for value in key, value pair (${header}: ${value}) while processing CSV.`
+              );
+            return value.replace(/^\uFEFF/g, '');
+          },
+        })
+      )
+      .on('data', row => {
+        rows.push(row);
+      })
+      .on('end', () => {
+        resolve(rows);
+      });
+  });
+}
+
+/**
+ * @param {FileRecordChain} testPlanJS
+ * @returns {AriaATParsed.ScriptSource[]}
+ */
+function loadScripts(testPlanJS) {
+  return testPlanJS.filter({ glob: ',*.js' }).entries.map(({ name: fileName, text: source }) => {
+    const name = path.basename(fileName, '.js');
+    const modulePath = path.posix.join('scripts', `${name}.module.js`);
+    const jsonpPath = path.posix.join('scripts', `${name}.jsonp.js`);
+
+    /** @type {AriaATFile.ScriptSource} */
+    return {
+      name,
+      source,
+      modulePath,
+      jsonpPath,
+    };
+  });
+}
+
+/**
+ * @param {AriaATFile.ScriptSource[]} scripts
+ * @param {string} testPlanBuildDirectory
+ * @returns {{path: string, content: Uint8Array}[]}
+ */
+function createScriptFiles(scripts, testPlanBuildDirectory) {
+  const jsonpFunction = 'scriptsJsonpLoaded';
+
+  return [
+    ...scripts.reduce((files, script) => {
+      const { modulePath, jsonpPath } = script;
+      const oneScript = [script];
+
+      return [...files, ...renderFileVariants(oneScript, modulePath, jsonpPath)];
+    }, []),
+    ...renderFileVariants(scripts, 'scripts.module.js', 'scripts.jsonp.js'),
+  ];
+
+  function renderFileVariants(scripts, modulePath, jsonpPath) {
+    return [
+      {
+        path: path.join(testPlanBuildDirectory, modulePath),
+        content: encodeText(renderModule(scripts).toString()),
+      },
+      {
+        path: path.join(testPlanBuildDirectory, jsonpPath),
+        content: encodeText(renderJsonp(scripts).toString()),
+      },
+    ];
+  }
+
+  function renderJsonp(scripts) {
+    return reindent`window[document.currentScript.getAttribute("jsonpFunction") || "${jsonpFunction}"]({
+  ${scripts.map(renderJsonpExport).join(',\n')}
+});
+`;
+  }
+
+  function renderJsonpExport({ name, source }) {
+    return reindent`${name}(testPageDocument) {
+  ${source.trim()}
+}`;
+  }
+
+  function renderModule(scripts) {
+    return reindent`${scripts.map(renderModuleExport).join('\n\n')}
+`;
+  }
+
+  function renderModuleExport({ name, source }) {
+    return reindent`export function ${name}(testPageDocument) {
+  ${source.trim()}
+}`;
+  }
+}
+
+/**
+ * @param {Object<string, string>} keyLines
+ * @returns {AriaATParsed.KeyMap}
+ */
+function parseKeyMap(keyDefs) {
+  const keyMap = {};
+  for (const id in keyDefs) {
+    keyMap[id] = { id, keystroke: keyDefs[id] };
+  }
+  return keyMap;
+}
+
+/**
+ * @param {AriaATCSV.Reference[]} referenceRows
+ * @returns {AriaATParsed.ReferenceMap}
+ */
+function parseReferencesCSV(referenceRows) {
+  const refMap = {};
+  for (const { refId, value } of referenceRows) {
+    refMap[refId] = { refId, value: value.trim() };
+  }
+  return refMap;
+}
+
+/**
+ * @param {AriaATParsed.Command} commandParsed
+ * @param {object} data
+ * @param {Queryable<AriaATParsed.Key>} data.key
+ * @param {object} data.support
+ * @param {Queryable<{key: string, name: string}>} data.support.at
+ * @param {object} [options]
+ * @param {function(AriaATParsed.Command, string): void} [options.addCommandError]
+ * @returns {AriaATValidated.Command}
+ */
+function validateCommand(commandParsed, data, { addCommandError = () => {} } = {}) {
+  return {
+    ...commandParsed,
+    target: {
+      ...commandParsed.target,
+      at: {
+        ...commandParsed.target.at,
+        ...mapDefined(data.support.at.where({ key: commandParsed.target.at.key }), ({ name }) => ({
+          name,
+        })),
+      },
+    },
+    commands: commandParsed.commands.map(({ id, keypresses: commandKeypresses, ...rest }) => {
+      const keypresses = commandKeypresses.map(keypress => {
+        const key = data.key.where(keypress);
+        if (!key) {
+          addCommandError(commandParsed, keypress.id);
+        }
+        return key || {};
+      });
+      return {
+        id: id,
+        keystroke: keypresses.map(({ keystroke }) => keystroke).join(', then '),
+        keypresses,
+        ...rest,
+      };
+    }),
+  };
+}
+
+/**
+ * @param {AriaATParsed.KeyMap} keyMap
+ */
+function validateKeyMap(keyMap, { addKeyMapError }) {
+  if (!keyMap.ALT_DELETE) {
+    addKeyMapError(`ALT_DELETE is not defined in keys module.`);
+  }
+  if (!keyMap.INS_Z) {
+    addKeyMapError(`INS_Z is not defined in keys module.`);
+  }
+  if (!keyMap.ESC) {
+    addKeyMapError(`ESC is not defined in keys module.`);
+  }
+  if (!keyMap.INS_SPACE) {
+    addKeyMapError(`INS_SPACE is not defined in keys module.`);
+  }
+  if (!keyMap.LEFT) {
+    addKeyMapError(`LEFT is not defined in keys module.`);
+  }
+  if (!keyMap.RIGHT) {
+    addKeyMapError(`RIGHT is not defined in keys module.`);
+  }
+  return keyMap;
+}
+
+const MODE_INSTRUCTION_TEMPLATES_QUERYABLE = Queryable.from('modeInstructionTemplate', [
+  {
+    at: 'jaws',
+    mode: 'reading',
+    render: data => {
+      const altDelete = data.key.where({ id: 'ALT_DELETE' });
+      const esc = data.key.where({ id: 'ESC' });
+      return `Verify the Virtual Cursor is active by pressing ${altDelete.keystroke}. If it is not, exit Forms Mode to activate the Virtual Cursor by pressing ${esc.keystroke}.`;
+    },
+  },
+  {
+    at: 'jaws',
+    mode: 'interaction',
+    render: data => {
+      const altDelete = data.key.where({ id: 'ALT_DELETE' });
+      const insZ = data.key.where({ id: 'INS_Z' });
+      return `Verify the PC Cursor is active by pressing ${altDelete.keystroke}. If it is not, turn off the Virtual Cursor by pressing ${insZ.keystroke}.`;
+    },
+  },
+  {
+    at: 'nvda',
+    mode: 'reading',
+    render: data => {
+      const esc = data.key.where({ id: 'ESC' });
+      return `Ensure NVDA is in browse mode by pressing ${esc.keystroke}. Note: This command has no effect if NVDA is already in browse mode.`;
+    },
+  },
+  {
+    at: 'nvda',
+    mode: 'interaction',
+    render: data => {
+      const insSpace = data.key.where({ id: 'INS_SPACE' });
+      return `If NVDA did not make the focus mode sound when the test page loaded, press ${insSpace.keystroke} to turn focus mode on.`;
+    },
+  },
+  {
+    at: 'voiceover_macos',
+    mode: 'reading',
+    render: data => {
+      const left = data.key.where({ id: 'LEFT' });
+      const right = data.key.where({ id: 'RIGHT' });
+      return `Toggle Quick Nav ON by pressing the ${left.keystroke} and ${right.keystroke} keys at the same time.`;
+    },
+  },
+  {
+    at: 'voiceover_macos',
+    mode: 'interaction',
+    render: data => {
+      const left = data.key.where({ id: 'LEFT' });
+      const right = data.key.where({ id: 'RIGHT' });
+      return `Toggle Quick Nav OFF by pressing the ${left.keystroke} and ${right.keystroke} keys at the same time.`;
+    },
+  },
+]);
+
+/**
+ * @param {T} maybeDefined
+ * @param {function(T): U} goal
+ * @returns {T}
+ * @template T
+ * @template {T} U
+ */
+function mapDefined(maybeDefined, goal) {
+  if (maybeDefined) {
+    return goal(maybeDefined);
+  }
+  return maybeDefined;
+}
+
+/**
+ * @param {AriaATParsed.Test} testParsed
+ * @param {object} data
+ * @param {Queryable<AriaATParsed.Command>} data.command
+ * @param {Queryable<AriaATParsed.Key>} data.key
+ * @param {Queryable<string>} data.mode
+ * @param {Queryable<AriaATParsed.Reference>} data.reference
+ * @param {Queryable<AriaATParsed.ScriptSource>} data.script
+ * @param {object} data.support
+ * @param {Queryable<{key: string, name: string}>} data.support.at
+ * @param {Queryable<{key: string, name: string}>} data.support.atGroup
+ * @param {object} [options]
+ * @param {function(string): void} [options.addTestError]
+ * @returns {AriaATValidated.Test}
+ */
+function validateTest(testParsed, data, { addTestError = () => {} } = {}) {
+  if (!data.command.where({ task: testParsed.task })) {
+    addTestError(`"${testParsed.task}" does not exist in commands.csv file.`);
+  }
+
+  testParsed.target.at.forEach(at => {
+    if (!data.support.atGroup.where({ key: at.key })) {
+      addTestError(`"${at.key}" is not valid value for "appliesTo" property.`);
+    }
+
+    if (
+      !data.command.where({
+        task: testParsed.task,
+        target: {
+          at: { key: at.key },
+          mode: testParsed.target.mode,
+        },
+      })
+    ) {
+      addTestError(
+        `command is missing for the combination of task: "${testParsed.task}", mode: "${testParsed.target.mode}", and AT: "${at.key}"`
+      );
+    }
+  });
+
+  if (!data.mode.where(testParsed.target.mode)) {
+    addTestError(`"${testParsed.target.mode}" is not valid value for "mode" property.`);
+  }
+
+  const references = testParsed.references.filter(({ refId }) => {
+    if (!data.reference.where({ refId })) {
+      addTestError(`Reference does not exist: ${refId}`);
+      return false;
+    }
+    return true;
+  });
+
+  if (testParsed.setupScript && !data.script.where({ name: testParsed.setupScript.name })) {
+    addTestError(
+      `Setup script does not exist: "${testParsed.setupScript.name}" for task "${testParsed.task}"`
+    );
+  }
+
+  const assertions = testParsed.assertions.map(assertion => {
+    if (
+      typeof assertion.priority === 'string' ||
+      (assertion.priority !== 1 && assertion.priority !== 2)
+    ) {
+      addTestError(
+        `Level value must be 1 or 2, value found was "${assertion.priority}" for assertion "${assertion.expectation}" (NOTE: level 2 defined for this assertion).`
+      );
+      return {
+        priority: 2,
+        expectation: assertion.expectation,
+      };
+    }
+    return assertion;
+  });
+
+  return {
+    ...testParsed,
+    references: [
+      ...[data.reference.where({ refId: 'example' })].filter(Boolean),
+      ...references,
+    ].map(ref => ({
+      ...ref,
+      ...data.reference.where({ refId: ref.refId }),
+    })),
+    target: {
+      at: testParsed.target.at.map(at => ({
+        ...at,
+        ...mapDefined(data.support.at.where({ key: at.key }), ({ name }) => ({
+          name,
+        })),
+      })),
+      mode: testParsed.target.mode,
+    },
+    setupScript:
+      testParsed.setupScript && data.script.where({ name: testParsed.setupScript.name })
+        ? {
+            ...testParsed.setupScript,
+            ...data.script.where({ name: testParsed.setupScript.name }),
+          }
+        : undefined,
+    assertions,
+  };
+}
+
+/**
+ * @param {object} data
+ * @param {AriaATValidated.Test} data.test
+ * @param {AriaATValidated.Command} data.command
+ * @param {Queryable<AriaATParsed.Key>} data.key
+ * @param {Queryable<{name: string, path: string}>} data.example
+ * @param {Queryable<{at: string, mode: string, render: function({key: *}): string}>} data.modeInstructionTemplate
+ * @returns {AriaATFile.CollectedTest}
+ */
+function collectTestData({ test, command, key, example, modeInstructionTemplate }) {
+  return {
+    info: {
+      testId: test.testId,
+      task: test.task,
+      title: test.title,
+      references: test.references,
+    },
+    target: {
+      ...test.target,
+      at: command.target.at,
+      referencePage: example.where({ name: test.setupScript ? test.setupScript.name : '' }).path,
+      setupScript: test.setupScript,
+    },
+    instructions: {
+      ...test.instructions,
+      mode: modeInstructionTemplate
+        .where({
+          at: command.target.at.key,
+          mode: command.target.mode,
+        })
+        .render({ key }),
+    },
+    commands: command.commands,
+    assertions: test.assertions,
+  };
+}
+
+function encodeText(text) {
+  if (typeof TextEncoder !== 'undefined') {
+    return new TextEncoder().encode(text);
+  }
+  return new Uint8Array(Buffer.from(text).arrayBuffer);
+}
+
+/**
+ * @param {AriaATFile.CollectedTest} test
+ */
+function createCollectedTestFile(test, testPlanBuildDirectory) {
+  return {
+    path: path.join(
+      testPlanBuildDirectory,
+      `test-${test.info.testId.toString().padStart(2, '0')}-${test.info.task.replace(
+        /\s+/g,
+        '-'
+      )}-${test.target.mode}-${test.target.at.key}.collected.json`
+    ),
+    content: encodeText(beautify(test, null, 2, 40)),
+  };
+}
+
+/**
+ * @param {AriaATFile.CollectedTest} test
+ * @param {string} testPlanBuildDirectory
+ * @returns {{path: string, content: Uint8Array}}
+ */
+function createCollectedTestHtmlFile(test, testPlanBuildDirectory) {
+  const testJsonFileName = `test-${test.info.testId
+    .toString()
+    .padStart(2, '0')}-${test.info.task.replace(/\s+/g, '-')}-${test.target.mode}-${
+    test.target.at.key
+  }.collected.json`;
+  return {
+    path: path.join(
+      testPlanBuildDirectory,
+      `test-${test.info.testId.toString().padStart(2, '0')}-${test.info.task.replace(
+        /\s+/g,
+        '-'
+      )}-${test.target.mode}-${test.target.at.key}.collected.html`
+    ),
+    content: encodeText(renderCollectedTestHtml(test, testJsonFileName)),
+  };
+}
+
+function toBuffer(content) {
+  if (Buffer.isBuffer(content) || isArrayBufferView(content) || isArrayBuffer(content)) {
+    return content;
+  } else if (typeof content === 'string') {
+    return Buffer.from(content);
+  }
+  return Buffer.from(content.toString());
+}
+
+function exampleTemplateParams(name, source) {
+  return {
+    script: reindent`
+<!-- Generated by process-test-directory.js -->
+<script>
+  (function() {
+    function setupScript(testPageDocument) {
+      // ${name}
+      ${source}
+    };
+    document.addEventListener('click', function(event) {
+      if (event.target.classList.contains('button-run-test-setup')) {
+        event.target.disabled = true;
+        setupScript(document);
+      }
+    });
+  })();
+</script>
+<!-- End of generated output -->`,
+    button: reindent`
+<!-- Generated by process-test-directory.js -->
+<div style="position: relative; left: 0; right: 0; height: 2rem;">
+  <button class="button-run-test-setup" autofocus style="height: 100%; width: 100%;"${
+    source ? '' : ' disabled'
+  }>Run Test Setup</button>
+</div>
+<!-- End of generated output -->`,
+  };
+}
diff --git a/lib/data/process-test-directory.js b/lib/data/process-test-directory.js
index 9e3d76110..d27079037 100644
--- a/lib/data/process-test-directory.js
+++ b/lib/data/process-test-directory.js
@@ -22,9 +22,11 @@ const { Queryable } = require('../util/queryable');
 const { FileRecordChain } = require('../util/file-record-chain');
 
 const { parseSupport } = require('./parse-support');
-const { parseTestCSVRow } = require('./parse-test-csv-row');
-const { parseCommandCSVRow } = require('./parse-command-csv-row');
-const { createCommandTuplesATModeTaskLookup } = require('./command-tuples-at-mode-task-lookup');
+const { parseTestCSVRowV2 } = require('./parse-test-csv-row');
+const { parseCommandCSVRowV2, flattenObject } = require('./parse-command-csv-row');
+const {
+  createAtCommandTuplesATSettingsTestIdLookupByPresentationNumber,
+} = require('./command-tuples-at-mode-task-lookup');
 
 const { renderHTML: renderCollectedTestHtml } = require('./templates/collected-test.html');
 const { createExampleScriptsTemplate } = require('./example-scripts-template');
@@ -34,9 +36,6 @@ const { createExampleScriptsTemplate } = require('./example-scripts-template');
  * @param {object} args={}
  */
 const processTestDirectory = async ({ directory, args = {} }) => {
-  let VERBOSE_CHECK = false;
-  let VALIDATE_CHECK = false;
-
   let suppressedMessages = 0;
 
   /**
@@ -70,10 +69,8 @@ const processTestDirectory = async ({ directory, args = {} }) => {
   };
 
   // setup from arguments passed to npm script
-  VERBOSE_CHECK = !!args.verbose;
-  VALIDATE_CHECK = !!args.validate;
-
-  const validModes = ['reading', 'interaction', 'item'];
+  const VERBOSE_CHECK = !!args.verbose;
+  const VALIDATE_CHECK = !!args.validate;
 
   // cwd; @param rootDirectory is dependent on this file not moving from the `lib/data` folder
   const libDataDirectory = path.dirname(__filename);
@@ -83,11 +80,12 @@ const processTestDirectory = async ({ directory, args = {} }) => {
   const testPlanDirectory = path.join(rootDirectory, directory);
 
   const resourcesDirectory = path.join(testsDirectory, 'resources');
-
-  const supportFilePath = path.join(testsDirectory, 'support.json');
+  const supportJsonFilePath = path.join(testsDirectory, 'support.json');
+  const commandsJsonFilePath = path.join(testsDirectory, 'commands.json');
   const testsCsvFilePath = path.join(testPlanDirectory, 'data', 'tests.csv');
-  const atCommandsCsvFilePath = path.join(testPlanDirectory, 'data', 'commands.csv');
   const referencesCsvFilePath = path.join(testPlanDirectory, 'data', 'references.csv');
+  const assertionsCsvFilePath = path.join(testPlanDirectory, 'data', 'assertions.csv');
+  const scriptsCsvFilePath = path.join(testPlanDirectory, 'data', 'scripts.csv');
 
   // build output folders and file paths setup
   const buildDirectory = path.join(rootDirectory, 'build');
@@ -106,14 +104,16 @@ const processTestDirectory = async ({ directory, args = {} }) => {
       'tests/resources',
       'tests/resources/*',
       'tests/support.json',
+      'tests/commands.json',
     ].join(','),
   });
 
-  const [testPlanRecord, resourcesOriginalRecord, supportRecord] = await Promise.all(
-    [testPlanDirectory, resourcesDirectory, supportFilePath].map(filepath =>
-      FileRecordChain.read(filepath)
-    )
-  );
+  const [testPlanRecord, resourcesOriginalRecord, supportJsonRecord, commandsJsonRecord] =
+    await Promise.all(
+      [testPlanDirectory, resourcesDirectory, supportJsonFilePath, commandsJsonFilePath].map(
+        filepath => FileRecordChain.read(filepath)
+      )
+    );
 
   const scriptsRecord = testPlanRecord.find('data/js');
   const resourcesRecord = resourcesOriginalRecord.filter({ glob: '{aria-at-*,keys,vrender}.mjs' });
@@ -128,19 +128,33 @@ const processTestDirectory = async ({ directory, args = {} }) => {
             entries: testPlanRecord.filter({ glob: 'reference{,/**}' }).record.entries,
           },
           { name: 'resources', ...resourcesRecord.record },
-          { name: 'support.json', ...supportRecord.record },
+          { name: 'support.json', ...supportJsonRecord.record },
+          { name: 'commands.json', ...commandsJsonRecord.record },
         ],
       },
     ],
   });
 
-  const keyDefs = {};
-  const support = JSON.parse(supportRecord.text);
+  const supportJson = JSON.parse(supportJsonRecord.text);
+  const commandsJson = JSON.parse(commandsJsonRecord.text);
 
-  let allATKeys = support.ats.map(({ key }) => key);
-  let allATNames = support.ats.map(({ name }) => name);
+  const allAts = supportJson.ats;
+  const allAtKeys = allAts.map(({ key }) => key);
+  const allAtNames = allAts.map(({ name }) => name);
+  const atSettings = allAts
+    .map(({ settings }) => settings)
+    .flatMap(setting => Object.keys(setting));
 
-  const validAppliesTo = ['Screen Readers', 'Desktop Screen Readers'].concat(allATKeys);
+  // Get paths to possible at keys
+  const atCommandsCsvFilePaths = getTestPlanDataFilePaths(
+    testPlanDirectory,
+    allAtKeys.map(key => `${key}-commands.csv`)
+  ).map((atCommandCsvFilePath, index) => ({ atKey: allAtKeys[index], atCommandCsvFilePath }));
+
+  // readingMode and interactionMode are known screen reader 'at modes' found in
+  // support.json at ats[].assertionTokens. The specific named modes are
+  // stored in ats[].settings
+  const validModes = ['readingMode', 'interactionMode', 'defaultMode'].concat(atSettings);
 
   if (!testPlanRecord.isDirectory()) {
     log.error(`The test directory '${testPlanDirectory}' does not exist. Check the path to tests.`);
@@ -150,158 +164,285 @@ const processTestDirectory = async ({ directory, args = {} }) => {
     log.error(`The tests.csv file does not exist. Please create '${testsCsvFilePath}' file.`);
   }
 
-  if (!testPlanRecord.find('data/commands.csv').isFile()) {
+  if (!testPlanRecord.find('data/references.csv').isFile()) {
     log.error(
-      `The at-commands.csv file does not exist. Please create '${atCommandsCsvFilePath}' file.`
+      `The references.csv file does not exist. Please create '${referencesCsvFilePath}' file.`
     );
   }
 
-  if (!testPlanRecord.find('data/references.csv').isFile()) {
+  if (!testPlanRecord.find('data/assertions.csv').isFile()) {
     log.error(
-      `The references.csv file does not exist. Please create '${referencesCsvFilePath}' file.`
+      `The assertions.csv file does not exist. Please create '${assertionsCsvFilePath}' file.`
     );
   }
 
-  // get Keys that are defined
-  try {
-    // read contents of the file
-    const keys = resourcesRecord.find('keys.mjs').text;
+  if (!testPlanRecord.find('data/scripts.csv').isFile()) {
+    log.error(`The scripts.csv file does not exist. Please create '${scriptsCsvFilePath}' file.`);
+  }
+
+  let someAtCommandsCsvExist = false;
+  let missingAtCommandsCsvFiles = [];
+  for (const atCommandCsvFilePath of atCommandsCsvFilePaths) {
+    const { atKey, atCommandCsvFilePath: filePath } = atCommandCsvFilePath;
 
-    // split the contents by new line
-    const lines = keys.split(/\r?\n/);
+    // Checks that at least one {at}-commands.csv exists
+    if (testPlanRecord.find(`data/${atKey}-commands.csv`).isFile()) someAtCommandsCsvExist = true;
+    else missingAtCommandsCsvFiles.push(filePath);
+  }
+  if (!someAtCommandsCsvExist) {
+    log.error(
+      `No *-commands.csv files found for ${directory}. Please create at least one of the following: ${missingAtCommandsCsvFiles.join(
+        ', '
+      )}`
+    );
+  }
 
-    // print all lines
-    lines.forEach(line => {
-      let parts1 = line.split(' ');
-      let parts2 = line.split('"');
+  /**
+   * @param {AriaATCSV.Reference} row
+   * @returns {AriaATCSV.Reference}
+   */
+  function validateReferencesKeys(row) {
+    if (
+      typeof row.refId !== 'string' ||
+      typeof row.type !== 'string' ||
+      typeof row.value !== 'string'
+    ) {
+      throw new Error('Row missing refId, type or value');
+    }
+    return row;
+  }
 
-      if (parts1.length > 3) {
-        let code = parts1[2].trim();
-        keyDefs[code] = parts2[1].trim();
+  const validCommandKeys = /^(?:testId|command|settings|assertionExceptions|presentationNumber)$/;
+  const numericKeyFormat = /^_(\d+)$/;
+  const idFormat = /^[A-Za-z0-9-]+$/;
+  const assertionsExceptionsFormat = /^([0123]:[a-zA-Z-]+\s*)+$/;
+  const settingsFormat = /^[A-Za-z0-9-\s]+$/;
+  function validateCommandsKeys(row) {
+    // example header:
+    // testId,command,settings,assertionExceptions,presentationNumber
+    for (const key of Object.keys(row)) {
+      if (numericKeyFormat.test(key)) {
+        throw new Error(`Column found without header row, ${+key.substring(1) + 1}`);
+      } else if (!validCommandKeys.test(key)) {
+        throw new Error(`Unknown *-commands.csv key: ${key} - check header row?`);
       }
-    });
-  } catch (err) {
-    log.warning(err);
+    }
+    if (!(row.testId?.length && row.command?.length && row.presentationNumber?.length)) {
+      throw new Error('Missing one of required testId, command, presentationNumber');
+    }
+    if (!idFormat.test(row.testId))
+      throw new Error('testId does not match the expected format: ' + row.testId);
+    if (row.settings && !settingsFormat.test(row.settings))
+      throw new Error('settings does not match the expected format: ' + row.settings);
+    if (row.assertionExceptions && !assertionsExceptionsFormat.test(row.assertionExceptions))
+      throw new Error(
+        'assertionExceptions does not match the expectedFormat: ' + row.assertionExceptions
+      );
+    if (!Number(row.presentationNumber) > 0)
+      throw new Error(
+        'presentationNumber does not match the expected format: ' + row.presentationNumber
+      );
+    return row;
   }
 
-  function cleanTask(task) {
-    return task.replace(/'/g, '').replace(/;/g, '').trim().toLowerCase();
+  const validTestsKeys =
+    /^(?:testId|title|presentationNumber|setupScript|instructions|assertions)$/;
+  const titleFormat = /^[A-Z]([A-Za-z-',\s]){2,}[^.]$/;
+  function validateTestsKeys(row) {
+    // example header:
+    // testId,title,presentationNumber,setupScript,instructions,assertions
+    for (const key of Object.keys(row)) {
+      if (numericKeyFormat.test(key)) {
+        throw new Error(`Column found without header row, ${+key.substring(1) + 1}`);
+      } else if (!validTestsKeys.test(key)) {
+        throw new Error(`Unknown tests.csv key: ${key} - check header row?`);
+      }
+    }
+    if (
+      !(
+        row.testId?.length &&
+        row.title?.length &&
+        row.presentationNumber?.length &&
+        row.instructions?.length &&
+        row.assertions?.length
+      )
+    ) {
+      throw new Error(
+        'Missing one of required testId, title, presentationNumber, instructions, assertions'
+      );
+    }
+    if (!idFormat.test(row.testId))
+      throw new Error('testId does not match the expected format: ' + row.testId);
+    if (!titleFormat.test(row.title))
+      throw new Error('title does not match the expected format: ' + row.title);
+    if (!Number(row.presentationNumber) > 0)
+      throw new Error(
+        'presentationNumber does not match the expected format: ' + row.presentationNumber
+      );
+    return row;
+  }
+
+  const validAssertionsKeys =
+    /^(?:assertionId|priority|assertionStatement|assertionPhrase|refIds)$/;
+  const priorityFormat = /^[123]$/;
+  // TODO: The make-v2 script isn't removing the punctuations at the end which violates the requirements of this
+  //  column's validation. Based on https://github.com/w3c/aria-at/wiki/Test-Format-Definition-V2#assertionstatement
+  //  Please ensure they are removing and use the commented regex instead.
+  const assertionStatementFormat = /^[A-Z].*[a-zA-Z'{}().](?![.!?])$/;
+  // const assertionStatementFormat = /^[A-Z].*[a-zA-Z'{}()](?![.!?])$/;
+
+  // TODO: Same as TODO above. Based on https://github.com/w3c/aria-at/wiki/Test-Format-Definition-V2#assertionphrase
+  const assertionPhraseFormat = /^[a-z].*[a-zA-Z'"{}()\d+.](?![.!?])$/;
+  // const assertionPhraseFormat = /^[a-z].*[a-zA-Z'"{}()\d+](?![.!?])$/;
+  function validateAssertionsKeys(row) {
+    // example header:
+    // assertionId,priority,assertionStatement,assertionPhrase,refIds
+    for (const key of Object.keys(row)) {
+      if (numericKeyFormat.test(key)) {
+        throw new Error(`Column found without header row, ${+key.substring(1) + 1}`);
+      } else if (!validAssertionsKeys.test(key)) {
+        throw new Error(`Unknown tests.csv key: ${key} - check header row?`);
+      }
+    }
+    if (
+      !(
+        row.assertionId?.length &&
+        row.priority?.length &&
+        row.assertionStatement?.length &&
+        row.assertionPhrase?.length
+      )
+    ) {
+      throw new Error(
+        'Missing one of required assertionId, priority, assertionStatement, assertionPhrase'
+      );
+    }
+    if (!idFormat.test(row.assertionId))
+      throw new Error('assertionId does not match the expected format: ' + row.assertionId);
+    if (!priorityFormat.test(row.priority))
+      throw new Error('priority does not match the expected format: ' + row.priority);
+    if (!assertionStatementFormat.test(row.assertionStatement))
+      throw new Error(
+        'assertionStatement does not match the expected format: ' + row.assertionStatement
+      );
+    if (!assertionPhraseFormat.test(row.assertionPhrase))
+      throw new Error('assertionPhrase does not match the expected format: ' + row.assertionPhrase);
+    return row;
+  }
+
+  const validScriptsKeys = /^(?:setupScript|setupScriptDescription)$/;
+  const setupScriptDescriptionFormat = /^[a-z].*[a-zA-Z'](?![.!?])$/;
+  function validateScriptsKeys(row) {
+    // example header:
+    // setupScript,setupScriptDescription
+    for (const key of Object.keys(row)) {
+      if (numericKeyFormat.test(key)) {
+        throw new Error(`Column found without header row, ${+key.substring(1) + 1}`);
+      } else if (!validScriptsKeys.test(key)) {
+        throw new Error(`Unknown tests.csv key: ${key} - check header row?`);
+      }
+    }
+    if (!(row.setupScript?.length && row.setupScriptDescription?.length)) {
+      throw new Error('Missing one of required setupScript, setupScriptDescription');
+    }
+    if (!setupScriptDescriptionFormat.test(row.setupScriptDescription))
+      throw new Error(
+        'setupScriptDescription does not match the expected format: ' + row.setupScriptDescription
+      );
+    return row;
+  }
+
+  const [referencesCsv, testsCsv, assertionsCsv, scriptsCsv, ...atCommandsCsvs] = await Promise.all(
+    [
+      readCSVFile('data/references.csv', validateReferencesKeys),
+      readCSVFile('data/tests.csv', validateTestsKeys),
+      readCSVFile('data/assertions.csv', validateAssertionsKeys),
+      readCSVFile('data/scripts.csv', validateScriptsKeys),
+      ...atCommandsCsvFilePaths.map(({ atKey }) =>
+        readCSVFile(`data/${atKey}-commands.csv`, validateCommandsKeys)
+      ),
+    ]
+  );
+
+  // Works because the order of allAtKeys and atCommandsCsvs should be maintained up this point
+  const parsedAtCommandsCsvs = allAtKeys.map((atKey, index) => ({
+    atKey,
+    commands: atCommandsCsvs[index],
+  }));
+
+  const testsParsed = parseTestCSVRowV2({
+    tests: testsCsv,
+    assertions: assertionsCsv,
+    scripts: scriptsCsv,
+    commands: parsedAtCommandsCsvs,
+  });
+
+  /**
+   *
+   * @param {string} root
+   * @param {string[]} fileNames
+   * @return {array[string]}
+   */
+  function getTestPlanDataFilePaths(root, fileNames = []) {
+    let filePaths = [];
+
+    for (const fileName of fileNames) {
+      const filePath = path.join(testPlanDirectory, 'data', fileName);
+      filePaths.push(filePath);
+    }
+
+    return filePaths;
   }
 
   /**
    * Create Test File
    * @param {AriaATCSV.Test} test
-   * @param refs
-   * @param commands
+   * @param {Object<string, Object<type, value, linkText>>} refs
+   * @param {Object<string, Object<string, Object<string, [[string]]>>>} atCommandsMap
+   * @param {object} options
+   * @param {function(string, string)} options.addTestError
+   * @param {function(filePath: string, content: any, encoding: string)} options.emitFile
+   * @param {FileRecordChain} options.scriptsRecord
+   * @param {Queryable<T>} options.exampleScriptedFilesQueryable
    * @returns {(string|*[])[]}
    */
   function createTestFile(
     test,
     refs,
-    commands,
+    atCommandsMap,
     { addTestError, emitFile, scriptsRecord, exampleScriptedFilesQueryable }
   ) {
     let scripts = [];
 
     // default setupScript if test has undefined setupScript
-    if (!scriptsRecord.find(`${test.setupScript}.js`).isFile()) test.setupScript = '';
-
-    function getModeValue(value) {
-      let v = value.trim().toLowerCase();
-      if (!validModes.includes(v)) {
-        addTestError(test.testId, '"' + value + '" is not valid value for "mode" property.');
-      }
-      return v;
-    }
-
-    function getTask(t) {
-      let task = cleanTask(t);
-
-      if (typeof commands[task] !== 'object') {
-        addTestError(test.testId, '"' + task + '" does not exist in commands.csv file.');
-      }
-
-      return task;
-    }
+    if (!scriptsRecord.find(`${test.setupScript?.script}.js`).isFile())
+      test.setupScript = {
+        ...test.setupScript,
+        script: '',
+      };
 
-    function getAppliesToValues(values) {
-      function checkValue(value) {
-        let v1 = value.trim().toLowerCase();
-        for (let i = 0; i < validAppliesTo.length; i++) {
-          let v2 = validAppliesTo[i];
-          if (v1 === v2.toLowerCase()) {
-            return v2;
-          }
-        }
-        return false;
+    function getTestId(testId) {
+      if (typeof atCommandsMap[testId] !== 'object') {
+        addTestError(test.testId, '"' + testId + '" does not exist in *-commands.csv file.');
       }
-
-      // check for individual assistive technologies
-      let items = values.split(',');
-      let newValues = [];
-      items.filter(item => {
-        let value = checkValue(item);
-        if (!value) {
-          addTestError(test.testId, '"' + item + '" is not valid value for "appliesTo" property.');
-        }
-
-        newValues.push(value);
-      });
-
-      return newValues;
+      return testId;
     }
 
-    /**
-     * Determines priority level (default is 1) of assertion string, then adds it to the collection of assertions for
-     * the test plan
-     * @param {string} a - Assertion string to be evaluated
-     */
-    function addAssertion(a) {
-      let level = '1';
-      let str = a;
-      a = a.trim();
-
-      // matches a 'colon' when preceded by either of the digits 1 OR 2 (SINGLE CHARACTER), at the start of the string
-      let parts = a.split(/(?<=^[1-2]):/g);
-
-      if (parts.length === 2) {
-        level = parts[0];
-        str = parts[1].substring(0);
-        if (level !== '1' && level !== '2') {
-          addTestError(
-            test.testId,
-            "Level value must be 1 or 2, value found was '" +
-              level +
-              "' for assertion '" +
-              str +
-              "' (NOTE: level 2 defined for this assertion)."
-          );
-          level = '2';
-        }
-      }
-
-      if (a.length) {
-        assertions.push([level, str]);
+    function getModeValue({ settings }) {
+      let v = settings.trim();
+      if (!validModes.includes(v)) {
+        addTestError(test.testId, '"' + settings + '" is not valid value for "settings" property.');
       }
+      return v;
     }
 
-    function getReferences(example, testRefs) {
+    function getReferences(test, refs) {
       let links = '';
 
-      if (typeof example === 'string' && example.length) {
-        links += `<link rel="help" href="${refs.example}">\n`;
-      }
+      test.references.forEach(({ refId }) => {
+        const { value: link, linkText } = refs[refId];
 
-      let items = test.refs.split(' ');
-      items.forEach(function (item) {
-        item = item.trim();
-
-        if (item.length) {
-          if (typeof refs[item] === 'string') {
-            links += `<link rel="help" href="${refs[item]}">\n`;
-          } else {
-            addTestError(test.testId, 'Reference does not exist: ' + item);
-          }
+        if (typeof link === 'string' && link.length) {
+          links += `<link rel="help" href="${link}" title="${linkText}">\n`;
         }
       });
 
@@ -345,65 +486,51 @@ const processTestDirectory = async ({ directory, args = {} }) => {
     }
 
     function getScripts() {
-      let js = 'var scripts = {\n';
+      let js = 'let scripts = {\n';
       js += scripts.join(',\n');
       js += '\n\t};';
       return js;
     }
 
-    let task = getTask(test.task);
-    let appliesTo = getAppliesToValues(test.appliesTo);
-    let mode = getModeValue(test.mode);
+    let testId = getTestId(test.testId);
+    let modes = test.target.ats.map(getModeValue).join('_');
 
-    appliesTo.forEach(at => {
-      if (commands[task]) {
-        if (!commands[task][mode][at.toLowerCase()]) {
+    test.target.ats.forEach(at => {
+      if (atCommandsMap[testId]) {
+        if (!atCommandsMap[testId][at.settings][at.key]) {
           addTestError(
-            test.testId,
+            testId,
             'command is missing for the combination of task: "' +
-              task +
+              testId +
               '", mode: "' +
-              mode +
+              atCommandsMap[testId][at.settings] +
               '", and AT: "' +
-              at.toLowerCase() +
+              at.key.toLowerCase() +
               '" '
           );
         }
       }
     });
 
-    let assertions = [];
-    let id = test.testId;
-    if (parseInt(test.testId) < 10) {
-      id = '0' + id;
-    }
-
-    const cleanTaskName = cleanTask(test.task).replace(/\s+/g, '-');
-    let testFileName = `test-${id}-${cleanTaskName}-${mode}.html`;
-    let testJSONFileName = `test-${id}-${cleanTaskName}-${mode}.json`;
-
-    let testPlanHtmlFileBuildPath = path.join(testPlanBuildDirectory, testFileName);
-    let testPlanJsonFileBuildPath = path.join(testPlanBuildDirectory, testJSONFileName);
+    // testId and test level presentationNumber should be enough of a descriptor to differentiate the values
+    let testFileName = `test-${test.presentationNumber.toString().padStart(2, '0')}-${testId}`;
+    let testPlanHtmlFileBuildPath = path.join(testPlanBuildDirectory, `${testFileName}.html`);
+    let testPlanJsonFileBuildPath = path.join(testPlanBuildDirectory, `${testFileName}.json`);
 
-    let references = getReferences(refs.example, test.refs);
-    addSetupScript(test.setupScript);
-
-    for (let i = 1; i < 31; i++) {
-      if (!test['assertion' + i]) {
-        continue;
-      }
-      addAssertion(test['assertion' + i]);
-    }
+    let exampleReferences = getReferences(test, refs);
+    addSetupScript(test.setupScript.script);
 
     /** @type {AriaATFile.Behavior} */
     let testData = {
-      setup_script_description: getSetupScriptDescription(test.setupScriptDescription),
-      setupTestPage: test.setupScript,
-      applies_to: appliesTo,
-      mode: mode,
-      task: task,
+      task: testId,
+      mode: modes,
+      applies_to: [...new Set(test.target.ats.map(({ key }) => key))],
+      setup_script_description: getSetupScriptDescription(test.setupScript.scriptDescription),
+      setupTestPage: test.setupScript.script,
       specific_user_instruction: test.instructions,
-      output_assertions: assertions,
+      assertionResponseQuestion: supportJson.testPlanStrings.assertionResponseQuestion,
+      commandsInfo: test.commandsInfo,
+      output_assertions: test.assertions,
     };
 
     emitFile(testPlanJsonFileBuildPath, JSON.stringify(testData, null, 2), 'utf8');
@@ -413,14 +540,14 @@ const processTestDirectory = async ({ directory, args = {} }) => {
     }
 
     function getCommandsJson() {
-      return beautify({ [task]: commands[task] }, null, 2, 40);
+      return beautify({ [testId]: atCommandsMap[testId] }, null, 2, 40);
     }
 
     let testHTML = `
 <!DOCTYPE html>
 <meta charset="utf-8">
 <title>${test.title}</title>
-${references}
+${exampleReferences}
 <script>
   ${getScripts()}
 </script>
@@ -430,14 +557,20 @@ ${references}
   new Promise((resolve) => {
     fetch('../support.json')
       .then(response => resolve(response.json()))
+    }).then(supportJson => {
+      return fetch('../commands.json')
+        .then(response => response.json())
+        .then(allCommandsJson => ({ supportJson, allCommandsJson })
+      );
     })
-  .then(supportJson => {
+  .then(({ supportJson, allCommandsJson }) => {
     const testJson = ${getTestJson()};
     const commandJson = ${getCommandsJson()};
-    initialize(supportJson, commandJson);
+    initialize(supportJson, commandJson, allCommandsJson);
     verifyATBehavior(testJson);
     displayTestPageAndInstructions(${JSON.stringify(
-      exampleScriptedFilesQueryable.where({ name: test.setupScript ? test.setupScript : '' }).path
+      exampleScriptedFilesQueryable.where({ name: test.setupScript ? test.setupScript.script : '' })
+        .path
     )});
   });
 </script>
@@ -445,37 +578,44 @@ ${references}
 
     emitFile(testPlanHtmlFileBuildPath, testHTML, 'utf8');
 
-    /** @type {AriaATFile.CollectedTest} */
-    const collectedTest = {};
-
     const applies_to_at = [];
-
-    allATKeys.forEach(at => applies_to_at.push(testData.applies_to.indexOf(at) >= 0));
+    allAtKeys.forEach(at => applies_to_at.push(testData.applies_to.indexOf(at) >= 0));
 
     return [testFileName, applies_to_at];
   }
 
   /**
    * Create an index file for a local server
-   * @param tasks
+   * @param {object[]} tasks
+   * @param {number} tasks.seq
+   * @param {string} tasks.id
+   * @param {string} tasks.title
+   * @param {string} tasks.href
+   * @param {object} tasks.script
+   * @param {string} tasks.script.script
+   * @param {string} tasks.script.scriptDescription
+   * @param {boolean[]} tasks.applies_to_at
+   * @param {object} options
+   * @param {function(filePath: string, content: any, encoding: string)} options.emitFile
    */
   function createIndexFile(tasks, { emitFile }) {
     let rows = '';
     let all_ats = '';
 
-    allATNames.forEach(at => (all_ats += '<th>' + at + '</th>\n'));
+    allAtNames.forEach(at => (all_ats += '<th>' + at + '</th>\n'));
 
     tasks.forEach(function (task) {
-      rows += `<tr><td>${task.id}</td>`;
+      rows += `<tr><td>${task.seq}</td>`;
+      rows += `<td>${task.id}</td>`;
       rows += `<td scope="row">${task.title}</td>`;
-      for (let i = 0; i < allATKeys.length; i++) {
+      for (let i = 0; i < allAtKeys.length; i++) {
         if (task.applies_to_at[i]) {
-          rows += `<td class="test"><a href="${task.href}?at=${allATKeys[i]}" aria-label="${allATNames[i]} test for task ${task.id}">${allATNames[i]}</a></td>`;
+          rows += `<td class="test"><a href="${task.href}.html?at=${allAtKeys[i]}" aria-label="${allAtNames[i]} test for task ${task.id}">${allAtNames[i]}</a></td>`;
         } else {
           rows += `<td class="test none">not included</td>`;
         }
       }
-      rows += `<td>${task.script}</td></tr>\n`;
+      rows += `<td>${task.script.script}</td></tr>\n`;
     });
 
     let indexHTML = `
@@ -488,7 +628,7 @@ ${references}
       display: table;
       border-collapse: collapse;
       border-spacing: 2px;
-      border-color: gray;
+      border-color: rgb(128,128,128);
     }
 
     thead {
@@ -500,7 +640,7 @@ ${references}
     tbody {
       display: table-row-group;
       vertical-align: middle;
-      border-color: gray;
+      border-color: rgb(128,128,128);
     }
 
     tr:nth-child(even) {background: #DDD}
@@ -509,7 +649,7 @@ ${references}
     tr {
       display: table-row;
       vertical-align: inherit;
-      border-color: gray;
+      border-color: rgb(128,128,128);
     }
 
     td {
@@ -539,6 +679,7 @@ ${references}
   <table>
     <thead>
       <tr>
+        <th>Sequence</th>
         <th>Task ID</th>
         <th>Testing Task</th>
         ${all_ats}
@@ -557,20 +698,57 @@ ${rows}
   }
 
   // Process CSV files
-  var refs = {};
-  var errorCount = 0;
-  var errors = '';
-  var indexOfURLs = [];
-  var checkedSourceHtmlScriptFiles = [];
+  let refs = {};
+  let errorCount = 0;
+  let errors = '';
+  let indexOfURLs = [];
+  let checkedSourceHtmlScriptFiles = [];
 
+  /**
+   * @param {string} id
+   * @param {string} error
+   */
   function addTestError(id, error) {
     errorCount += 1;
     errors += '[Test ' + id + ']: ' + error + '\n';
   }
 
-  function addCommandError({ testId, task }, key) {
+  /**
+   * @param {object} options
+   * @param {string} options.testId
+   * @param {object} options.target
+   * @param {string} key
+   */
+  function addCommandError(
+    {
+      testId,
+      target: {
+        at: { key: atKey },
+      },
+    },
+    key
+  ) {
+    errorCount += 1;
+    errors += `[Command]: The key reference "${key}" found in "${directory}/data/${atKey}-commands.csv" for "test id ${testId}" is invalid. Command may not be defined in "tests/commands.json".\n`;
+  }
+
+  /**
+   * @param {object} options
+   * @param {string} options.testId
+   * @param {object} options.target
+   * @param {string} assertion
+   */
+  function addCommandAssertionExceptionError(
+    {
+      testId,
+      target: {
+        at: { key: atKey },
+      },
+    },
+    assertion
+  ) {
     errorCount += 1;
-    errors += `[Command]: The key reference "${key}" found in "${directory}/data/commands.csv" for "test id ${testId}: ${task}" is invalid. Command may not be defined in "tests/resources/keys.mjs".\n`;
+    errors += `[Command]: assertionExceptions reference "${assertion}" found in "${directory}/data/${atKey}-commands.csv" for "test id ${testId}" is invalid.\n`;
   }
 
   const newTestPlan = newBuild.find(`tests/${path.basename(testPlanBuildDirectory)}`);
@@ -595,7 +773,14 @@ ${rows}
 
   // intended to be an internal helper to reduce some code duplication and make logging for csv errors simpler
   async function readCSVFile(filePath, rowValidator = identity => identity) {
-    const rawCSV = await readCSV(testPlanRecord.find(filePath));
+    let rawCSV = [];
+    try {
+      rawCSV = await readCSV(testPlanRecord.find(filePath));
+    } catch (e) {
+      log.warning(`WARNING: Error reading ${path.join(testPlanDirectory, filePath)}`);
+      return rawCSV;
+    }
+
     let index = 0;
     function printError(message) {
       // line number is index+2
@@ -627,101 +812,73 @@ ${rows}
     return rawCSV;
   }
 
-  function validateReferencesKeys(row) {
-    if (typeof row.refId !== 'string' || typeof row.value !== 'string') {
-      throw new Error('Row missing refId or value');
-    }
-    return row;
-  }
+  for (const row of referencesCsv) {
+    const {
+      references: { aria, htmlAam },
+    } = supportJson;
 
-  const validCommandKeys = /^(?:testId|task|mode|at|command[A-Z])$/;
-  const numericKeyFormat = /^_(\d+)$/;
-  function validateCommandsKeys(row) {
-    // example header:
-    //    testId,task,mode,at,commandA,commandB,commandC,commandD,commandE,commandF
-    for (const key of Object.keys(row)) {
-      if (numericKeyFormat.test(key)) {
-        throw new Error(`Column found without header row, ${+key.substring(1) + 1}`);
-      } else if (!validCommandKeys.test(key)) {
-        throw new Error(`Unknown commands.csv key: ${key} - check header row?`);
-      }
-    }
-    if (
-      !(
-        row.testId?.length &&
-        row.task?.length &&
-        row.mode?.length &&
-        row.at?.length &&
-        row.commandA?.length
-      )
-    ) {
-      throw new Error('Missing one of required testId, task, mode, at, commandA');
-    }
-    return row;
-  }
+    let refId = row.refId.trim();
+    let type = row.type.trim();
+    let value = row.value.trim();
+    let linkText = row.linkText.trim();
 
-  const validTestsKeys =
-    /^(?:testId|title|appliesTo|mode|task|setupScript|setupScriptDescription|refs|instructions|assertion(?:[1-9]|[1-2][0-9]|30))$/;
-  function validateTestsKeys(row) {
-    // example header:
-    // testId,title,appliesTo,mode,task,setupScript,setupScriptDescription,refs,instructions,assertion1,assertion2,assertion3,assertion4,assertion5,assertion6,assertion7
-    for (const key of Object.keys(row)) {
-      if (numericKeyFormat.test(key)) {
-        throw new Error(`Column found without header row, ${+key.substring(1) + 1}`);
-      } else if (!validTestsKeys.test(key)) {
-        throw new Error(`Unknown tests.csv key: ${key} - check header row?`);
-      }
-    }
-    if (
-      !(
-        row.testId?.length &&
-        row.title?.length &&
-        row.appliesTo?.length &&
-        row.mode?.length &&
-        row.task?.length
-      )
-    ) {
-      throw new Error('Missing one of required testId, title, appliesTo, mode, task');
+    if (type === 'aria') {
+      value = `${aria.baseUrl}${aria.fragmentIds[value]}`;
+      linkText = `${linkText} ${aria.linkText}`;
     }
-    return row;
-  }
 
-  const [refRows, atCommands, tests] = await Promise.all([
-    readCSVFile('data/references.csv', validateReferencesKeys),
-    readCSVFile('data/commands.csv', validateCommandsKeys),
-    readCSVFile('data/tests.csv', validateTestsKeys),
-  ]);
+    if (type === 'htmlAam') {
+      value = `${htmlAam.baseUrl}${htmlAam.fragmentIds[value]}`;
+      linkText = `${linkText} ${htmlAam.linkText}`;
+    }
 
-  for (const row of refRows) {
-    refs[row.refId] = row.value.trim();
+    refs[refId] = {
+      type,
+      value,
+      linkText,
+    };
   }
 
-  const scripts = loadScripts(scriptsRecord);
+  const scriptsSource = loadScriptsSource(scriptsRecord);
+  const commandsParsed = parseCommandCSVRowV2(
+    {
+      commands: parsedAtCommandsCsvs,
+    },
+    commandsJson
+  );
+  const {
+    references: { aria, htmlAam },
+  } = supportJson;
+  const referencesParsed = parseReferencesCSV(referencesCsv, { aria, htmlAam });
 
-  const commandsParsed = atCommands.map(parseCommandCSVRow);
-  const testsParsed = tests.map(parseTestCSVRow);
-  const referencesParsed = parseReferencesCSV(refRows);
+  const keyDefs = flattenObject(commandsJson);
   const keysParsed = parseKeyMap(keyDefs);
-  const supportParsed = parseSupport(support);
+  const supportParsed = parseSupport(supportJson);
 
+  // TODO: This causes 'delete' to incorrectly not be recognized as a key, why?
   const keysValidated = validateKeyMap(keysParsed, {
     addKeyMapError(reason) {
       errorCount += 1;
-      errors += `[resources/keys.mjs]: ${reason}\n`;
+      errors += `[commands.json]: ${reason}\n`;
     },
   });
 
   const supportQueryables = {
-    at: Queryable.from('at', supportParsed.ats),
-    atGroup: Queryable.from('atGroup', supportParsed.atGroups),
+    ats: Queryable.from('ats', supportParsed.ats),
+    atGroups: Queryable.from('atGroups', supportParsed.atGroups),
+    references: Queryable.from('references', supportParsed.ats),
+    testPlanStrings: Queryable.from('testPlanStrings', supportParsed.ats),
   };
+
   const keyQueryable = Queryable.from('key', keysValidated);
+  const assertionQueryables = Queryable.from('assertions', assertionsCsv);
   const commandLookups = {
     key: keyQueryable,
     support: supportQueryables,
+    assertions: assertionQueryables,
   };
   const commandsValidated = commandsParsed.map(command =>
-    validateCommand(command, commandLookups, { addCommandError })
+    validateCommand(command, commandLookups, { addCommandError, addCommandAssertionExceptionError })
   );
 
   const referenceQueryable = Queryable.from('reference', referencesParsed);
@@ -740,8 +897,8 @@ ${rows}
   const testLookups = {
     command: Queryable.from('command', commandsValidated),
     mode: Queryable.from('mode', validModes),
+    script: Queryable.from('script', scriptsSource),
     reference: referenceQueryable,
-    script: Queryable.from('script', scripts),
     support: supportQueryables,
   };
   const testsValidated = testsParsed.map(test =>
@@ -760,42 +917,120 @@ ${rows}
     reason => log.warning(`[${examplePathOriginal}]: ${reason.message}`),
     () => createExampleScriptsTemplate(exampleRecord)
   );
-  const exampleScriptedFiles = [{ name: '', source: '' }, ...scripts].map(({ name, source }) => ({
-    name,
-    path: examplePathTemplate(name),
-    content: exampleTemplate.render(exampleTemplateParams(name, source)).toString(),
-  }));
+  const exampleScriptedFiles = [{ name: '', source: '' }, ...scriptsSource].map(
+    ({ name, source }) => ({
+      name,
+      path: examplePathTemplate(name),
+      content: exampleTemplate.render(exampleTemplateParams(name, source)).toString(),
+    })
+  );
   const exampleScriptedFilesQueryable = Queryable.from('example', exampleScriptedFiles);
-
   const commandQueryable = Queryable.from('command', commandsValidated);
   const testsCollected = testsValidated.flatMap(test => {
-    return test.target.at.map(({ key }) =>
+    return test.target.ats.map(({ key, settings }) =>
       collectTestData({
         test,
         command: commandQueryable.where({
           testId: test.testId,
-          target: { at: { key } },
+          target: { at: { key, settings } },
         }),
         reference: referenceQueryable,
+        supportAt: supportQueryables.ats,
         example: exampleScriptedFilesQueryable,
-        key: keyQueryable,
-        modeInstructionTemplate: MODE_INSTRUCTION_TEMPLATES_QUERYABLE,
+        modeInstructionTemplate: MODE_INSTRUCTION_TEMPLATES_QUERYABLE(supportJson),
       })
     );
   });
 
+  // So there can be a single {at}.collected.(json|html) instead of
+  // multiple {at}-{settings}.collected.(json|html)
+  let combinedCollectedTests = [];
+  const _testsCollected = JSON.parse(JSON.stringify(testsCollected.slice(0)));
+
+  // { eg. jaws: [ ... ], nvda: [ ... ], vo: [ ... ] }
+  const collectedTestsGroupedByAt = {};
+  allAtKeys.forEach(atKey => {
+    collectedTestsGroupedByAt[atKey] = _testsCollected.filter(
+      collected => collected.target.at.key === atKey
+    );
+  });
+
+  for (const key in collectedTestsGroupedByAt) {
+    const collectedTestAtGroup = collectedTestsGroupedByAt[key];
+
+    // Get the unique testIds found for the at
+    const collectedTestsGroupedByAtTestIds = [
+      ...new Set(collectedTestAtGroup.map(c => c.info.testId)),
+    ];
+
+    // Group by the testIds
+    for (const testId of collectedTestsGroupedByAtTestIds) {
+      const collectedTestsGroupedByAtGroupedByTestIds = collectedTestAtGroup.filter(
+        c => c.info.testId === testId
+      );
+
+      // Declare a common collectedTest that will be modified (if needed)
+      let common = collectedTestsGroupedByAtGroupedByTestIds[0];
+      const settings = common.target.at.settings;
+      common = {
+        ...common,
+        instructions: {
+          ...common.instructions,
+          mode: { [settings]: common.instructions.mode },
+        },
+        commands: common.commands.map(command => ({
+          ...command,
+          settings,
+        })),
+      };
+
+      // Iterate over the remaining collected tests
+      if (collectedTestsGroupedByAtGroupedByTestIds.length > 1) {
+        for (const additional of collectedTestsGroupedByAtGroupedByTestIds.slice(1)) {
+          const settings = additional.target.at.settings;
+
+          common.target.at.settings = `${common.target.at.settings}_${settings}`;
+          common.instructions.mode[settings] = additional.instructions.mode;
+          common.commands.push(
+            ...additional.commands.map(command => ({
+              ...command,
+              settings,
+            }))
+          );
+        }
+      }
+
+      combinedCollectedTests.push(common);
+    }
+  }
+
   const files = [
-    ...createScriptFiles(scripts, testPlanBuildDirectory),
+    ...createScriptFiles(scriptsSource, testPlanBuildDirectory),
     ...exampleScriptedFiles.map(({ path: pathSuffix, content }) => ({
       path: path.join('build', 'tests', path.basename(directory), pathSuffix),
       content,
     })),
-    ...testsCollected.map(collectedTest =>
-      createCollectedTestFile(collectedTest, testPlanBuildDirectory)
-    ),
-    ...testsCollected.map(collectedTest =>
-      createCollectedTestHtmlFile(collectedTest, testPlanBuildDirectory)
-    ),
+    // TODO: If there is a need to individually view jaws-pcCursor or nvda-browseMode for example
+    // ...testsCollected.map(collectedTest =>
+    //   createCollectedTestFile(collectedTest, testPlanBuildDirectory)
+    // ),
+    // ...testsCollected.map(collectedTest =>
+    //   createCollectedTestHtmlFile(collectedTest, testPlanBuildDirectory)
+    // ),
+    ...combinedCollectedTests.map(collectedTest => {
+      const presentationNumber = parseInt(collectedTest.info.presentationNumber)
+        .toString()
+        .padStart(2, '0');
+      const fileName = `test-${presentationNumber}-${collectedTest.info.testId}-${collectedTest.target.at.key}`;
+      return createCollectedTestFile(collectedTest, testPlanBuildDirectory, fileName);
+    }),
+    ...combinedCollectedTests.map(collectedTest => {
+      const presentationNumber = parseInt(collectedTest.info.presentationNumber)
+        .toString()
+        .padStart(2, '0');
+      const fileName = `test-${presentationNumber}-${collectedTest.info.testId}-${collectedTest.target.at.key}`;
+      return createCollectedTestHtmlFile(collectedTest, testPlanBuildDirectory, fileName);
+    }),
   ];
   files.forEach(file => {
     generateSourceHtmlScriptFile(file.path, file.content);
@@ -819,16 +1054,18 @@ ${rows}
     });
   }
 
-  const atCommandsMap = createCommandTuplesATModeTaskLookup(commandsValidated);
+  const atCommandsMap =
+    createAtCommandTuplesATSettingsTestIdLookupByPresentationNumber(commandsValidated);
+
   emitFile(
     path.join(testPlanBuildDirectory, 'commands.json'),
     beautify(atCommandsMap, null, 2, 40)
   );
 
   log('Creating the following test files: ');
-  tests.forEach(function (test) {
+  testsParsed.forEach(function (testParsed, index) {
     try {
-      const [url, applies_to_at] = createTestFile(test, refs, atCommandsMap, {
+      const [url, applies_to_at] = createTestFile(testParsed, refs, atCommandsMap, {
         addTestError,
         emitFile,
         scriptsRecord,
@@ -836,14 +1073,15 @@ ${rows}
       });
 
       indexOfURLs.push({
-        id: test.testId,
-        title: test.title,
+        seq: index + 1,
+        id: testParsed.testId,
+        title: testParsed.title,
         href: url,
-        script: test.setupScript,
+        script: testParsed.setupScript,
         applies_to_at: applies_to_at,
       });
 
-      log('[Test ' + test.testId + ']: ' + url);
+      log('[Test ' + testParsed.testId + ']: ' + url);
     } catch (err) {
       log.warning(err);
     }
@@ -870,7 +1108,7 @@ ${rows}
     );
     log.warning(errors);
   } else {
-    log('No validation errors detected\n');
+    log(`No validation errors detected for ${directory}\n`);
   }
 
   return { isSuccessfulRun: errorCount === 0, suppressedMessages };
@@ -917,7 +1155,7 @@ function readCSV(record) {
  * @param {FileRecordChain} testPlanJS
  * @returns {AriaATParsed.ScriptSource[]}
  */
-function loadScripts(testPlanJS) {
+function loadScriptsSource(testPlanJS) {
   return testPlanJS.filter({ glob: ',*.js' }).entries.map(({ name: fileName, text: source }) => {
     const name = path.basename(fileName, '.js');
     const modulePath = path.posix.join('scripts', `${name}.module.js`);
@@ -990,25 +1228,45 @@ function createScriptFiles(scripts, testPlanBuildDirectory) {
 }
 
 /**
- * @param {Object<string, string>} keyLines
+ * @param {Object<string, string>} keyDefs
  * @returns {AriaATParsed.KeyMap}
  */
 function parseKeyMap(keyDefs) {
   const keyMap = {};
   for (const id in keyDefs) {
-    keyMap[id] = { id, keystroke: keyDefs[id] };
+    if (id.includes('.')) {
+      const [type, key] = id.split('.');
+      keyMap[key] = { id: key, type, keystroke: keyDefs[id] };
+    }
   }
   return keyMap;
 }
 
 /**
  * @param {AriaATCSV.Reference[]} referenceRows
+ * @param {AriaATCSV.SupportReference} aria
+ * @param {AriaATCSV.SupportReference} htmlAam
  * @returns {AriaATParsed.ReferenceMap}
  */
-function parseReferencesCSV(referenceRows) {
+function parseReferencesCSV(referenceRows, { aria, htmlAam }) {
   const refMap = {};
-  for (const { refId, value } of referenceRows) {
-    refMap[refId] = { refId, value: value.trim() };
+  for (const { refId: _refId, type: _type, value: _value, linkText: _linkText } of referenceRows) {
+    let refId = _refId?.trim();
+    let type = _type?.trim();
+    let value = _value?.trim();
+    let linkText = _linkText?.trim();
+
+    if (type === 'aria') {
+      value = `${aria.baseUrl}${aria.fragmentIds[value]}`;
+      linkText = `${linkText} ${aria.linkText}`;
+    }
+
+    if (type === 'htmlAam') {
+      value = `${htmlAam.baseUrl}${htmlAam.fragmentIds[value]}`;
+      linkText = `${linkText} ${htmlAam.linkText}`;
+    }
+
+    refMap[refId] = { refId, type, value, linkText };
   }
   return refMap;
 }
@@ -1019,34 +1277,62 @@ function parseReferencesCSV(referenceRows) {
  * @param {Queryable<AriaATParsed.Key>} data.key
  * @param {object} data.support
  * @param {Queryable<{key: string, name: string}>} data.support.at
- * @param {object} [options]
- * @param {function(AriaATParsed.Command, string): void} [options.addCommandError]
+ * @param {object} options
+ * @param {function(AriaATParsed.Command, string): void} options.addCommandError
+ * @param {function(AriaATParsed.Command, string): void} options.addCommandAssertionExceptionError
  * @returns {AriaATValidated.Command}
  */
-function validateCommand(commandParsed, data, { addCommandError = () => {} } = {}) {
+function validateCommand(
+  commandParsed,
+  data,
+  { addCommandError = () => {}, addCommandAssertionExceptionError = () => {} } = {}
+) {
   return {
     ...commandParsed,
     target: {
       ...commandParsed.target,
       at: {
         ...commandParsed.target.at,
-        ...mapDefined(data.support.at.where({ key: commandParsed.target.at.key }), ({ name }) => ({
+        ...mapDefined(data.support.ats.where({ key: commandParsed.target.at.key }), ({ name }) => ({
           name,
         })),
       },
     },
-    commands: commandParsed.commands.map(({ id, keypresses: commandKeypresses, ...rest }) => {
-      const keypresses = commandKeypresses.map(keypress => {
-        const key = data.key.where(keypress);
-        if (!key) {
-          addCommandError(commandParsed, keypress.id);
+    commands: commandParsed.commands.map(({ id, keypresses, assertionExceptions, ...rest }) => {
+      keypresses.forEach(keypress => {
+        if (keypress.id.includes('+')) {
+          const splitKeys = keypress.id.split('+');
+          splitKeys.forEach(splitKey => {
+            const key = data.key.where({ id: splitKey });
+            if (!key) {
+              addCommandError(commandParsed, keypress.id);
+            }
+          });
+        } else {
+          const key = data.key.where({ id: keypress.id });
+          if (!key) {
+            addCommandError(commandParsed, keypress.id);
+          }
         }
-        return key || {};
       });
+
       return {
-        id: id,
-        keystroke: keypresses.map(({ keystroke }) => keystroke).join(', then '),
+        id,
         keypresses,
+        assertionExceptions: assertionExceptions.map(each => {
+          const [_priority, assertionId] = each.split(':');
+          const priority = Number(_priority);
+
+          if (isNaN(priority)) {
+            addCommandAssertionExceptionError(commandParsed, each);
+          } else {
+            if (!/^[0123]$/.test(_priority)) {
+              addCommandAssertionExceptionError(commandParsed, each);
+            }
+          }
+
+          return { priority, assertionId };
+        }),
         ...rest,
       };
     }),
@@ -1055,83 +1341,44 @@ function validateCommand(commandParsed, data, { addCommandError = () => {} } = {
 
 /**
  * @param {AriaATParsed.KeyMap} keyMap
+ * @param {object} options
+ * @param {function(string): void} options.addKeyMapError
  */
 function validateKeyMap(keyMap, { addKeyMapError }) {
-  if (!keyMap.ALT_DELETE) {
-    addKeyMapError(`ALT_DELETE is not defined in keys module.`);
-  }
-  if (!keyMap.INS_Z) {
-    addKeyMapError(`INS_Z is not defined in keys module.`);
-  }
-  if (!keyMap.ESC) {
-    addKeyMapError(`ESC is not defined in keys module.`);
-  }
-  if (!keyMap.INS_SPACE) {
-    addKeyMapError(`INS_SPACE is not defined in keys module.`);
-  }
-  if (!keyMap.LEFT) {
-    addKeyMapError(`LEFT is not defined in keys module.`);
-  }
-  if (!keyMap.RIGHT) {
-    addKeyMapError(`RIGHT is not defined in keys module.`);
-  }
+  if (!keyMap.alt) addKeyMapError('"alt" is not defined in keys module.');
+  if (!keyMap.del) addKeyMapError('"del" is not defined in keys module.');
+  if (!keyMap.ins) addKeyMapError('"ins" is not defined in keys module.');
+  if (!keyMap.z) addKeyMapError('"z" is not defined in keys module.');
+  if (!keyMap.esc) addKeyMapError('"esc" is not defined in keys module.');
+  if (!keyMap.space) addKeyMapError('"space" is not defined in keys module.');
+  if (!keyMap.left) addKeyMapError('"left" is not defined in keys module.');
+  if (!keyMap.right) addKeyMapError('"right" is not defined in keys module.');
+
   return keyMap;
 }
 
-const MODE_INSTRUCTION_TEMPLATES_QUERYABLE = Queryable.from('modeInstructionTemplate', [
-  {
-    at: 'jaws',
-    mode: 'reading',
-    render: data => {
-      const altDelete = data.key.where({ id: 'ALT_DELETE' });
-      const esc = data.key.where({ id: 'ESC' });
-      return `Verify the Virtual Cursor is active by pressing ${altDelete.keystroke}. If it is not, exit Forms Mode to activate the Virtual Cursor by pressing ${esc.keystroke}.`;
-    },
-  },
-  {
-    at: 'jaws',
-    mode: 'interaction',
-    render: data => {
-      const altDelete = data.key.where({ id: 'ALT_DELETE' });
-      const insZ = data.key.where({ id: 'INS_Z' });
-      return `Verify the PC Cursor is active by pressing ${altDelete.keystroke}. If it is not, turn off the Virtual Cursor by pressing ${insZ.keystroke}.`;
-    },
-  },
-  {
-    at: 'nvda',
-    mode: 'reading',
-    render: data => {
-      const esc = data.key.where({ id: 'ESC' });
-      return `Ensure NVDA is in browse mode by pressing ${esc.keystroke}. Note: This command has no effect if NVDA is already in browse mode.`;
-    },
-  },
-  {
-    at: 'nvda',
-    mode: 'interaction',
-    render: data => {
-      const insSpace = data.key.where({ id: 'INS_SPACE' });
-      return `If NVDA did not make the focus mode sound when the test page loaded, press ${insSpace.keystroke} to turn focus mode on.`;
-    },
-  },
-  {
-    at: 'voiceover_macos',
-    mode: 'reading',
-    render: data => {
-      const left = data.key.where({ id: 'LEFT' });
-      const right = data.key.where({ id: 'RIGHT' });
-      return `Toggle Quick Nav ON by pressing the ${left.keystroke} and ${right.keystroke} keys at the same time.`;
-    },
-  },
-  {
-    at: 'voiceover_macos',
-    mode: 'interaction',
-    render: data => {
-      const left = data.key.where({ id: 'LEFT' });
-      const right = data.key.where({ id: 'RIGHT' });
-      return `Toggle Quick Nav OFF by pressing the ${left.keystroke} and ${right.keystroke} keys at the same time.`;
-    },
-  },
-]);
+const MODE_INSTRUCTION_TEMPLATES_QUERYABLE = support => {
+  const collection = [];
+  support.ats.forEach(at => {
+    const modes = Object.keys(at.settings);
+    modes.forEach(mode => {
+      collection.push({
+        at: at.key,
+        mode: mode,
+        render: [at.defaultConfigurationInstructionsHTML, ...at.settings[mode].instructions],
+      });
+    });
+
+    // Accounting for modeless AT configurations
+    collection.push({
+      at: at.key,
+      mode: 'defaultMode',
+      render: [at.defaultConfigurationInstructionsHTML],
+    });
+  });
+
+  return Queryable.from('modeInstructionTemplate', collection);
+};
 
 /**
  * @param {T} maybeDefined
@@ -1157,39 +1404,51 @@ function mapDefined(maybeDefined, goal) {
  * @param {Queryable<AriaATParsed.ScriptSource>} data.script
  * @param {object} data.support
  * @param {Queryable<{key: string, name: string}>} data.support.at
- * @param {Queryable<{key: string, name: string}>} data.support.atGroup
+ * @param {Queryable<{key: string, name: string}>} data.support.atGroups
  * @param {object} [options]
  * @param {function(string): void} [options.addTestError]
  * @returns {AriaATValidated.Test}
  */
 function validateTest(testParsed, data, { addTestError = () => {} } = {}) {
-  if (!data.command.where({ task: testParsed.task })) {
-    addTestError(`"${testParsed.task}" does not exist in commands.csv file.`);
+  const assertionStatementTokenPattern = /\{([^{}]+)}/g;
+  const replacedAssertionStatement = (assertionStatement, matches, replacements) => {
+    matches.forEach(
+      match =>
+        (assertionStatement = assertionStatement.replaceAll(
+          match,
+          replacements[match.slice(1, -1)]
+        ))
+    );
+    return assertionStatement;
+  };
+
+  if (!data.command.where({ testId: testParsed.testId })) {
+    addTestError(`"${testParsed.testId}" does not exist in *-commands.csv file.`);
   }
 
-  testParsed.target.at.forEach(at => {
-    if (!data.support.atGroup.where({ key: at.key })) {
+  testParsed.target.ats.forEach(at => {
+    if (!data.support.atGroups.where({ key: at.key })) {
       addTestError(`"${at.key}" is not valid value for "appliesTo" property.`);
     }
 
     if (
       !data.command.where({
-        task: testParsed.task,
         target: {
-          at: { key: at.key },
-          mode: testParsed.target.mode,
+          at: { key: at.key, settings: at.settings },
         },
       })
     ) {
       addTestError(
-        `command is missing for the combination of task: "${testParsed.task}", mode: "${testParsed.target.mode}", and AT: "${at.key}"`
+        `command is missing for the combination of task: "${testParsed.testId}", mode: "${at.settings}", and AT: "${at.key}"`
       );
     }
   });
 
-  if (!data.mode.where(testParsed.target.mode)) {
-    addTestError(`"${testParsed.target.mode}" is not valid value for "mode" property.`);
-  }
+  testParsed.target.ats.forEach(at => {
+    if (!data.mode.where(at.settings)) {
+      addTestError(`"${at.settings}" is not valid value for "settings" property.`);
+    }
+  });
 
   const references = testParsed.references.filter(({ refId }) => {
     if (!data.reference.where({ refId })) {
@@ -1199,25 +1458,55 @@ function validateTest(testParsed, data, { addTestError = () => {} } = {}) {
     return true;
   });
 
-  if (testParsed.setupScript && !data.script.where({ name: testParsed.setupScript.name })) {
+  if (testParsed.setupScript && !data.script.where({ name: testParsed.setupScript.script })) {
     addTestError(
-      `Setup script does not exist: "${testParsed.setupScript.name}" for task "${testParsed.task}"`
+      `Setup script does not exist: "${testParsed.setupScript.script}" for task "${testParsed.testId}"`
     );
   }
 
   const assertions = testParsed.assertions.map(assertion => {
+    assertion.tokenizedAssertionStatements = {};
+
+    // There are assertion tokens to account for
+    if (assertion.assertionStatement.includes('|')) {
+      const [genericAssertionStatement, tokenizedAssertionStatement] =
+        assertion.assertionStatement.split('|');
+
+      // Set fallback just in case tokenized statement or properties do not exist
+      assertion.assertionStatement = genericAssertionStatement;
+
+      if (tokenizedAssertionStatement) {
+        const matches = tokenizedAssertionStatement.match(assertionStatementTokenPattern);
+
+        testParsed.target.ats.forEach(at => {
+          const { assertionTokens } = data.support.ats.where({ key: at.key });
+          const tokensExist =
+            assertionTokens && matches.every(match => assertionTokens[match.slice(1, -1)]);
+
+          if (tokensExist) {
+            assertion.tokenizedAssertionStatements[at.key] = replacedAssertionStatement(
+              tokenizedAssertionStatement,
+              matches,
+              assertionTokens
+            );
+          }
+        });
+      }
+    }
+
     if (
       typeof assertion.priority === 'string' ||
-      (assertion.priority !== 1 && assertion.priority !== 2)
+      (assertion.priority !== 1 && assertion.priority !== 2 && assertion.priority !== 3)
     ) {
       addTestError(
-        `Level value must be 1 or 2, value found was "${assertion.priority}" for assertion "${assertion.expectation}" (NOTE: level 2 defined for this assertion).`
+        `Level value must be 1, 2 or 3, value found was "${assertion.priority}" for assertion "${assertion.assertionStatement}" (NOTE: Priority 3 defined for this assertion).`
       );
       return {
-        priority: 2,
-        expectation: assertion.expectation,
+        ...assertion,
+        priority: 3,
       };
     }
+
     return assertion;
   });
 
@@ -1231,19 +1520,18 @@ function validateTest(testParsed, data, { addTestError = () => {} } = {}) {
       ...data.reference.where({ refId: ref.refId }),
     })),
     target: {
-      at: testParsed.target.at.map(at => ({
+      ats: testParsed.target.ats.map(at => ({
         ...at,
-        ...mapDefined(data.support.at.where({ key: at.key }), ({ name }) => ({
+        ...mapDefined(data.support.ats.where({ key: at.key }), ({ name }) => ({
           name,
         })),
       })),
-      mode: testParsed.target.mode,
     },
     setupScript:
-      testParsed.setupScript && data.script.where({ name: testParsed.setupScript.name })
+      testParsed.setupScript && data.script.where({ name: testParsed.setupScript.script })
         ? {
             ...testParsed.setupScript,
-            ...data.script.where({ name: testParsed.setupScript.name }),
+            ...data.script.where({ name: testParsed.setupScript.script }),
           }
         : undefined,
     assertions,
@@ -1254,33 +1542,31 @@ function validateTest(testParsed, data, { addTestError = () => {} } = {}) {
  * @param {object} data
  * @param {AriaATValidated.Test} data.test
  * @param {AriaATValidated.Command} data.command
- * @param {Queryable<AriaATParsed.Key>} data.key
+ * @param {Queryable<{screenText: string, instructions: [string]}>} data.supportAt
  * @param {Queryable<{name: string, path: string}>} data.example
  * @param {Queryable<{at: string, mode: string, render: function({key: *}): string}>} data.modeInstructionTemplate
  * @returns {AriaATFile.CollectedTest}
  */
-function collectTestData({ test, command, key, example, modeInstructionTemplate }) {
+function collectTestData({ test, command, supportAt, example, modeInstructionTemplate }) {
   return {
     info: {
       testId: test.testId,
-      task: test.task,
       title: test.title,
       references: test.references,
+      presentationNumber: test.presentationNumber,
     },
     target: {
       ...test.target,
-      at: command.target.at,
+      at: { ...command.target.at, raw: supportAt.where({ key: command.target.at.key }) },
       referencePage: example.where({ name: test.setupScript ? test.setupScript.name : '' }).path,
       setupScript: test.setupScript,
     },
     instructions: {
-      ...test.instructions,
-      mode: modeInstructionTemplate
-        .where({
-          at: command.target.at.key,
-          mode: command.target.mode,
-        })
-        .render({ key }),
+      instructions: test.instructions,
+      mode: modeInstructionTemplate.where({
+        at: command.target.at.key,
+        mode: command.target.at.settings,
+      }).render,
     },
     commands: command.commands,
     assertions: test.assertions,
@@ -1296,16 +1582,18 @@ function encodeText(text) {
 
 /**
  * @param {AriaATFile.CollectedTest} test
+ * @param {string} testPlanBuildDirectory
+ * @param {string} fileName
+ * @returns {{path: string, content: Uint8Array}}
  */
-function createCollectedTestFile(test, testPlanBuildDirectory) {
+function createCollectedTestFile(test, testPlanBuildDirectory, fileName = null) {
+  const testPresentationNumber = parseInt(test.info.presentationNumber).toString().padStart(2, '0');
+  const testFileName =
+    fileName ||
+    `test-${testPresentationNumber}-${test.info.testId}-${test.target.at.key}-${test.target.at.settings}`;
+
   return {
-    path: path.join(
-      testPlanBuildDirectory,
-      `test-${test.info.testId.toString().padStart(2, '0')}-${test.info.task.replace(
-        /\s+/g,
-        '-'
-      )}-${test.target.mode}-${test.target.at.key}.collected.json`
-    ),
+    path: path.join(testPlanBuildDirectory, `${testFileName}.collected.json`),
     content: encodeText(beautify(test, null, 2, 40)),
   };
 }
@@ -1313,23 +1601,18 @@ function createCollectedTestFile(test, testPlanBuildDirectory) {
 /**
  * @param {AriaATFile.CollectedTest} test
  * @param {string} testPlanBuildDirectory
+ * @param {string} fileName
  * @returns {{path: string, content: Uint8Array}}
  */
-function createCollectedTestHtmlFile(test, testPlanBuildDirectory) {
-  const testJsonFileName = `test-${test.info.testId
-    .toString()
-    .padStart(2, '0')}-${test.info.task.replace(/\s+/g, '-')}-${test.target.mode}-${
-    test.target.at.key
-  }.collected.json`;
+function createCollectedTestHtmlFile(test, testPlanBuildDirectory, fileName = null) {
+  const testPresentationNumber = parseInt(test.info.presentationNumber).toString().padStart(2, '0');
+  const testFileName =
+    fileName ||
+    `test-${testPresentationNumber}-${test.info.testId}-${test.target.at.key}-${test.target.at.settings}`;
+
   return {
-    path: path.join(
-      testPlanBuildDirectory,
-      `test-${test.info.testId.toString().padStart(2, '0')}-${test.info.task.replace(
-        /\s+/g,
-        '-'
-      )}-${test.target.mode}-${test.target.at.key}.collected.html`
-    ),
-    content: encodeText(renderCollectedTestHtml(test, testJsonFileName)),
+    path: path.join(testPlanBuildDirectory, `${testFileName}.collected.html`),
+    content: encodeText(renderCollectedTestHtml(test, `${testFileName}.collected.json`)),
   };
 }
 
diff --git a/package.json b/package.json
index 3f41e5e66..95d0dd012 100644
--- a/package.json
+++ b/package.json
@@ -7,7 +7,9 @@
     "count": "node ./scripts/count-assertions.js",
     "lint": "eslint .",
     "build": "npm run create-all-tests && npm run review-tests",
-    "validate": "npm run create-all-tests -- --validate",
+    "build-v1": "npm run create-all-tests -- --version1 --verbose && npm run review-tests",
+    "build-v2": "npm run create-all-tests -- --version2 --verbose && npm run review-tests",
+    "validate": "npm run create-all-tests -- --verbose --validate",
     "cleanup": "rimraf build",
     "create-all-tests": "cross-var node scripts/create-all-tests.js --testplan=$npm_config_testplan",
     "review-tests": "cross-var node --experimental-modules scripts/test-reviewer.mjs --testplan=$npm_config_testplan",
diff --git a/scripts/create-all-tests.js b/scripts/create-all-tests.js
index aa4d45305..c58266148 100644
--- a/scripts/create-all-tests.js
+++ b/scripts/create-all-tests.js
@@ -2,7 +2,12 @@ const path = require('path');
 
 const fse = require('fs-extra');
 
-const { processTestDirectory } = require('../lib/data/process-test-directory');
+const {
+  processTestDirectory: processTestDirectoryV2,
+} = require('../lib/data/process-test-directory');
+const {
+  processTestDirectory: processTestDirectoryV1,
+} = require('../lib/data/process-test-directory-v1');
 
 const args = require('minimist')(process.argv.slice(2), {
   alias: {
@@ -10,6 +15,8 @@ const args = require('minimist')(process.argv.slice(2), {
     t: 'testplan',
     v: 'verbose',
     V: 'validate',
+    v1: 'version1',
+    v2: 'version2',
   },
 });
 
@@ -26,6 +33,10 @@ if (args.help) {
        Generate tests and view a detailed report summary.
     -V, --validate
        Determine whether current test plans are valid (no errors present).
+    -v1, --version1
+       Build the tests with the v1 format of the tests
+    -v2, --version2
+       Build the tests with the v2 format of the tests
 `);
   process.exit();
 }
@@ -36,8 +47,11 @@ async function main() {
   // on some OSes, it seems the `npm_config_testplan` environment variable will come back as the actual variable name rather than empty if it does not exist
   const TARGET_TEST_PLAN =
     args.testplan && !args.testplan.includes('npm_config_testplan') ? args.testplan : null; // individual test plan to generate test assets for
+
   const VERBOSE_CHECK = !!args.verbose;
   const VALIDATE_CHECK = !!args.validate;
+  const V1_CHECK = !!args.v1;
+  const V2_CHECK = !!args.v2;
 
   const scriptsDirectory = path.dirname(__filename);
   const rootDirectory = path.join(scriptsDirectory, '..');
@@ -58,15 +72,44 @@ async function main() {
   }
 
   const filteredTests = await Promise.all(
-    filteredTestPlans.map(directory =>
-      processTestDirectory({
-        directory: path.join('tests', directory),
-        args,
-      }).catch(error => {
-        error.directory = directory;
-        throw error;
-      })
-    )
+    filteredTestPlans.map(directory => {
+      let FALLBACK_V1_CHECK = false;
+      let FALLBACK_V2_CHECK = false;
+
+      // Check if files exist for doing v2 build by default first, then try v1
+      if (!V1_CHECK && !V2_CHECK) {
+        // Use existence of assertions.csv to determine if v2 format files exist for now
+        const assertionsCsvPath = path.join(
+          __dirname,
+          '../',
+          'tests',
+          directory,
+          'data',
+          'assertions.csv'
+        );
+
+        if (fse.existsSync(assertionsCsvPath)) FALLBACK_V2_CHECK = true;
+        else FALLBACK_V1_CHECK = true;
+      }
+
+      if (FALLBACK_V2_CHECK || V2_CHECK) {
+        return processTestDirectoryV2({
+          directory: path.join('tests', directory),
+          args,
+        }).catch(error => {
+          error.directory = directory;
+          throw error;
+        });
+      } else if (FALLBACK_V1_CHECK || V1_CHECK) {
+        return processTestDirectoryV1({
+          directory: path.join('tests', directory),
+          args,
+        }).catch(error => {
+          error.directory = directory;
+          throw error;
+        });
+      }
+    })
   ).catch(error => {
     console.error(`ERROR: Unhandled exception thrown while processing "${error.directory}".`);
     if (!VERBOSE_CHECK) {
diff --git a/scripts/review-index-template.mustache b/scripts/review-index-template.mustache
index ab76db06f..ef19e13db 100644
--- a/scripts/review-index-template.mustache
+++ b/scripts/review-index-template.mustache
@@ -38,6 +38,7 @@
 
     <table>
       <tr>
+        <th>Title</th>
         <th>Pattern</th>
         <th>Index Page</th>
         <th>Review Page</th>
@@ -46,9 +47,10 @@
       </tr>
       {{#patterns}}
           <tr>
-            <th>{{name}}</th>
-            <td><a href="./tests/{{name}}/index.html" aria-label="Index: {{name}}">Index</a></td>
-            <td><a href="./review/{{name}}.html" aria-label="Review: {{name}}">Review</a></td>
+            <th>{{title}}</th>
+            <td>{{patternName}}</td>
+            <td><a href="./tests/{{patternName}}/index.html" aria-label="Index: {{patternName}}">Index</a></td>
+            <td><a href="./review/{{patternName}}.html" aria-label="Review: {{patternName}}">Review</a></td>
             <td><p aria-label="Number of Tests: {{numberOfTests}}">{{numberOfTests}}</p></td>
             <td><a href="https://github.com/w3c/aria-at/commit/{{commit}}" target="_blank">{{commitDescription}}</a></td>
           </tr>
diff --git a/scripts/review-template.mustache b/scripts/review-template.mustache
index fdc248967..74063f23b 100644
--- a/scripts/review-template.mustache
+++ b/scripts/review-template.mustache
@@ -2,7 +2,7 @@
 <html lang="en">
   <head>
     <meta charset="utf-8">
-    <title>Test plan review for pattern: {{pattern}}</title>
+    <title>{{title}} Test Plan | For Pattern: {{pattern}}</title>
     <style>
       table {
         border-collapse: collapse;
@@ -112,79 +112,102 @@
     </script>
   </head>
   <body>
-
-    <h1>Test plan review for pattern: {{pattern}} ({{totalTests}} tests)</h1>
+    <h1>{{h1Heading}}</h1>
 
     <fieldset>
-      <legend>Filter tests by assistive technology</legend>
+      <legend>Filter tests by covered assistive technology</legend>
       <input type="radio" onclick="filterATs(this)" id="all" value="all" checked><label for="all">All assistive technologies</label>
-      {{#AToptions}}
+      {{#atOptions}}
       <input type="radio" onclick="filterATs(this)" id="{{key}}" value="{{key}}"><label for="{{key}}">{{name}}</label>
-      {{/AToptions}}
+      {{/atOptions}}
     </fieldset>
 
+    <h2>Supporting Documentation</h2>
+    <ul>
+      {{#supportingDocs}}
+      <li><a href="{{link}}">{{text}}</a></li>
+      {{/supportingDocs}}
+    </ul>
+
     {{#tests}}
     <h2 class="{{allRelevantATsSpaceSeparated}}">Test {{testNumber}}: {{{name}}}</h2>
     <ul class="{{allRelevantATsSpaceSeparated}}">
-      <li>Mode: {{mode}}</li>
-      <li>Applies to: {{allRelevantATsFormatted}}</li>
-      <li>Last edited: {{lastEdited}}</li>
+      <li>Last Edited: {{lastEdited}}</li>
       <li>Tests:
         <ul>
           {{#allRelevantATs}}
-            <li><a href="../tests{{{location}}}?at={{{.}}}">{{{.}}}</a></li>
+            <li><a href="../tests{{{location}}}?at={{key}}">{{name}}</a></li>
           {{/allRelevantATs}}
         </ul>
       </li>
-      <li>Relevant Specifications:
+      {{#helpLinksExist}}
+      <li>{{helpLinksTitle}}
         <ul>
           {{#helpLinks}}
-            <li><a href="{{link}}">{{text}}</a></li>
+              <li><a href="{{link}}">{{text}}</a></li>
           {{/helpLinks}}
         </ul>
       </li>
+      {{/helpLinksExist}}
     </ul>
 
     <button id="open-test-page-{{testNumber}}" class="{{allRelevantATsSpaceSeparated}}"
         onclick="openTestPage('../tests{{reference}}', {{testNumber}}, '{{setupScriptName}}');">Open Test {{testNumber}} Page</button>
 
-      {{#ATTests}}
+      {{#atTests}}
       <div class="{{atKey}}">
         <h3>{{atName}}</h3>
-        {{#setupScriptDescription}}
-        <h4>Scripted Instructions</h4>
-        The following instructions are executed by a script in the test page to initialize the widget:
+        <h4>Instructions</h4>
         <ol>
-        <li>{{.}}</li>
-        </ol>
-        {{/setupScriptDescription}}
-        <h4>Tester Instructions</h4>
-        <ol>
-          <li>{{modeInstruction}}</li>
-          <li>{{userInstruction}} using the following commands:
+          <li>{{{defaultConfigurationInstructions}}}</li>
+          <li>{{{openExampleInstructions}}}</li>
+          <li>{{userInstruction}}
             <ul>
-              {{#commands}}
+              {{#commandsValuesForInstructions}}
                 <li>{{.}}</li>
-              {{/commands}}
-              {{^commands}}
-                <li>No commands have been added for this test for {{atName}}. Add commands, or, update the "applies_to" to list only the relevant assistive technologies.</li>
-              {{/commands}}
+              {{/commandsValuesForInstructions}}
+              {{^commandsValuesForInstructions}}
+                <li>No commands have been added for this test for {{atName}}. Add commands to the relevant assistive technologies.</li>
+              {{/commandsValuesForInstructions}}
             </ul>
           </li>
         </ol>
-        <h4>Assertions</h4>
-        <table>
-          <tr><th>Priority</th><th>Assertion</th></tr>
-          {{#assertions}}
-            <tr><td>{{priority}}</td><td>{{description}}</td></tr>
-          {{/assertions}}
-          {{^assertions}}
-            <tr><td colspan="2">No assertions have been listed for {{atName}}. Add assertion or update the "applies_to" to list only the relevant assistive technologies.</td></tr>
-          {{/assertions}}
-        </table>
+        {{#modeInstructions}}
+          <p>{{screenText}}</p>
+          <ol>
+            {{#instructions}}
+              <li>{{{.}}}</li>
+            {{/instructions}}
+          </ol>
+        {{/modeInstructions}}
+        {{#assertionsForCommandsInstructions}}
+          <h4 id="{{elemId}}">{{value}}: {{mustCount}} MUST, {{shouldCount}} SHOULD, AND {{mayCount}} MAY assertions</h4>
+          <table aria-labelledby="{{elemId}}">
+            <tr>
+              <th>Priority</th>
+              {{#isV2}}
+              <th>Assertion Phrase</th>
+              {{/isV2}}
+              <th>Assertion Statement</th>
+            </tr>
+            {{#assertionsInstructions}}
+              {{#priority}}
+                <tr>
+                  <td>{{priority}}</td>
+                  {{#isV2}}
+                  <td>{{assertionPhrase}}</td>
+                  {{/isV2}}
+                  <td>{{assertionStatement}}</td>
+                </tr>
+              {{/priority}}
+            {{/assertionsInstructions}}
+            {{^assertionsInstructions}}
+            <tr><td colspan="3">No assertions have been listed for {{atName}}. Add assertion or update the relevant assistive technologies.</td></tr>
+            {{/assertionsInstructions}}
+          </table>
+        {{/assertionsForCommandsInstructions}}
       </div>
-      {{/ATTests}}
+      {{/atTests}}
     {{/tests}}
-
   </body>
 </html>
diff --git a/scripts/test-reviewer.mjs b/scripts/test-reviewer.mjs
index 171c58175..b47a4a3fa 100644
--- a/scripts/test-reviewer.mjs
+++ b/scripts/test-reviewer.mjs
@@ -39,6 +39,7 @@ const reviewBuildDirectory = path.resolve(buildDirectory, 'review');
 
 const indexFileBuildOutputPath = path.resolve(buildDirectory, 'index.html');
 const supportFilePath = path.join(testsDirectory, 'support.json');
+const allCommandsFilePath = path.join(testsDirectory, 'commands.json');
 const reviewTemplateFilePath = path.resolve(scriptsDirectory, 'review-template.mustache');
 const reviewIndexTemplateFilePath = path.resolve(
   scriptsDirectory,
@@ -49,7 +50,9 @@ const reviewIndexTemplateFilePath = path.resolve(
 fse.existsSync(reviewBuildDirectory) || fse.mkdirSync(reviewBuildDirectory);
 
 const allTestsForPattern = {};
+const referencesForPattern = {};
 const support = JSON.parse(fse.readFileSync(supportFilePath));
+const allCommands = JSON.parse(fse.readFileSync(allCommandsFilePath));
 
 let allATKeys = [];
 support.ats.forEach(at => {
@@ -61,33 +64,101 @@ const scripts = [];
 const getPriorityString = function (priority) {
   priority = parseInt(priority);
   if (priority === 1) {
-    return 'required';
+    return 'MUST';
   } else if (priority === 2) {
-    return 'optional';
+    return 'SHOULD';
+  } else if (priority === 3) {
+    return 'MAY';
   }
   return '';
 };
 
-fse.readdirSync(testsDirectory).forEach(function (directory) {
+const getReferenceForDirectory = (references, refId) => {
+  const { type, value, linkText } = references.find(el => el.refId === refId) || {};
+  return { type, value, linkText };
+};
+
+const unescapeHTML = string =>
+  string.replace(
+    /&amp;|&lt;|&gt;|&#39;|&quot;/g,
+    tag =>
+      ({
+        '&amp;': '&',
+        '&lt;': '<',
+        '&gt;': '>',
+        '&#39;': "'",
+        '&quot;': '"',
+      }[tag] || tag)
+  );
+
+fse.readdirSync(testsBuildDirectory).forEach(function (directory) {
   const testPlanDirectory = path.join(testsDirectory, directory);
   const testPlanBuildDirectory = path.join(testsBuildDirectory, directory);
   const stat = fse.statSync(testPlanDirectory);
 
-  if (stat.isDirectory() && directory !== 'resources') {
+  if (
+    stat.isDirectory() &&
+    directory !== 'resources' &&
+    (TARGET_TEST_PLAN ? directory === TARGET_TEST_PLAN : true)
+  ) {
     // Initialize the commands API
-    const commandsJSONFile = path.join(testPlanBuildDirectory, 'commands.json');
-    const commands = JSON.parse(fse.readFileSync(commandsJSONFile));
-    const commandsAPI = new CommandsAPI(commands, support);
+    const testPlanCommandsJSONFile = path.join(testPlanBuildDirectory, 'commands.json');
+    const testPlanCommands = JSON.parse(fse.readFileSync(testPlanCommandsJSONFile));
+    const commandsAPI = new CommandsAPI(testPlanCommands, support, allCommands);
 
     const tests = [];
+    const collectedTestsData = [];
 
     const referencesCsv = fse.readFileSync(
       path.join(testPlanDirectory, 'data', 'references.csv'),
       'UTF-8'
     );
-    const referenceLine = referencesCsv.split(/\r?\n/).find(s => s.startsWith('reference,'));
-    const splitReferenceLine = referenceLine ? referenceLine.split(',') : null;
-    const reference = splitReferenceLine && splitReferenceLine.length > 1 && splitReferenceLine[1];
+    const lines = referencesCsv.trim().split(/\r?\n/);
+    const headers = lines[0].split(',');
+    const referencesCsvData = lines.slice(1).map(line => line.split(','));
+
+    let referencesData = referencesCsvData.map(row => {
+      const obj = {};
+      headers.forEach((header, index) => {
+        obj[header] = row[index];
+      });
+      return obj;
+    });
+
+    const {
+      references: { aria, htmlAam },
+      testPlanStrings: {
+        ariaSpecsPreface,
+        openExampleInstruction,
+        commandListPreface,
+        commandListSettingsPreface,
+        settingInstructionsPreface,
+        assertionResponseQuestion,
+      },
+    } = support;
+    referencesData = referencesData.map(
+      ({ refId: _refId, type: _type, value: _value, linkText: _linkText }) => {
+        let refId = _refId?.trim();
+        let type = _type?.trim();
+        let value = _value?.trim();
+        let linkText = _linkText?.trim();
+
+        if (type === 'aria') {
+          value = `${aria.baseUrl}${aria.fragmentIds[value]}`;
+          linkText = `${linkText} ${aria.linkText}`;
+        }
+
+        if (type === 'htmlAam') {
+          value = `${htmlAam.baseUrl}${htmlAam.fragmentIds[value]}`;
+          linkText = `${linkText} ${htmlAam.linkText}`;
+        }
+
+        return { refId, type, value, linkText };
+      }
+    );
+
+    const reference = getReferenceForDirectory(referencesData, 'reference');
+    const title = getReferenceForDirectory(referencesData, 'title');
 
     if (!reference) {
       // force exit if file path reference not found
@@ -97,6 +168,8 @@ fse.readdirSync(testsDirectory).forEach(function (directory) {
       process.exit(1);
     }
 
+    referencesForPattern[directory] = referencesData;
+
     const scriptsPath = path.join(testPlanDirectory, 'data', 'js');
     fse.readdirSync(scriptsPath).forEach(function (scriptFile) {
       let script = '';
@@ -121,17 +194,30 @@ fse.readdirSync(testsDirectory).forEach(function (directory) {
         const testFile = path.join(testsBuildDirectory, directory, test);
         const root = np.parse(fse.readFileSync(testFile, 'utf8'), { script: true });
 
-        // Get metadata
+        // Get testData from test-review-{presentationNumber}-{testId}-{modes}.json
+        const testData = JSON.parse(
+          fse.readFileSync(
+            path.join(testPlanBuildDirectory, path.parse(test).name + '.json'),
+            'utf8'
+          )
+        );
+
+        // Get metadata help links
         const testFullName = root.querySelector('title').innerHTML;
         const helpLinks = [];
         for (let link of root.querySelectorAll('link')) {
           if (link.attributes.rel === 'help') {
             let href = link.attributes.href;
-            let text;
-            if (href.indexOf('#') >= 0) {
-              text = `ARIA specification: ${href.split('#')[1]}`;
-            } else {
-              text = `APG example: ${href.split('examples/')[1]}`;
+            // V2
+            let text = link.attributes.title;
+
+            // V1
+            if (!text) {
+              if (href.indexOf('#') >= 0) {
+                text = `ARIA specification: ${href.split('#')[1]}`;
+              } else {
+                text = `APG example: ${href.split('examples/')[1]}`;
+              }
             }
 
             helpLinks.push({
@@ -141,23 +227,56 @@ fse.readdirSync(testsDirectory).forEach(function (directory) {
           }
         }
 
-        let testData = JSON.parse(
-          fse.readFileSync(
-            path.join(testPlanBuildDirectory, path.parse(test).name + '.json'),
-            'utf8'
-          )
-        );
+        collectedTestsData.push({ ...testData, test, testFullName, helpLinks });
+      }
+    });
+
+    collectedTestsData
+      .sort((a, b) => {
+        const commandsInfoA = a.commandsInfo;
+        const commandsInfoB = b.commandsInfo;
+
+        // The whole number will always be the same in the collection
+        function extractPresentationNumber(data) {
+          let presentationNumber;
+
+          // Loop through the keys in testData
+          for (const key in data) {
+            // Check if the key has data
+            if (data[key].length > 0) {
+              // Extract presentation number from the first item in the array
+              presentationNumber = parseInt(data[key][0].presentationNumber);
+            }
+          }
+
+          return presentationNumber;
+        }
+
+        const wholeNumberA = extractPresentationNumber(commandsInfoA);
+        const wholeNumberB = extractPresentationNumber(commandsInfoB);
+
+        return wholeNumberA - wholeNumberB;
+      })
+      .forEach(({ test, testFullName, helpLinks, ...testData }) => {
+        const testNumber = tests.length + 1;
+        // TODO: Using a property unique to the v2 test format to identify if v2; consider a metadata property in the
+        //  future if newer versions are to be supported
+        const isV2 = !!testData.commandsInfo;
+
+        const helpLinksTitle = ariaSpecsPreface;
+        const helpLinksExist = !!helpLinks.length;
+
+        const openExampleInstructions =
+          unescapeHTML(openExampleInstruction) + ' ' + testData.setup_script_description + '.';
 
-        const userInstruction = testData.specific_user_instruction;
         const task = testData.task;
 
         // This is temporary while transitioning from lists to strings
         const mode = typeof testData.mode === 'string' ? testData.mode : testData.mode[0];
+        const atTests = [];
 
-        const ATTests = [];
-
-        // TODO: These apply_to strings are not standardized yet.
-        let allRelevantATs = [];
+        // TODO: These applies_to strings are not standardized yet.
+        let allRelevantATs;
         if (
           testData.applies_to[0].toLowerCase() === 'desktop screen readers' ||
           testData.applies_to[0].toLowerCase() === 'screen readers'
@@ -166,66 +285,228 @@ fse.readdirSync(testsDirectory).forEach(function (directory) {
         } else {
           allRelevantATs = testData.applies_to;
         }
+        allRelevantATs = [...new Set(allRelevantATs)];
 
         for (const atKey of allRelevantATs.map(a => a.toLowerCase())) {
-          let commands, assertions;
+          let userInstruction = testData.specific_user_instruction + ' ' + commandListPreface;
+
+          let assertionsInstructions,
+            assertionsForCommandsInstructions,
+            commandsValuesForInstructions,
+            modeInstructions = undefined;
           let at = commandsAPI.isKnownAT(atKey);
+          const defaultConfigurationInstructions = unescapeHTML(
+            commandsAPI.defaultConfigurationInstructions(atKey)
+          );
+
+          if (testData.additional_assertions && testData.additional_assertions[at.key]) {
+            assertionsInstructions = testData.additional_assertions[at.key];
+          } else {
+            assertionsInstructions = testData.output_assertions;
+          }
+
+          const defaultAssertionsInstructions =
+            assertionsInstructions && assertionsInstructions.length
+              ? assertionsInstructions.map(a => {
+                  // V1 support
+                  if (Array.isArray(a)) {
+                    return {
+                      assertionId: null,
+                      priority: getPriorityString(a[0]),
+                      assertionPhrase: 'N/A',
+                      assertionStatement: a[1],
+                      commandInfo: null,
+                    };
+                  }
+
+                  // V2 support
+                  return {
+                    assertionId: a.assertionId,
+                    priority: getPriorityString(a.priority),
+                    assertionPhrase: a.assertionPhrase,
+                    assertionStatement:
+                      a.tokenizedAssertionStatements?.[at.key] || a.assertionStatement,
+                    commandInfo: a.commandInfo,
+                  };
+                })
+              : undefined;
 
           try {
-            commands = commandsAPI.getATCommands(mode, task, at);
+            assertionsForCommandsInstructions = commandsAPI.getATCommands(mode, task, {
+              ...at,
+              settings: {
+                ...at.settings,
+                defaultMode: {
+                  // TODO: If there is a need to explicitly state that the
+                  //  default mode is active for an AT
+                  screenText: '',
+                  // instructions: [at.defaultConfigurationInstructionsHTML],
+                },
+              },
+            });
+            if (
+              assertionsForCommandsInstructions.length &&
+              typeof assertionsForCommandsInstructions[0] === 'object'
+            ) {
+              commandsValuesForInstructions = assertionsForCommandsInstructions.map(
+                each => each.value
+              );
+            } else {
+              // V1 came in as array of strings
+              if (assertionsForCommandsInstructions.every(each => typeof each === 'string')) {
+                commandsValuesForInstructions = assertionsForCommandsInstructions;
+                assertionsForCommandsInstructions = assertionsForCommandsInstructions.map(each => ({
+                  value: each,
+                }));
+              }
+            }
+
+            // For V2 to handle assertion exceptions
+            assertionsForCommandsInstructions = assertionsForCommandsInstructions.map(
+              (assertionForCommand, assertionForCommandIndex) => {
+                const assertionsInstructions = defaultAssertionsInstructions.map(assertion => {
+                  let priority = assertion.priority;
+
+                  // Check to see if there is any command info exceptions for current at key
+                  if (assertion.commandInfo && assertion.commandInfo[at.key]) {
+                    assertion.commandInfo[at.key].forEach(commandInfoForAt => {
+                      // Reconfirm against the known testData.commandsInfo;
+                      // order should be maintained as presorted during build
+                      // process
+                      const testDataCommandInfoForAt =
+                        testData.commandsInfo[at.key][assertionForCommandIndex];
+
+                      if (
+                        commandInfoForAt.testId === task &&
+                        commandInfoForAt.command === assertionForCommand.key &&
+                        commandInfoForAt.assertionExceptions.includes(assertion.assertionId) &&
+                        commandInfoForAt.presentationNumber ===
+                          testDataCommandInfoForAt.presentationNumber
+                      ) {
+                        for (const exceptionPair of commandInfoForAt.assertionExceptions.split(
+                          ' '
+                        )) {
+                          let [exceptionPriority, exceptionAssertion] = exceptionPair.split(':');
+                          exceptionPriority = Number(exceptionPriority);
+
+                          if (assertion.assertionId === exceptionAssertion) {
+                            priority = getPriorityString(exceptionPriority);
+                          }
+                        }
+                      }
+                    });
+                  }
+
+                  return {
+                    ...assertion,
+                    priority,
+                  };
+                });
+
+                return {
+                  ...assertionForCommand,
+                  assertionsInstructions,
+                  elemId: `t${testNumber}-${at.key}-c${assertionForCommandIndex + 1}`,
+                  mustCount: assertionsInstructions.reduce(
+                    (acc, curr) => acc + (curr.priority === 'MUST' ? 1 : 0),
+                    0
+                  ),
+                  shouldCount: assertionsInstructions.reduce(
+                    (acc, curr) => acc + (curr.priority === 'SHOULD' ? 1 : 0),
+                    0
+                  ),
+                  mayCount: assertionsInstructions.reduce(
+                    (acc, curr) => acc + (curr.priority === 'MAY' ? 1 : 0),
+                    0
+                  ),
+                };
+              }
+            );
+
+            if (commandsValuesForInstructions && !commandsValuesForInstructions.length) {
+              // Invalid state to reflect that no commands have been added to the related .csv in the template
+              commandsValuesForInstructions = undefined;
+            }
           } catch (error) {
             // An error will occur if there is no data for a screen reader, ignore it
           }
 
-          if (testData.additional_assertions && testData.additional_assertions[at.key]) {
-            assertions = testData.additional_assertions[at.key];
-          } else {
-            assertions = testData.output_assertions;
+          for (const atMode of mode.split('_')) {
+            // TODO: If there is ever need to explicitly show the instructions
+            //  for an AT with the default mode active
+            // const atSettingsWithDefault = {
+            //   ...at.settings,
+            //   defaultMode: {
+            //     screenText: 'default mode active',
+            //     instructions: [at.defaultConfigurationInstructionsHTML],
+            //   },
+            // };
+
+            if (at.settings[atMode]) {
+              let settings = at.settings[atMode];
+              const modifiedSettings = {
+                ...settings,
+                screenText: settingInstructionsPreface + ' ' + settings.screenText + ':',
+                instructions: settings.instructions.map(instruction => {
+                  return unescapeHTML(instruction);
+                }),
+              };
+              if (!modeInstructions) modeInstructions = [modifiedSettings];
+              else modeInstructions = [...modeInstructions, modifiedSettings];
+            }
           }
 
-          ATTests.push({
+          // Append commandListSettingsPreface only if 1+ command exists that specifies a setting
+          if (modeInstructions)
+            userInstruction = userInstruction + ' ' + commandListSettingsPreface;
+
+          atTests.push({
             atName: at.name,
             atKey: at.key,
-            commands: commands && commands.length ? commands : undefined,
-            assertions:
-              assertions && assertions.length
-                ? assertions.map(a => ({
-                    priority: getPriorityString(a[0]),
-                    description: a[1],
-                  }))
-                : undefined,
+            commandsValuesForInstructions,
+            assertionsForCommandsInstructions,
+            defaultConfigurationInstructions,
+            openExampleInstructions,
+            modeInstructions,
             userInstruction,
-            modeInstruction: commandsAPI.getModeInstructions(mode, at),
-            setupScriptDescription: testData.setup_script_description,
           });
         }
 
         // Create the test review pages
-        const testFilePath = path.join(testsBuildDirectory, directory, test);
+        const testFilePath = path.join(testsDirectory, directory);
         // TODO: useful for determining smart-diffs
         const output = spawnSync('git', ['log', '-1', '--format="%ad"', testFilePath]);
         const lastEdited = output.stdout.toString().replace(/"/gi, '').replace('\n', '');
 
         tests.push({
-          testNumber: tests.length + 1,
+          testNumber,
+          title: title.value,
           name: testFullName,
           location: `/${directory}/${test}`,
           reference: `/${directory}/${path.posix.join(
-            path.dirname(reference),
-            path.basename(reference, '.html')
+            path.dirname(reference.value),
+            path.basename(reference.value, '.html')
           )}${testData.setupTestPage ? `.${testData.setupTestPage}` : ''}.html`,
-          allRelevantATsFormatted: testData.applies_to.join(', '),
-          allRelevantATsSpaceSeparated: testData.applies_to.join(' '),
-          allRelevantATs: testData.applies_to,
+          allRelevantATsFormatted: allRelevantATs.join(', '),
+          allRelevantATsSpaceSeparated: allRelevantATs.join(' '),
+          allRelevantATs: allRelevantATs.map(each => {
+            const at = support.ats.find(at => at.key === each);
+            return {
+              key: at.key,
+              name: at.name,
+            };
+          }),
           setupScriptName: testData.setupTestPage,
           task,
           mode,
-          ATTests,
+          atTests,
           helpLinks,
+          helpLinksTitle,
+          helpLinksExist,
           lastEdited,
+          isV2,
         });
-      }
-    });
+      });
 
     if (tests.length) {
       allTestsForPattern[directory] = tests;
@@ -236,15 +517,70 @@ fse.readdirSync(testsDirectory).forEach(function (directory) {
 let template = fse.readFileSync(reviewTemplateFilePath, 'utf8');
 let indexTemplate = fse.readFileSync(reviewIndexTemplateFilePath, 'utf8');
 
+const getRenderValues = (
+  references,
+  { pattern, tests, atOptions = support.ats, setupScripts = scripts }
+) => {
+  const supportingDocs = [];
+
+  const { value: title } = getReferenceForDirectory(references, 'title');
+  const { value: exampleLink, linkText: exampleLinkText } = getReferenceForDirectory(
+    references,
+    'example'
+  );
+  const { value: designPatternLink, linkText: designPatternLinkText } = getReferenceForDirectory(
+    references,
+    'designPattern'
+  );
+  const { value: developmentDocumentationLink, linkText: developmentDocumentationLinkText } =
+    getReferenceForDirectory(references, 'developmentDocumentation');
+
+  // Handle special cases where text could be null
+  let defaultExampleLinkText;
+  let defaultDesignPatternLinkText;
+
+  if (exampleLink) {
+    defaultExampleLinkText = `APG example: ${exampleLink.split('examples/')[1]}`;
+  }
+  if (designPatternLink) {
+    defaultDesignPatternLinkText = `ARIA specification: ${designPatternLink.split('#')[1]}`;
+  }
+
+  if (exampleLink)
+    supportingDocs.push({ link: exampleLink, text: exampleLinkText || defaultExampleLinkText });
+  if (designPatternLink)
+    supportingDocs.push({
+      link: designPatternLink,
+      text: designPatternLinkText || defaultDesignPatternLinkText,
+    });
+  if (developmentDocumentationLink)
+    supportingDocs.push({
+      link: developmentDocumentationLink,
+      text: developmentDocumentationLinkText,
+    });
+
+  const testsLength = tests.length;
+  const h1Heading = `${title} Test Plan (${tests.length} test${testsLength === 1 ? '' : 's'})`;
+
+  return {
+    title,
+    pattern,
+    h1Heading,
+    tests,
+    atOptions,
+    setupScripts,
+    supportingDocs,
+  };
+};
+
 if (TARGET_TEST_PLAN) {
   if (allTestsForPattern[TARGET_TEST_PLAN]) {
-    let rendered = mustache.render(template, {
+    const references = referencesForPattern[TARGET_TEST_PLAN];
+    const renderValues = getRenderValues(references, {
       pattern: TARGET_TEST_PLAN,
-      totalTests: allTestsForPattern[TARGET_TEST_PLAN].length,
       tests: allTestsForPattern[TARGET_TEST_PLAN],
-      AToptions: support.ats,
-      setupScripts: scripts,
     });
+    let rendered = mustache.render(template, renderValues);
 
     let summaryBuildFile = path.resolve(reviewBuildDirectory, `${TARGET_TEST_PLAN}.html`);
     fse.writeFileSync(summaryBuildFile, rendered);
@@ -257,13 +593,12 @@ if (TARGET_TEST_PLAN) {
   }
 } else {
   for (let pattern in allTestsForPattern) {
-    let rendered = mustache.render(template, {
+    const references = referencesForPattern[pattern];
+    const renderValues = getRenderValues(references, {
       pattern: pattern,
-      totalTests: allTestsForPattern[pattern].length,
       tests: allTestsForPattern[pattern],
-      AToptions: support.ats,
-      setupScripts: scripts,
     });
+    let rendered = mustache.render(template, renderValues);
 
     let summaryBuildFile = path.resolve(reviewBuildDirectory, `${pattern}.html`);
     fse.writeFileSync(summaryBuildFile, rendered);
@@ -273,21 +608,31 @@ if (TARGET_TEST_PLAN) {
 }
 
 const renderedIndex = mustache.render(indexTemplate, {
-  patterns: Object.keys(allTestsForPattern).map(pattern => {
-    // TODO: useful for determining smart-diffs; this has to continue generating for all patterns until smart-diffs come into play
-    const lastCommit = spawnSync('git', [
-      'log',
-      '-n1',
-      '--oneline',
-      path.join('.', 'tests', pattern),
-    ]).stdout.toString();
-    return {
-      name: pattern,
-      numberOfTests: allTestsForPattern[pattern].length,
-      commit: lastCommit.split(' ')[0],
-      commitDescription: lastCommit,
-    };
-  }),
+  patterns: Object.keys(allTestsForPattern)
+    .map(pattern => {
+      // TODO: useful for determining smart-diffs; this has to continue generating for all patterns until smart-diffs come into play
+      const lastCommit = spawnSync('git', [
+        'log',
+        '-n1',
+        '--oneline',
+        path.join('.', 'tests', pattern),
+      ]).stdout.toString();
+      return {
+        patternName: pattern,
+        title: allTestsForPattern[pattern][0].title,
+        numberOfTests: allTestsForPattern[pattern].length,
+        commit: lastCommit.split(' ')[0],
+        commitDescription: lastCommit,
+      };
+    })
+    .sort((a, b) => {
+      const titleA = a.title.toUpperCase();
+      const titleB = b.title.toUpperCase();
+
+      if (titleA < titleB) return -1;
+      if (titleA > titleB) return 1;
+      return 0;
+    }),
 });
 
 fse.writeFileSync(indexFileBuildOutputPath, renderedIndex);
diff --git a/scripts/v2maker.js b/scripts/v2maker.js
index 5797d6810..cd7668b47 100644
--- a/scripts/v2maker.js
+++ b/scripts/v2maker.js
@@ -210,11 +210,12 @@ async function makeAssertionsCsvData(allInputCsvData) {
   // Separate p1 and p2 assertions.
   let p1assertions = assertions.filter(assertion => !assertion.includes('2:'));
   let p2assertions = assertions.filter(assertion => assertion.includes('2:'));
-  // Remove the prefixes from the p2 assertions.
+  // Remove the prefixes from the assertions.
+  p1assertions = p1assertions.map(assertion => assertion.replace('1:', ''));
   p2assertions = p2assertions.map(assertion => assertion.replace('2:', ''));
   // Get rid of duplicates.
-  p1assertions = [...new Set(p1assertions)];
-  p2assertions = [...new Set(p2assertions)];
+  p1assertions = [...new Set(p1assertions.map(a => a.replace(/\s+/g, ' ').trim()))];
+  p2assertions = [...new Set(p2assertions.map(a => a.replace(/\s+/g, ' ').trim()))];
   // Remove p1 assertions that are the same as a p2 assertion.
   for (const p2assertion of p2assertions) {
     if (p1assertions.includes(p2assertion)) {
@@ -326,7 +327,11 @@ async function makeTestsCsvData(allInputCsvData, assertionRows) {
       if (colName.startsWith('assertion')) {
         if (row[colName].trim() !== '') {
           // Remove priority prefix if present.
-          const v1assertion = row[colName].replace('2:', '');
+          const v1assertion = row[colName]
+            .replace('1:', '')
+            .replace('2:', '')
+            .replace(/\s+/g, ' ')
+            .trim();
           // get the v2 assertion Id and add it to the assertions string. Do lookups and comparisons using lowercase. Keeping the original case for the log in the event the assertion is not found.
           if (assertionStatementsToIds.has(v1assertion.toLowerCase())) {
             assertions += ` ${assertionStatementsToIds.get(v1assertion.toLowerCase())}`;
@@ -354,7 +359,7 @@ async function makeTestsCsvData(allInputCsvData, assertionRows) {
     return 0;
   });
 
-  /* 
+  /*
     We will be filtering testRows to keep only the rows for the VoiceOver tests. We want to get rid of all the tests that specify reading mode or interaction mode.
     However, before removing those obsolete tests, there is some data we need to collect from them:
     1. A map of all the v1 testIds to v2 testIds to use during conversion of commands.csv.
@@ -374,15 +379,21 @@ async function makeTestsCsvData(allInputCsvData, assertionRows) {
   const v1tasks = new Set(allInputCsvData.v1tests.map(row => row.task));
   // iterate through the tasks and compare the VoiceOver assertions to the the JAWS and NVDA assertions.
   for (const task of v1tasks) {
-    // Find the v1testId for the VoiceOver test for this task in the v1testRows array.
-    const voiceOverV1TestId = allInputCsvData.v1tests.find(
+    let voiceOverV1TestId;
+    let voiceOverAssertions;
+    const voiceOverV1 = allInputCsvData.v1tests.find(
       row => row.task === task && row.appliesTo.toLowerCase().includes('voiceover')
-    ).testId;
-    // Use the v1testId to extract the VoiceOver assertions column for this task from the v2testRows. It contains a space-delimited set of assertionIds.
-    // Note that the v1testId was stored in the presentationNumber property in v2testRows.
-    const voiceOverAssertions = v2testRows.find(
-      row => row.presentationNumber === voiceOverV1TestId
-    ).assertions;
+    );
+    if (voiceOverV1) {
+      // Find the v1testId for the VoiceOver test for this task in the v1testRows array.
+      voiceOverV1TestId = voiceOverV1.testId;
+
+      // Use the v1testId to extract the VoiceOver assertions column for this task from the v2testRows. It contains a space-delimited set of assertionIds.
+      // Note that the v1testId was stored in the presentationNumber property in v2testRows.
+      voiceOverAssertions = v2testRows.find(
+        row => row.presentationNumber === voiceOverV1TestId
+      ).assertions;
+    }
     // Get array of v1testIds for JAWS and NVDA for this task.
     const jawsAndNvdaV1testIds = allInputCsvData.v1tests
       .filter(row => row.task === task && row.appliesTo.toLowerCase().search(/jaws|nvda/) >= 0)
@@ -393,7 +404,7 @@ async function makeTestsCsvData(allInputCsvData, assertionRows) {
         .assertions.split(' ');
       let loggedWarnings = '';
       for (const assertion of jawsAndNvdaAssertions) {
-        if (!voiceOverAssertions.includes(assertion)) {
+        if (voiceOverAssertions && !voiceOverAssertions.includes(assertion)) {
           if (!loggedWarnings.includes(assertion)) {
             const v2testId = v2testRows.find(row => row.presentationNumber === v1testId).testId;
             const msg =
@@ -408,7 +419,8 @@ async function makeTestsCsvData(allInputCsvData, assertionRows) {
     }
   }
 
-  // Now filter v2testRows down to just the VoiceOver rows.
+  // Now filter v2testRows down to just the VoiceOver rows (because they don't
+  // specify the reading or interaction mode).
   // First, get an array of just the voiceOver rows from v1tests.
   const v1voiceOverRows = allInputCsvData.v1tests.filter(row =>
     row.appliesTo.toLowerCase().includes('voiceover')
@@ -416,7 +428,32 @@ async function makeTestsCsvData(allInputCsvData, assertionRows) {
   // Build a set  of the v1 testIds for the VoiceOver tests.
   const voiceOverV1testIds = new Set(v1voiceOverRows.map(row => row.testId));
   // Filter v2testRows. Note that the presentationNumber property contains the v1testId.
-  v2testRows = v2testRows.filter(row => voiceOverV1testIds.has(row.presentationNumber));
+  const v2voiceOverTestRows = v2testRows.filter(row =>
+    voiceOverV1testIds.has(row.presentationNumber)
+  );
+
+  // Needs to also cover cases where there are tests which have no matching
+  // voiceover tests (for jaws, nvda). Eg. form test 19 and 20 from v1
+  const v2uniqueVoiceOverTestIds = v2voiceOverTestRows.map(({ testId }) => testId);
+  const unhandledV2testRows = v2testRows.filter(
+    row => !v2uniqueVoiceOverTestIds.includes(row.testId)
+  );
+
+  const v2uniqueNonVoiceOverTestRows = [];
+  const v2NonVoiceOverFoundTestIds = new Set();
+
+  for (const row of unhandledV2testRows) {
+    if (!v2NonVoiceOverFoundTestIds.has(row.testId)) {
+      v2uniqueNonVoiceOverTestRows.push({
+        ...row,
+        // Need to manually update these instances
+        title: row.title.replace('in reading mode', '').replace('in interaction mode', '').trim(),
+        instructions: row.instructions.replace('the reading cursor', 'focus'),
+      });
+      v2NonVoiceOverFoundTestIds.add(row.testId);
+    }
+  }
+  v2testRows = [...v2voiceOverTestRows, ...v2uniqueNonVoiceOverTestRows];
 
   // Write rows to CSV file
   const rowWriter = createCsvWriter({
@@ -430,7 +467,7 @@ async function makeTestsCsvData(allInputCsvData, assertionRows) {
 }
 
 async function makeCommandsCsvData(allInputCsvData, v1ToV2testIds) {
-  /* 
+  /*
     The V1 columns are:
     testId,task,mode,at,commandA,commandB,commandC...
     The V2 columns are:
@@ -479,22 +516,34 @@ async function makeCommandsCsvData(allInputCsvData, v1ToV2testIds) {
 
       // Make a new row for each command.
       for (const [index, command] of commands.entries()) {
-        let newRow = {};
-        newRow.testId = v1ToV2testIds.get(row.testId);
-        const { commandSequence, commandSettings } = util.translateCommand(
-          screenReader,
-          command,
-          allInputCsvData.commandSubstitutions
-        );
-        newRow.command = commandSequence;
-        if (commandSettings.trim() !== '') newRow.settings = commandSettings;
-        else if (row.mode.toLowerCase().includes('reading')) newRow.settings = readingModeSetting;
-        else if (row.mode.toLowerCase().includes('interaction'))
-          newRow.settings = interactionModeSetting;
-        else newRow.settings = '';
-        newRow.assertionExceptions = '';
-        newRow.presentationNumber = (Number(row.testId) + 0.1 * index).toFixed(1);
-        v2commandRows.push(newRow);
+        let splitValue = ' ';
+        // Create additional rows in the instance of `commandSeq1 / commandSeq2`.
+        // For eg. F / Shift + F and is defined as F_AND_SHIFT_F in keys.mjs
+        if (command.includes('_AND_')) splitValue = '_AND_';
+        // Create additional rows in the instance of `commandSeq1 (or commandSeq2)`.
+        // For eg. Insert+F7 (or CapsLock+F7) and is defined as INS_F7_OR_CAPS_F7 in keys.mjs
+        if (command.includes('_OR_')) splitValue = '_OR_';
+
+        for (const [_index, _command] of command.split(splitValue).entries()) {
+          let newRow = {};
+          newRow.testId = v1ToV2testIds.get(row.testId);
+          const { commandSequence, commandSettings } = util.translateCommand(
+            screenReader,
+            _command,
+            allInputCsvData.commandSubstitutions
+          );
+          newRow.command = commandSequence;
+          if (commandSettings.trim() !== '') newRow.settings = commandSettings.trim();
+          else if (row.mode.toLowerCase().includes('reading')) newRow.settings = readingModeSetting;
+          else if (row.mode.toLowerCase().includes('interaction'))
+            newRow.settings = interactionModeSetting;
+          else newRow.settings = '';
+          newRow.assertionExceptions = '';
+          const isAdditionalCommand = command.includes(splitValue);
+          const control = isAdditionalCommand ? index + index : index;
+          newRow.presentationNumber = (Number(row.testId) + 0.1 * (control + _index)).toFixed(1);
+          v2commandRows.push(newRow);
+        }
       }
     }
 
diff --git a/scripts/v2makerUtil.js b/scripts/v2makerUtil.js
index 00742de8b..64b841131 100644
--- a/scripts/v2makerUtil.js
+++ b/scripts/v2makerUtil.js
@@ -157,7 +157,22 @@ function translateCommand(screenReader, commandSequence, substitutions) {
     commandSequence = newCommandSequence.join(' ');
     if (newCommandSettings.length > 0) commandSettings = newCommandSettings.join(' ');
   }
-  commandSequence = commandSequence.replaceAll('_', '+');
+  commandSequence = commandSequence
+    .replaceAll('_', '+')
+    .replaceAll('one', '1')
+    .replaceAll('two', '2')
+    .replaceAll('caps', 'capsLock')
+    .replaceAll('page+up', 'pageUp')
+    .replaceAll('page+down', 'pageDown')
+    .replaceAll('numpad+5', 'numpad5')
+    .replaceAll('numpad+6', 'numpad6')
+    .replaceAll('UP', 'up')
+    .replaceAll('DOWN', 'down')
+    .replaceAll('LEFT', 'left')
+    .replaceAll('RIGHT', 'right')
+    .replaceAll('+then+', ' ')
+    .replaceAll('(with smart navigation on)', '')
+    .trim();
   return { commandSequence, commandSettings };
 }
 
diff --git a/tests/resources/aria-at-harness.mjs b/tests/resources/aria-at-harness.mjs
index b95489bc7..769547871 100644
--- a/tests/resources/aria-at-harness.mjs
+++ b/tests/resources/aria-at-harness.mjs
@@ -8,7 +8,12 @@ import {
   focus,
   render,
 } from './vrender.mjs';
-import { userCloseWindow, userOpenWindow, WhitespaceStyleMap } from './aria-at-test-run.mjs';
+import {
+  AssertionResultMap,
+  userCloseWindow,
+  userOpenWindow,
+  WhitespaceStyleMap,
+} from './aria-at-test-run.mjs';
 import { TestRunExport, TestRunInputOutput } from './aria-at-test-io-format.mjs';
 import { TestWindow } from './aria-at-test-window.mjs';
 
@@ -39,6 +44,14 @@ const PAGE_STYLES = `
    margin-left: 1em;
   }
 
+  fieldset.assertions {
+    margin-bottom: 1em;
+  }
+
+  label.assertion {
+    display: block;
+  }
+
   .required:not(.highlight-required) {
     display: none;
   }
@@ -77,9 +90,11 @@ testRunIO.setScriptsInputFromMap(typeof scripts === 'object' ? scripts : {});
 /**
  * @param {SupportJSON} newSupport
  * @param {CommandsJSON} newCommandsData
+ * @param {AllCommandsJSON} allCommands
  */
-export function initialize(newSupport, newCommandsData) {
+export function initialize(newSupport, newCommandsData, allCommands) {
   testRunIO.setSupportInputFromJSON(newSupport);
+  testRunIO.setAllCommandsInputFromJSON(allCommands);
   testRunIO.setConfigInputFromQueryParamsAndSupport(
     Array.from(new URL(document.location).searchParams)
   );
@@ -99,8 +114,12 @@ export function verifyATBehavior(atBehavior) {
 }
 
 export async function loadCollectedTestAsync(testRoot, testFileName) {
+  const commandsJsonResponse = await fetch(`../commands.json`);
+  const commandsJson = await commandsJsonResponse.json();
+
   const collectedTestResponse = await fetch(`${testRoot}/${testFileName}`);
   const collectedTestJson = await collectedTestResponse.json();
+  testRunIO.setAllCommandsInputFromJSON(commandsJson);
   await testRunIO.setInputsFromCollectedTestAsync(collectedTestJson, testRoot);
   testRunIO.setConfigInputFromQueryParamsAndSupport([
     ['at', collectedTestJson.target.at.key],
@@ -222,6 +241,7 @@ const br = bind(element, 'br');
 const button = bind(element, 'button');
 const div = bind(element, 'div');
 const em = bind(element, 'em');
+const kbd = bind(element, 'kbd');
 const fieldset = bind(element, 'fieldset');
 const h1 = bind(element, 'h1');
 const h2 = bind(element, 'h2');
@@ -270,6 +290,8 @@ function rich(value) {
     return value;
   } else if (Array.isArray(value)) {
     return fragment(...value.map(rich));
+  } else if (value.kbd) {
+    return kbd.bind(value.kbd)(rich(value.kbd));
   } else {
     if ('whitespace' in value) {
       if (value.whitespace === WhitespaceStyleMap.LINE_BREAK) {
@@ -373,12 +395,9 @@ function renderVirtualInstructionDocument(doc) {
           )
         )
       ),
-      table(
-        tr(
-          th(rich(command.assertionsHeader.descriptionHeader)),
-          th(rich(command.assertionsHeader.passHeader)),
-          th(rich(command.assertionsHeader.failHeader))
-        ),
+      fieldset(
+        className(['assertions']),
+        legend(rich(command.assertionsHeader.descriptionHeader)),
         ...command.assertions.map(bind(commandResultAssertion, commandIndex))
       ),
       ...[command.unexpectedBehaviors].map(bind(commandResultUnexpectedBehavior, commandIndex))
@@ -470,26 +489,15 @@ function renderVirtualInstructionDocument(doc) {
    * @param {number} assertionIndex
    */
   function commandResultAssertion(commandIndex, assertion, assertionIndex) {
-    return tr(
-      td(rich(assertion.description)),
-      td(
-        ...[assertion.passChoice].map(choice =>
-          radioChoice(
-            `pass-${commandIndex}-${assertionIndex}`,
-            `result-${commandIndex}-${assertionIndex}`,
-            choice
-          )
-        )
+    return label(
+      className(['assertion']),
+      input(
+        type('checkbox'),
+        id(`cmd-${commandIndex}-${assertionIndex}`),
+        checked(assertion.passed === AssertionResultMap.PASS),
+        onclick(assertion.click)
       ),
-      td(
-        ...assertion.failChoices.map((choice, failIndex) =>
-          radioChoice(
-            `${failIndex === 0 ? 'missing' : 'fail'}-${commandIndex}-${assertionIndex}`,
-            `result-${commandIndex}-${assertionIndex}`,
-            choice
-          )
-        )
-      )
+      rich(assertion.description)
     );
   }
 
@@ -599,6 +607,7 @@ function renderVirtualResultsTable(results) {
 }
 
 /** @typedef {import('./aria-at-test-io-format.mjs').SupportJSON} SupportJSON */
+/** @typedef {import('./aria-at-test-io-format.mjs').AllCommandsJSON} AllCommandsJSON */
 /** @typedef {import('./aria-at-test-io-format.mjs').CommandsJSON} CommandsJSON */
 /** @typedef {import('./aria-at-test-io-format.mjs').BehaviorJSON} BehaviorJSON */
 
diff --git a/tests/resources/aria-at-test-io-format.mjs b/tests/resources/aria-at-test-io-format.mjs
index d28852e0f..d967c7392 100644
--- a/tests/resources/aria-at-test-io-format.mjs
+++ b/tests/resources/aria-at-test-io-format.mjs
@@ -3,12 +3,12 @@
 /// <reference path="./types/aria-at-test-result.js" />
 
 import {
-  HasUnexpectedBehaviorMap,
+  AssertionResultMap,
+  CommonResultMap,
   createEnumMap,
+  HasUnexpectedBehaviorMap,
   TestRun,
-  AssertionResultMap,
   UserActionMap,
-  CommonResultMap,
 } from './aria-at-test-run.mjs';
 import * as keysModule from './keys.mjs';
 
@@ -145,13 +145,146 @@ class SupportInput {
    */
   static fromCollectedTest(collectedTest) {
     return new SupportInput({
-      ats: [{ key: collectedTest.target.at.key, name: collectedTest.target.at.name }],
+      ats: [
+        typeof collectedTest.target.at.raw === 'object'
+          ? collectedTest.target.at.raw
+          : { key: collectedTest.target.at.key, name: collectedTest.target.at.name },
+      ],
       applies_to: {},
       examples: [],
     });
   }
 }
 
+class AllCommandsInput {
+  /**
+   * @param {AllCommandsJSON} value
+   * @private
+   */
+  constructor(value) {
+    this.errors = [];
+
+    /** @private */
+    this._value = value;
+
+    /** @private */
+    this._flattened = this.flattenObject(this._value);
+  }
+
+  flattenObject(obj, parentKey) {
+    const flattened = {};
+
+    for (const key in obj) {
+      if (typeof obj[key] === 'object') {
+        const subObject = this.flattenObject(obj[key], parentKey + key + '.');
+        Object.assign(flattened, subObject);
+      } else {
+        flattened[parentKey + key] = obj[key];
+      }
+    }
+
+    return flattened;
+  }
+
+  findValueByKey(keyToFind) {
+    const keys = Object.keys(this._flattened);
+
+    // Need to specially handle VO modifier key combination
+    if (keyToFind === 'vo')
+      return this.findValuesByKeys([this._flattened['modifierAliases.vo']])[0];
+
+    if (keyToFind.includes('modifiers.') || keyToFind.includes('keys.')) {
+      const parts = keyToFind.split('.');
+      const keyToCheck = parts[parts.length - 1]; // value after the '.'
+
+      if (this._flattened[keyToFind])
+        return {
+          value: this._flattened[keyToFind],
+          key: keyToCheck,
+        };
+
+      return null;
+    }
+
+    for (const key of keys) {
+      const parts = key.split('.');
+      const parentKey = parts[0];
+      const keyToCheck = parts[parts.length - 1]; // value after the '.'
+
+      if (keyToCheck === keyToFind) {
+        if (parentKey === 'modifierAliases') {
+          return this.findValueByKey(`modifiers.${this._flattened[key]}`);
+        } else if (parentKey === 'keyAliases') {
+          return this.findValueByKey(`keys.${this._flattened[key]}`);
+        }
+
+        return {
+          value: this._flattened[key],
+          key: keyToCheck,
+        };
+      }
+    }
+
+    // Return null if the key is not found
+    return null;
+  }
+
+  findValuesByKeys(keysToFind = []) {
+    const result = [];
+
+    const patternSepWithReplacement = (keyToFind, pattern, replacement) => {
+      if (keyToFind.includes(pattern)) {
+        let value = '';
+        let validKeys = true;
+        const keys = keyToFind.split(pattern);
+
+        for (const key of keys) {
+          const keyResult = this.findValueByKey(key);
+          if (keyResult)
+            value = value ? `${value}${replacement}${keyResult.value}` : keyResult.value;
+          else validKeys = false;
+        }
+        if (validKeys) return { value, key: keyToFind };
+      }
+
+      return null;
+    };
+
+    const patternSepHandler = keyToFind => {
+      let value = '';
+
+      if (keyToFind.includes(' ') && keyToFind.includes('+')) {
+        const keys = keyToFind.split(' ');
+        for (let [index, key] of keys.entries()) {
+          const keyToFindResult = this.findValueByKey(key);
+          if (keyToFindResult) keys[index] = keyToFindResult.value;
+          if (key.includes('+')) keys[index] = patternSepWithReplacement(key, '+', '+').value;
+        }
+        value = keys.join(' then ');
+
+        return { value, key: keyToFind };
+      } else if (keyToFind.includes(' '))
+        return patternSepWithReplacement(keyToFind, ' ', ' then ');
+      else if (keyToFind.includes('+')) return patternSepWithReplacement(keyToFind, '+', '+');
+    };
+
+    for (const keyToFind of keysToFind) {
+      if (keyToFind.includes(' ') || keyToFind.includes('+')) {
+        result.push(patternSepHandler(keyToFind));
+      } else {
+        const keyToFindResult = this.findValueByKey(keyToFind);
+        if (keyToFindResult) result.push(keyToFindResult);
+      }
+    }
+
+    return result;
+  }
+
+  static fromJSON(json) {
+    return new AllCommandsInput(json);
+  }
+}
+
 /** Depends on ConfigInput and KeysInput. */
 class CommandsInput {
   /**
@@ -159,9 +292,10 @@ class CommandsInput {
    * @param {CommandsJSON} value.commands
    * @param {ATJSON} value.at
    * @param {KeysInput} keysInput
+   * @param {AllCommandsInput} allCommandsInput
    * @private
    */
-  constructor(value, keysInput) {
+  constructor(value, keysInput, allCommandsInput) {
     this.errors = [];
 
     /** @private */
@@ -169,27 +303,42 @@ class CommandsInput {
 
     /** @private */
     this._keysInput = keysInput;
+
+    this._allCommandsInput = allCommandsInput;
   }
 
   /**
-   * @param {string} task
-   * @param {ATMode} atMode
+   * @param {object} config
+   * @param {string} config.task
+   * @param {ATMode} mode
    * @returns {string[]}
    */
-  getCommands(task, atMode) {
+  getCommands({ task }, mode) {
+    if (mode === 'reading' || mode === 'interaction') {
+      const v1Commands = this.getCommandsV1(task, mode);
+      return {
+        commands: v1Commands,
+        commandsAndSettings: v1Commands.map(command => ({ command })),
+      };
+    } else {
+      return this.getCommandsV2({ task }, mode);
+    }
+  }
+
+  getCommandsV1(task, mode) {
     const assistiveTech = this._value.at;
 
     if (!this._value.commands[task]) {
       throw new Error(
         `Task "${task}" does not exist, please add to at-commands or correct your spelling.`
       );
-    } else if (!this._value.commands[task][atMode]) {
+    } else if (!this._value.commands[task][mode]) {
       throw new Error(
-        `Mode "${atMode}" instructions for task "${task}" does not exist, please add to at-commands or correct your spelling.`
+        `Mode "${mode}" instructions for task "${task}" does not exist, please add to at-commands or correct your spelling.`
       );
     }
 
-    let commandsData = this._value.commands[task][atMode][assistiveTech.key] || [];
+    let commandsData = this._value.commands[task][mode][assistiveTech.key] || [];
     let commands = [];
 
     for (let c of commandsData) {
@@ -199,7 +348,7 @@ class CommandsInput {
         command = this._keysInput.keysForCommand(command);
         if (typeof command === 'undefined') {
           throw new Error(
-            `Key instruction identifier "${c}" for AT "${assistiveTech.name}", mode "${atMode}", task "${task}" is not an available identified. Update you commands.json file to the correct identifier or add your identifier to resources/keys.mjs.`
+            `Key instruction identifier "${c}" for AT "${assistiveTech.name}", mode "${mode}", task "${task}" is not an available identified. Update you commands.json file to the correct identifier or add your identifier to resources/keys.mjs.`
           );
         }
 
@@ -213,14 +362,71 @@ class CommandsInput {
     return commands;
   }
 
+  getCommandsV2({ task }, mode) {
+    const assistiveTech = this._value.at;
+    let commandsAndSettings = [];
+    let commands = [];
+
+    // Mode could be in the format of mode1_mode2
+    // If they are from the same AT, this needs to return the function in the format of [ [[commands], settings], [[commands], settings], ... ]
+    for (const _atMode of mode.split('_')) {
+      if (assistiveTech.settings[_atMode] || _atMode === 'defaultMode') {
+        const [atMode] = deriveModeWithTextAndInstructions(_atMode, assistiveTech);
+
+        if (!this._value.commands[task]) {
+          throw new Error(
+            `Task "${task}" does not exist, please add to at-commands or correct your spelling.`
+          );
+        } else if (!this._value.commands[task][atMode]) {
+          throw new Error(
+            `Mode "${atMode}" instructions for task "${task}" does not exist, please add to at-commands or correct your spelling.`
+          );
+        }
+
+        let commandsData = this._value.commands[task][atMode][assistiveTech.key] || [];
+        for (let commandSequence of commandsData) {
+          for (const commandWithPresentationNumber of commandSequence) {
+            const [commandId, presentationNumber] = commandWithPresentationNumber.split('|');
+
+            let command;
+            const foundCommandKV = this._allCommandsInput.findValuesByKeys([commandId]);
+            if (!foundCommandKV.length) command = undefined;
+            else {
+              const { value } = this._allCommandsInput.findValuesByKeys([commandId])[0];
+              command = value;
+            }
+
+            if (typeof command === 'undefined') {
+              throw new Error(
+                `Key instruction identifier "${commandSequence}" for AT "${assistiveTech.name}", mode "${atMode}", task "${task}" is not an available identified. Update your commands.json file to the correct identifier or add your identifier to resources/keys.mjs.`
+              );
+            }
+
+            commands.push(command);
+            commandsAndSettings.push({
+              command,
+              settings: _atMode,
+              settingsText: assistiveTech.settings?.[_atMode]?.screenText || 'default mode active',
+              settingsInstructions: assistiveTech.settings?.[_atMode]?.instructions || [
+                assistiveTech.defaultConfigurationInstructionsHTML,
+              ],
+            });
+          }
+        }
+      }
+    }
+
+    return { commands, commandsAndSettings };
+  }
+
   /**
    * @param {CommandsJSON} json
    * @param {object} data
    * @param {ConfigInput} data.configInput
    * @param {KeysInput} data.keysInput
    */
-  static fromJSONAndConfigKeys(json, { configInput, keysInput }) {
-    return new CommandsInput({ commands: json, at: configInput.at() }, keysInput);
+  static fromJSONAndConfigKeys(json, { configInput, keysInput, allCommandsInput }) {
+    return new CommandsInput({ commands: json, at: configInput.at() }, keysInput, allCommandsInput);
   }
 
   /**
@@ -228,21 +434,42 @@ class CommandsInput {
    * @param {object} data
    * @param {KeysInput} data.keysInput
    */
-  static fromCollectedTestKeys(collectedTest, { keysInput }) {
+  static fromCollectedTestKeys(collectedTest, { keysInput, allCommandsInput }) {
+    let settingsForTest = {};
+
+    // For v2 test format
+    const settings = collectedTest.target.at.settings;
+    if (settings) {
+      for (const _atMode of settings.split('_')) {
+        settingsForTest[_atMode] = {
+          // Use settings attribute to verify in filter if available
+          [collectedTest.target.at.key]: collectedTest.commands
+            .filter(({ settings }) => (settings ? settings === _atMode : true))
+            .map(({ id, extraInstruction }) => (extraInstruction ? [id, extraInstruction] : [id])),
+        };
+      }
+    } else {
+      settingsForTest = {
+        [collectedTest.target.mode]: {
+          [collectedTest.target.at.key]: collectedTest.commands.map(({ id, extraInstruction }) =>
+            extraInstruction ? [id, extraInstruction] : [id]
+          ),
+        },
+      };
+    }
+
     return new CommandsInput(
       {
         commands: {
-          [collectedTest.info.task]: {
-            [collectedTest.target.mode]: {
-              [collectedTest.target.at.key]: collectedTest.commands.map(
-                ({ id, extraInstruction }) => (extraInstruction ? [id, extraInstruction] : [id])
-              ),
-            },
-          },
+          [collectedTest.info.task || collectedTest.info.testId]: settingsForTest,
         },
-        at: collectedTest.target.at,
+        at:
+          typeof collectedTest.target.at.raw === 'object'
+            ? collectedTest.target.at.raw
+            : collectedTest.target.at,
       },
-      keysInput
+      keysInput,
+      allCommandsInput
     );
   }
 }
@@ -538,6 +765,8 @@ class BehaviorInput {
     const mode = Array.isArray(json.mode) ? json.mode[0] : json.mode;
     const at = configInput.at();
 
+    const { commandsAndSettings } = commandsInput.getCommands({ task: json.task }, mode);
+
     return new BehaviorInput({
       behavior: {
         description: titleInput.title(),
@@ -548,11 +777,24 @@ class BehaviorInput {
         specificUserInstruction: json.specific_user_instruction,
         setupScriptDescription: json.setup_script_description,
         setupTestPage: json.setupTestPage,
-        commands: commandsInput.getCommands(json.task, mode),
-        assertions: (json.output_assertions ? json.output_assertions : []).map(assertionTuple => ({
-          priority: Number(assertionTuple[0]),
-          assertion: assertionTuple[1],
-        })),
+        assertionResponseQuestion: json.assertionResponseQuestion,
+        commands: commandsAndSettings,
+        assertions: (json.output_assertions ? json.output_assertions : []).map(assertion => {
+          // Tuple array [ priorityNumber, assertionText ]
+          if (Array.isArray(assertion)) {
+            return {
+              priority: Number(assertion[0]),
+              assertion: assertion[1],
+            };
+          }
+
+          // { assertionId, priority, assertionStatement, assertionPhrase, refIds, commandInfo, tokenizedAssertionStatements }
+          return {
+            priority: assertion.priority,
+            assertion:
+              assertion.tokenizedAssertionStatements?.[at.key] || assertion.assertionStatement,
+          };
+        }),
         additionalAssertions: (json.additional_assertions
           ? json.additional_assertions[at.key] || []
           : []
@@ -576,21 +818,36 @@ class BehaviorInput {
     { info, target, instructions, assertions },
     { commandsInput, keysInput, unexpectedInput }
   ) {
+    // v1:info.task, v2: info.testId | v1:target.mode, v2:target.at.settings
+    const { commandsAndSettings } = commandsInput.getCommands(
+      { task: info.task || info.testId },
+      target.mode || target.at.settings
+    );
+
     return new BehaviorInput({
       behavior: {
         description: info.title,
-        task: info.task,
-        mode: target.mode,
+        task: info.task || info.testId,
+        mode: target.mode || target.at.settings,
         modeInstructions: instructions.mode,
         appliesTo: [target.at.name],
-        specificUserInstruction: instructions.raw,
+        specificUserInstruction: instructions.raw || instructions.instructions,
         setupScriptDescription: target.setupScript ? target.setupScript.description : '',
         setupTestPage: target.setupScript ? target.setupScript.name : undefined,
-        commands: commandsInput.getCommands(info.task, target.mode),
-        assertions: assertions.map(({ priority, expectation: assertion }) => ({
-          priority,
-          assertion,
-        })),
+        commands: commandsAndSettings,
+        assertions: assertions.map(
+          ({ priority, expectation, assertionStatement, tokenizedAssertionStatements }) => {
+            let assertion = tokenizedAssertionStatements
+              ? tokenizedAssertionStatements[target.at.key]
+              : null;
+            assertion = assertion || expectation || assertionStatement;
+
+            return {
+              priority,
+              assertion,
+            };
+          }
+        ),
         additionalAssertions: [],
         unexpectedBehaviors: unexpectedInput.behaviors(),
       },
@@ -637,6 +894,8 @@ export class TestRunInputOutput {
     this.scriptsInput = null;
     /** @type {SupportInput} */
     this.supportInput = null;
+    /** @type {AllCommandsInput} */
+    this.allCommandsInput = null;
     /** @type {TitleInput} */
     this.titleInput = null;
     /** @type {UnexpectedInput} */
@@ -710,7 +969,11 @@ export class TestRunInputOutput {
 
     const unexpectedInput = UnexpectedInput.fromBuiltin();
     const keysInput = KeysInput.fromCollectedTest(collectedTest);
-    const commandsInput = CommandsInput.fromCollectedTestKeys(collectedTest, { keysInput });
+    const allCommandsInput = this.allCommandsInput;
+    const commandsInput = CommandsInput.fromCollectedTestKeys(collectedTest, {
+      keysInput,
+      allCommandsInput,
+    });
     const behaviorInput = BehaviorInput.fromCollectedTestCommandsKeysUnexpected(collectedTest, {
       commandsInput,
       keysInput,
@@ -754,6 +1017,7 @@ export class TestRunInputOutput {
       CommandsInput.fromJSONAndConfigKeys(commandsJSON, {
         configInput: this.configInput,
         keysInput: this.keysInput,
+        allCommandsInput: this.allCommandsInput,
       })
     );
   }
@@ -827,6 +1091,16 @@ export class TestRunInputOutput {
     this.setSupportInput(SupportInput.fromJSON(supportJSON));
   }
 
+  /** @param {AllCommandsInput} allCommandsInput */
+  setAllCommandsInput(allCommandsInput) {
+    this.allCommandsInput = allCommandsInput;
+  }
+
+  /** @param {AllCommandsJSON} allCommandsJSON */
+  setAllCommandsInputFromJSON(allCommandsJSON) {
+    this.setAllCommandsInput(AllCommandsInput.fromJSON(allCommandsJSON));
+  }
+
   /** @param {TitleInput} titleInput */
   setTitleInput(titleInput) {
     this.titleInput = titleInput;
@@ -871,13 +1145,26 @@ export class TestRunInputOutput {
     const test = this.behaviorInput.behavior();
     const config = this.configInput;
 
+    function unescapeHTML(input) {
+      const textarea = document.createElement('textarea');
+      textarea.innerHTML = input;
+      return textarea.value;
+    }
+
+    const [atMode, screenText, instructions] = deriveModeWithTextAndInstructions(
+      test.mode,
+      config.at()
+    );
+
     let state = {
       errors,
       info: {
         description: test.description,
         task: test.task,
-        mode: test.mode,
-        modeInstructions: test.modeInstructions,
+        mode: screenText || atMode,
+        modeInstructions: Array.isArray(instructions)
+          ? unescapeHTML(`${instructions[0]} ${instructions[1]}`)
+          : test.modeInstructions,
         userInstructions: test.specificUserInstruction.split('|'),
         setupScriptDescription: test.setupScriptDescription,
       },
@@ -890,10 +1177,17 @@ export class TestRunInputOutput {
       openTest: {
         enabled: true,
       },
+      assertionResponseQuestion: test.assertionResponseQuestion,
       commands: test.commands.map(
         command =>
           /** @type {import("./aria-at-test-run.mjs").TestRunCommand} */ ({
-            description: command,
+            description: command.command,
+            commandSettings: {
+              command: command.command,
+              description: command.settings,
+              text: command.settingsText,
+              instructions: command.settingsInstructions,
+            },
             atOutput: {
               highlightRequired: false,
               value: '',
@@ -1176,7 +1470,7 @@ export class TestRunInputOutput {
                 ? 'failIncorrect'
                 : assertionResult.failedReason === 'NO_OUTPUT'
                 ? 'failMissing'
-                : 'notSet',
+                : 'fail',
             };
           }),
           unexpected: {
@@ -1257,6 +1551,7 @@ export class TestRunExport extends TestRun {
 
 const AssertionPassJSONMap = createEnumMap({
   GOOD_OUTPUT: 'Good Output',
+  PASS: 'Pass',
 });
 
 /**
@@ -1278,6 +1573,7 @@ const AssertionFailJSONMap = createEnumMap({
   NO_OUTPUT: 'No Output',
   INCORRECT_OUTPUT: 'Incorrect Output',
   NO_SUPPORT: 'No Support',
+  FAIL: 'Fail',
 });
 
 /** @typedef {SubmitResultDetailsCommandsAssertionsPass | SubmitResultDetailsCommandsAssertionsFail} SubmitResultAssertionsJSON */
@@ -1312,6 +1608,36 @@ const StatusJSONMap = createEnumMap({
   FAIL: 'FAIL',
 });
 
+/**
+ *
+ * @param {ATMode} mode
+ * @param {ATJSON} at
+ * @returns {[ATMode, string, [string]]}
+ */
+function deriveModeWithTextAndInstructions(mode, at) {
+  let atMode = mode;
+  let screenText = '';
+  let instructions = [];
+
+  if (mode.includes('_')) {
+    const atModes = mode.split('_');
+    for (const _atMode of atModes) {
+      if (at.settings[_atMode]) {
+        atMode = _atMode;
+        screenText = at.settings[_atMode].screenText;
+        instructions = at.settings[_atMode].instructions;
+      }
+    }
+  } else {
+    if (at.settings && at.settings[atMode]) {
+      screenText = at.settings[atMode]?.screenText;
+      instructions = at.settings[atMode]?.instructions;
+    }
+  }
+
+  return [atMode, screenText, instructions];
+}
+
 /**
  * @param {boolean} test
  * @param {string} message
@@ -1335,6 +1661,8 @@ function invariant(test, message, ...args) {
  * @typedef ATJSON
  * @property {string} name
  * @property {string} key
+ * @property {string} defaultConfigurationInstructionsHTML
+ * @property {object} settings
  */
 
 /**
@@ -1346,6 +1674,14 @@ function invariant(test, message, ...args) {
  * @property {string} examples[].name
  */
 
+/**
+ * @typedef AllCommandsJSON
+ * @property {object} modifiers
+ * @property {object} modifierAliases
+ * @property {object} keys
+ * @property {object} keyAliases
+ */
+
 /**
  * @typedef {([string] | [string, string])[]} CommandATJSON
  */
@@ -1368,7 +1704,15 @@ function invariant(test, message, ...args) {
  * @typedef {["at" | "showSubmitButton" | "showResults" | string, string][]} ConfigQueryParams
  */
 
-/** @typedef {"reading" | "interaction"} ATMode */
+/** @typedef {"reading" | "interaction" | "virtualCursor", "pcCursor", "browseMode" | "focusMode" | "quickNavOn" | "quickNavOff" | "defaultMode"} ATMode */
+
+/** @typedef OutputAssertion
+ *  @property {string} assertionId
+ *  @property {Number} priority
+ *  @property {string} assertionStatement
+ *  @property {string} assertionPhrase
+ *  @property {string} refIds
+ */
 
 /**
  * @typedef BehaviorJSON
@@ -1378,7 +1722,7 @@ function invariant(test, message, ...args) {
  * @property {ATMode | ATMode[]} mode
  * @property {string} task
  * @property {string} specific_user_instruction
- * @property {[string, string][]} [output_assertions]
+ * @property {[string, string][] | [OutputAssertion]} [output_assertions]
  * @property {{[atKey: string]: [number, string][]}} [additional_assertions]
  */
 
diff --git a/tests/resources/aria-at-test-run.mjs b/tests/resources/aria-at-test-run.mjs
index cfdc0b7e0..04c7fd4c4 100644
--- a/tests/resources/aria-at-test-run.mjs
+++ b/tests/resources/aria-at-test-run.mjs
@@ -97,13 +97,15 @@ export function instructionDocument(resultState, hooks) {
     ? ` and runs a script that ${resultState.info.setupScriptDescription}.`
     : resultState.info.setupScriptDescription;
   // As a hack, special case mode instructions for VoiceOver for macOS until we
-  // support modeless tests. ToDo: remove this when resolving issue #194
+  // support modeless tests.
   const modePhrase =
     resultState.config.at.name === 'VoiceOver for macOS'
       ? 'Describe '
       : `With ${resultState.config.at.name} in ${mode} mode, describe `;
 
+  // TODO: Wrap each command token in <kbd>
   const commands = resultState.commands.map(({ description }) => description);
+  const commandSettings = resultState.commands.map(({ commandSettings }) => commandSettings);
   const assertions = resultState.commands[0].assertions.map(({ description }) => description);
   const additionalAssertions = resultState.commands[0].additionalAssertions.map(
     ({ description }) => description
@@ -118,6 +120,33 @@ export function instructionDocument(resultState, hooks) {
     return false;
   }
 
+  function convertModeInstructionsToKbdArray(inputString) {
+    const container = document.createElement('div');
+    container.innerHTML = inputString;
+
+    const resultArray = [];
+    for (const node of container.childNodes) {
+      if (node.nodeName === 'KBD') {
+        // Handle <kbd> elements
+        resultArray.push({ kbd: node.innerText.trim() });
+      } else {
+        // Handle text nodes
+        resultArray.push(node.textContent);
+      }
+    }
+
+    return resultArray.length ? resultArray : null;
+  }
+
+  const convertedModeInstructions =
+    modeInstructions !== undefined && !modeInstructions.includes('undefined')
+      ? convertModeInstructionsToKbdArray(modeInstructions)
+      : null;
+
+  let strongInstructions = [...userInstructions];
+  if (convertedModeInstructions)
+    strongInstructions = [convertedModeInstructions, ...strongInstructions];
+
   return {
     errors: {
       visible: resultState.errors && resultState.errors.length > 0 ? true : false,
@@ -143,10 +172,15 @@ export function instructionDocument(resultState, hooks) {
           ],
           `Activate the "Open test page" button below, which opens the example to test in a new window${setupScriptDescription}`,
         ],
-        strongInstructions: [modeInstructions, ...userInstructions],
+        strongInstructions: strongInstructions.filter(el => el),
         commands: {
           description: `Using the following commands, ${lastInstruction}`,
-          commands,
+          commands: commands.map((command, index) => {
+            const { description: settings, text: settingsText } = commandSettings[index];
+            return `${command}${
+              settingsText && settings !== 'defaultMode' ? ` (${settingsText})` : ''
+            }`;
+          }),
         },
       },
       assertions: {
@@ -175,24 +209,6 @@ export function instructionDocument(resultState, hooks) {
       : null,
   };
 
-  /**
-   * @param {T} resultAssertion
-   * @param {T["result"]} resultValue
-   * @param {Omit<InstructionDocumentAssertionChoice, 'checked' | 'focus'>} partialChoice
-   * @returns {InstructionDocumentAssertionChoice}
-   * @template {TestRunAssertion | TestRunAdditionalAssertion} T
-   */
-  function assertionChoice(resultAssertion, resultValue, partialChoice) {
-    return {
-      ...partialChoice,
-      checked: resultAssertion.result === resultValue,
-      focus:
-        resultState.currentUserAction === 'validateResults' &&
-        resultAssertion.highlightRequired &&
-        focusFirstRequired(),
-    };
-  }
-
   /**
    * @param {string} command
    * @param {number} commandIndex
@@ -201,8 +217,15 @@ export function instructionDocument(resultState, hooks) {
   function commandResult(command, commandIndex) {
     const resultStateCommand = resultState.commands[commandIndex];
     const resultUnexpectedBehavior = resultStateCommand.unexpected;
+
+    const {
+      commandSettings: { description: settings, text: settingsText },
+    } = resultStateCommand;
+
     return {
-      header: `After '${command}'`,
+      header: `After '${command}'${
+        settingsText && settings !== 'defaultMode' ? ` (${settingsText})` : ''
+      }`,
       atOutput: {
         description: [
           `${resultState.config.at.name} output after ${command}`,
@@ -220,9 +243,9 @@ export function instructionDocument(resultState, hooks) {
         change: atOutput => hooks.setCommandOutput({ commandIndex, atOutput }),
       },
       assertionsHeader: {
-        descriptionHeader: 'Assertion',
-        passHeader: 'Success case',
-        failHeader: 'Failure cases',
+        descriptionHeader: `${resultState.assertionResponseQuestion} ${command}${
+          settingsText && settings !== 'defaultMode' ? ` (${settingsText})` : ''
+        }?`,
       },
       assertions: [
         ...assertions.map(bind(assertionResult, commandIndex)),
@@ -341,57 +364,17 @@ export function instructionDocument(resultState, hooks) {
   function assertionResult(commandIndex, assertion, assertionIndex) {
     const resultAssertion = resultState.commands[commandIndex].assertions[assertionIndex];
     return /** @type {InstructionDocumentResultsCommandsAssertion} */ ({
-      description: [
-        assertion,
-        {
-          required: true,
-          highlightRequired: resultAssertion.highlightRequired,
-          description: '(required: mark output)',
-        },
-      ],
-      passChoice: assertionChoice(resultAssertion, CommonResultMap.PASS, {
-        label: [
-          `Good Output `,
-          {
-            offScreen: true,
-            description: 'for assertion',
-          },
-        ],
-        click: () =>
-          hooks.setCommandAssertion({ commandIndex, assertionIndex, result: CommonResultMap.PASS }),
-      }),
-      failChoices: [
-        assertionChoice(resultAssertion, AssertionResultMap.FAIL_MISSING, {
-          label: [
-            `No Output `,
-            {
-              offScreen: true,
-              description: 'for assertion',
-            },
-          ],
-          click: () =>
-            hooks.setCommandAssertion({
-              commandIndex,
-              assertionIndex,
-              result: AssertionResultMap.FAIL_MISSING,
-            }),
-        }),
-        assertionChoice(resultAssertion, AssertionResultMap.FAIL_INCORRECT, {
-          label: [
-            `Incorrect Output `,
-            {
-              offScreen: true,
-              description: 'for assertion',
-            },
-          ],
-          click: () =>
-            hooks.setCommandAssertion({
-              commandIndex,
-              assertionIndex,
-              result: AssertionResultMap.FAIL_INCORRECT,
-            }),
+      description: [assertion],
+      passed: resultAssertion.result === AssertionResultMap.PASS,
+      click: () =>
+        hooks.setCommandAssertion({
+          commandIndex,
+          assertionIndex,
+          result:
+            resultAssertion.result === AssertionResultMap.PASS
+              ? AssertionResultMap.FAIL
+              : AssertionResultMap.PASS,
         }),
-      ],
     });
   }
 
@@ -404,34 +387,17 @@ export function instructionDocument(resultState, hooks) {
     const resultAdditionalAssertion =
       resultState.commands[commandIndex].additionalAssertions[assertionIndex];
     return /** @type {InstructionDocumentResultsCommandsAssertion} */ ({
-      description: [
-        assertion,
-        {
-          required: true,
-          highlightRequired: resultAdditionalAssertion.highlightRequired,
-          description: '(required: mark support)',
-        },
-      ],
-      passChoice: assertionChoice(resultAdditionalAssertion, AdditionalAssertionResultMap.PASS, {
-        label: ['Good Support ', { offScreen: true, description: 'for assertion' }],
-        click: () =>
-          hooks.setCommandAdditionalAssertion({
-            commandIndex,
-            additionalAssertionIndex: assertionIndex,
-            result: AdditionalAssertionResultMap.PASS,
-          }),
-      }),
-      failChoices: [
-        assertionChoice(resultAdditionalAssertion, AdditionalAssertionResultMap.FAIL_SUPPORT, {
-          label: ['No Support ', { offScreen: true, description: 'for assertion' }],
-          click: () =>
-            hooks.setCommandAdditionalAssertion({
-              commandIndex,
-              additionalAssertionIndex: assertionIndex,
-              result: AdditionalAssertionResultMap.FAIL_SUPPORT,
-            }),
+      description: [assertion],
+      passed: resultAdditionalAssertion.result === CommonResultMap.PASS,
+      click: () =>
+        hooks.setCommandAssertion({
+          commandIndex,
+          assertionIndex,
+          result:
+            resultAdditionalAssertion.result === AssertionResultMap.PASS
+              ? AssertionResultMap.FAIL
+              : AssertionResultMap.PASS,
         }),
-      ],
     });
   }
 }
@@ -494,6 +460,7 @@ export const AssertionResultMap = createEnumMap({
   ...CommonResultMap,
   FAIL_MISSING: 'failMissing',
   FAIL_INCORRECT: 'failIncorrect',
+  FAIL: 'fail',
 });
 
 /**
@@ -755,10 +722,6 @@ function isSomeFieldRequired(state) {
   return state.commands.some(
     command =>
       command.atOutput.value.trim() === '' ||
-      command.assertions.some(assertion => assertion.result === CommonResultMap.NOT_SET) ||
-      command.additionalAssertions.some(
-        assertion => assertion.result === CommonResultMap.NOT_SET
-      ) ||
       command.unexpected.hasUnexpected === HasUnexpectedBehaviorMap.NOT_SET ||
       (command.unexpected.hasUnexpected === HasUnexpectedBehaviorMap.HAS_UNEXPECTED &&
         (command.unexpected.behaviors.every(({ checked }) => !checked) ||
@@ -934,14 +897,6 @@ export function userValidateState() {
             ...command.atOutput,
             highlightRequired: !command.atOutput.value.trim(),
           },
-          assertions: command.assertions.map(assertion => ({
-            ...assertion,
-            highlightRequired: assertion.result === CommonResultMap.NOT_SET,
-          })),
-          additionalAssertions: command.additionalAssertions.map(assertion => ({
-            ...assertion,
-            highlightRequired: assertion.result === CommonResultMap.NOT_SET,
-          })),
           unexpected: {
             ...command.unexpected,
             highlightRequired:
@@ -1059,15 +1014,14 @@ export function userValidateState() {
 /**
  * @typedef InstructionDocumentResultsCommandsAssertion
  * @property {Description} description
- * @property {InstructionDocumentAssertionChoice} passChoice
- * @property {InstructionDocumentAssertionChoice[]} failChoices
+ * @property {Boolean} passed
+ * @property {boolean} [focus]
+ * @property {() => void} click
  */
 
 /**
  * @typedef InstructionDocumentResultsCommandsAssertionsHeader
  * @property {Description} descriptionHeader
- * @property {Description} passHeader
- * @property {Description} failHeader
  */
 
 /**
diff --git a/tests/resources/at-commands.mjs b/tests/resources/at-commands.mjs
index 1c1fdda8a..c6bbfb5a1 100644
--- a/tests/resources/at-commands.mjs
+++ b/tests/resources/at-commands.mjs
@@ -20,14 +20,20 @@ export class commandsAPI {
    *       }
    *     }
    *   }
+   * @param {object} supportJson - The data object found in `tests/support.json`
+   * @param {object} commandsJson - The data object found in `tests/commands.json`
    */
-  constructor(commands, support) {
+  constructor(commands, supportJson, commandsJson) {
     if (!commands) {
       throw new Error('You must initialize commandsAPI with a commands data object');
     }
 
-    if (!support) {
-      throw new Error('You must initialize commandsAPI with a support data object');
+    if (!supportJson) {
+      throw new Error('You must initialize commandsAPI with a supportJson data object');
+    }
+
+    if (!commandsJson) {
+      throw new Error('You must initialize commandsAPI with a commandsJson data object');
     }
 
     this.AT_COMMAND_MAP = commands;
@@ -45,46 +51,84 @@ export class commandsAPI {
       },
     };
 
-    this.support = support;
+    this.supportJson = supportJson;
+    this.commandsJson = this.flattenObject(commandsJson);
   }
 
   /**
    * Get AT-specific instruction
    * @param {string} mode - The mode of the screen reader, "reading" or "interaction"
    * @param {string} task - The task of the test.
-   * @param {string} assitiveTech - The assistive technology.
+   * @param {object} assistiveTech - The assistive technology.
    * @return {Array} - A list of commands (strings)
    */
   getATCommands(mode, task, assistiveTech) {
-    if (!this.AT_COMMAND_MAP[task]) {
-      throw new Error(
-        `Task "${task}" does not exist, please add to at-commands or correct your spelling.`
-      );
-    } else if (!this.AT_COMMAND_MAP[task][mode]) {
-      throw new Error(
-        `Mode "${mode}" instructions for task "${task}" does not exist, please add to at-commands or correct your spelling.`
-      );
-    }
-
-    let commandsData = this.AT_COMMAND_MAP[task][mode][assistiveTech.key] || [];
     let commands = [];
 
-    for (let c of commandsData) {
-      let innerCommands = [];
-      let commandSequence = c[0].split(',');
-      for (let command of commandSequence) {
-        command = keys[command];
-        if (typeof command === 'undefined') {
+    for (const _atMode of mode.split('_')) {
+      if (this.AT_COMMAND_MAP[task][_atMode][assistiveTech.key]) {
+        mode = _atMode;
+
+        if (!this.AT_COMMAND_MAP[task]) {
+          throw new Error(
+            `Task "${task}" does not exist, please add to at-commands or correct your spelling.`
+          );
+        }
+
+        if (!this.AT_COMMAND_MAP[task][mode]) {
           throw new Error(
-            `Key instruction identifier "${c}" for AT "${assistiveTech.name}", mode "${mode}", task "${task}" is not an available identified. Update you commands.json file to the correct identifier or add your identifier to resources/keys.mjs.`
+            `Mode "${mode}" instructions for task "${task}" does not exist, please add to at-commands or correct your spelling.`
           );
         }
 
-        let furtherInstruction = c[1];
-        command = furtherInstruction ? `${command} ${furtherInstruction}` : command;
-        innerCommands.push(command);
+        let commandsData = this.AT_COMMAND_MAP[task][mode][assistiveTech.key] || [];
+
+        // V1
+        if (mode === 'reading' || mode === 'interaction') {
+          for (let c of commandsData) {
+            let innerCommands = [];
+            let commandSequence = c[0].split(',');
+            for (let command of commandSequence) {
+              command = keys[command];
+              if (typeof command === 'undefined') {
+                throw new Error(
+                  `Key instruction identifier "${c}" for AT "${assistiveTech.name}", mode "${mode}", task "${task}" is not an available identifier. Update your commands.json file to the correct identifier or add your identifier to resources/keys.mjs.`
+                );
+              }
+
+              let furtherInstruction = c[1];
+              command = furtherInstruction ? `${command} ${furtherInstruction}` : command;
+              innerCommands.push(command);
+            }
+            commands.push(innerCommands.join(', then '));
+          }
+        } else {
+          // V2
+          for (let c of commandsData) {
+            const commandWithPresentationNumber = c[0];
+            const [commandId, presentationNumber] = commandWithPresentationNumber.split('|');
+
+            const commandKVs = this.findValuesByKeys([commandId]);
+            if (!commandKVs.length) {
+              throw new Error(
+                `Key instruction identifier "${commandId}" for AT "${assistiveTech.name}", mode "${mode}", task "${task}" is not an available identifier. Update your commands.json file to the correct identifier or add your identifier to tests/commands.json.`
+              );
+            }
+
+            commands.push(
+              ...commandKVs.map(({ value, key }) => {
+                value = assistiveTech.settings[mode].screenText
+                  ? `${value} (${assistiveTech.settings[mode].screenText})`
+                  : value;
+                return {
+                  value,
+                  key,
+                };
+              })
+            );
+          }
+        }
       }
-      commands.push(innerCommands.join(', then '));
     }
 
     return commands;
@@ -109,6 +153,120 @@ export class commandsAPI {
    * @return {string} - if this API knows instructions for `at`, it will return the `at` with proper capitalization
    */
   isKnownAT(at) {
-    return this.support.ats.find(o => o.key === at.toLowerCase());
+    return this.supportJson.ats.find(o => o.key === at.toLowerCase());
+  }
+
+  defaultConfigurationInstructions(at) {
+    return this.supportJson.ats.find(o => o.key === at.toLowerCase())
+      .defaultConfigurationInstructionsHTML;
+  }
+
+  flattenObject(obj, parentKey) {
+    const flattened = {};
+
+    for (const key in obj) {
+      if (typeof obj[key] === 'object') {
+        const subObject = this.flattenObject(obj[key], parentKey + key + '.');
+        Object.assign(flattened, subObject);
+      } else {
+        flattened[parentKey + key] = obj[key];
+      }
+    }
+
+    return flattened;
+  }
+
+  findValueByKey(keyToFind) {
+    const keys = Object.keys(this.commandsJson);
+
+    // Need to specially handle VO modifier key combination
+    if (keyToFind === 'vo')
+      return this.findValuesByKeys([this.commandsJson['modifierAliases.vo']])[0];
+
+    if (keyToFind.includes('modifiers.') || keyToFind.includes('keys.')) {
+      const parts = keyToFind.split('.');
+      const keyToCheck = parts[parts.length - 1]; // value after the '.'
+
+      if (this.commandsJson[keyToFind])
+        return {
+          value: this.commandsJson[keyToFind],
+          key: keyToCheck,
+        };
+
+      return null;
+    }
+
+    for (const key of keys) {
+      const parts = key.split('.');
+      const parentKey = parts[0];
+      const keyToCheck = parts[parts.length - 1]; // value after the '.'
+
+      if (keyToCheck === keyToFind) {
+        if (parentKey === 'modifierAliases') {
+          return this.findValueByKey(`modifiers.${this.commandsJson[key]}`);
+        } else if (parentKey === 'keyAliases') {
+          return this.findValueByKey(`keys.${this.commandsJson[key]}`);
+        }
+
+        return {
+          value: this.commandsJson[key],
+          key: keyToCheck,
+        };
+      }
+    }
+
+    // Return null if the key is not found
+    return null;
+  }
+
+  findValuesByKeys(keysToFind = []) {
+    const result = [];
+
+    const patternSepWithReplacement = (keyToFind, pattern, replacement) => {
+      if (keyToFind.includes(pattern)) {
+        let value = '';
+        let validKeys = true;
+        const keys = keyToFind.split(pattern);
+
+        for (const key of keys) {
+          const keyResult = this.findValueByKey(key);
+          if (keyResult)
+            value = value ? `${value}${replacement}${keyResult.value}` : keyResult.value;
+          else validKeys = false;
+        }
+        if (validKeys) return { value, key: keyToFind };
+      }
+
+      return null;
+    };
+
+    const patternSepHandler = keyToFind => {
+      let value = '';
+
+      if (keyToFind.includes(' ') && keyToFind.includes('+')) {
+        const keys = keyToFind.split(' ');
+        for (let [index, key] of keys.entries()) {
+          const keyToFindResult = this.findValueByKey(key);
+          if (keyToFindResult) keys[index] = keyToFindResult.value;
+          if (key.includes('+')) keys[index] = patternSepWithReplacement(key, '+', '+').value;
+        }
+        value = keys.join(' then ');
+
+        return { value, key: keyToFind };
+      } else if (keyToFind.includes(' '))
+        return patternSepWithReplacement(keyToFind, ' ', ' then ');
+      else if (keyToFind.includes('+')) return patternSepWithReplacement(keyToFind, '+', '+');
+    };
+
+    for (const keyToFind of keysToFind) {
+      if (keyToFind.includes(' ') || keyToFind.includes('+')) {
+        result.push(patternSepHandler(keyToFind));
+      } else {
+        const keyToFindResult = this.findValueByKey(keyToFind);
+        if (keyToFindResult) result.push(keyToFindResult);
+      }
+    }
+
+    return result;
   }
 }
diff --git a/tests/resources/keys.mjs b/tests/resources/keys.mjs
index 5d9951541..bfeff2bde 100644
--- a/tests/resources/keys.mjs
+++ b/tests/resources/keys.mjs
@@ -1,119 +1,119 @@
 // Keys
-export const CTRL_HOME                       = "Control+Home";
-export const CTRL_OPT_HOME                       = "Control+Option+Home";
-export const CTRL_END                       = "Control+End";
-export const CTRL_OPT_END                       = "Control+Option+End";
-export const CTRL_HOME_THEN_DOWN                       = "Control+Home followed by Down Arrow";
-export const DELETE                       = "Delete";
-export const ALT_DELETE                       = "Alt+Delete";
-export const ALT_DOWN                         = "Alt+Down";
-export const CTRL_ALT_DOWN                         = "Control+Alt+Down";
-export const ALT_UP                         = "Alt+Up";
-export const C_AND_SHIFT_C                    = "C / Shift+C";
-export const SHIFT_C                    = "Shift+C";
-export const CTRL_INS_X                       = "Control+Insert+X";
-export const OPT_DOWN                    = "Option+Down";
-export const OPT_UP                    = "Option+Up";
-export const CTRL_OPT_LEFT                    = "Ctrl+Option+Left";
-export const CTRL_ALT_LEFT                    = "Control+Alt+Left";
-export const CTRL_OPT_RIGHT                   = "Control+Option+Right";
-export const CTRL_ALT_RIGHT                   = "Control+Alt+Right";
-export const CTRL_OPT_UP                   = "Control+Option+Up";
-export const CTRL_OPT_DOWN                   = "Control+Option+Down";
+export const CTRL_HOME = "Control+Home";
+export const CTRL_OPT_HOME = "Control+Option+Home";
+export const CTRL_END = "Control+End";
+export const CTRL_OPT_END = "Control+Option+End";
+export const CTRL_HOME_THEN_DOWN = "Control+Home followed by Down Arrow";
+export const DELETE = "Delete";
+export const ALT_DELETE = "Alt+Delete";
+export const ALT_DOWN = "Alt+Down";
+export const CTRL_ALT_DOWN = "Control+Alt+Down";
+export const ALT_UP = "Alt+Up";
+export const C_AND_SHIFT_C = "C / Shift+C";
+export const SHIFT_C = "Shift+C";
+export const CTRL_INS_X = "Control+Insert+X";
+export const OPT_DOWN = "Option+Down";
+export const OPT_UP = "Option+Up";
+export const CTRL_OPT_LEFT = "Ctrl+Option+Left";
+export const CTRL_ALT_LEFT = "Control+Alt+Left";
+export const CTRL_OPT_RIGHT = "Control+Option+Right";
+export const CTRL_ALT_RIGHT = "Control+Alt+Right";
+export const CTRL_OPT_UP = "Control+Option+Up";
+export const CTRL_OPT_DOWN = "Control+Option+Down";
 export const CTRL_OPT_RIGHT_AND_CTRL_OPT_LEFT = "Control+Option+Right / Ctrl+Option+Left";
-export const CTRL_OPT_A                       = "Control+Option+A";
-export const CTRL_OPT_CMD_J                   = "Control+Option+Command+J";
-export const CTRL_OPT_CMD_L                   = "Control+Option+Command+L";
-export const CTRL_OPT_CMD_P                   = "Control+Option+Command+P";
-export const SHIFT_CTRL_OPT_CMD_J             = "Shift+Control+Option+Command+J";
-export const SHIFT_CTRL_OPT_CMD_L             = "Shift+Control+Option+Command+L";
+export const CTRL_OPT_A = "Control+Option+A";
+export const CTRL_OPT_CMD_J = "Control+Option+Command+J";
+export const CTRL_OPT_CMD_L = "Control+Option+Command+L";
+export const CTRL_OPT_CMD_P = "Control+Option+Command+P";
+export const SHIFT_CTRL_OPT_CMD_J = "Shift+Control+Option+Command+J";
+export const SHIFT_CTRL_OPT_CMD_L = "Shift+Control+Option+Command+L";
 export const CTRL_OPT_CMD_J_AND_SHIFT_CTRL_OPT_CMD_J = "Control+Option+Command+J / Shift+Control+Option+Command+J";
 export const CTRL_OPT_CMD_C_AND_SHIFT_CTRL_OPT_CMD_C = "Control+Option+Command+C / Shift+Control+Option+Command+C";
-export const CTRL_OPT_F3                      = "Control+Option+F3";
-export const CTRL_OPT_F4                      = "Control+Option+F4";
-export const CTRL_OPT_SPACE                   = "Control+Option+Space";
-export const CTRL_OPT_SPACE_THEN_CTRL_OPT_RIGHT                   = "Control+Option+Space followed by Control+Option+Right";
-export const CTRL_U                           = "Control+U";
-export const CMD                              = "Command";
-export const CMD_LEFT                         = "Command+Left";
-export const CMD_RIGHT                        = "Command+Right";
-export const CMD_DOWN                        = "Command+Down";
-export const CMD_UP                        = "Command+Up";
-export const DOWN                             = "Down Arrow";
-export const END                              = "End";
-export const ENTER                            = "Enter";
-export const E_AND_SHIFT_E                    = "E / Shift+E";
-export const ESC                              = "Escape";
-export const F_AND_SHIFT_F                    = "F / Shift+F";
-export const HOME                             = "Home";
-export const INS_DOWN_OR_CAPS_DOWN            = "Insert+Down (or CapsLock+Down)";
-export const INS_F7_OR_CAPS_F7                = "Insert+F7 (or CapsLock+F7)";
-export const INS_SPACE                        = "Insert+Space";
-export const INS_TAB                          = "Insert+Tab";
-export const INS_TAB_OR_CAPS_TAB              = "Insert+Tab (or CapsLock+Tab)";
-export const INS_UP_OR_CAPS_I                 = "Insert+Up (or CapsLock+I)";
-export const INS_UP                           = "Insert+Up";
-export const INS_UP_OR_CAPS_UP                = "Insert+Up (or CapsLock+Up)";
-export const INS_Z                            = "Insert+Z";
-export const LEFT_AND_RIGHT                   = "Left Arrow / Right Arrow";
-export const LEFT                             = "Left Arrow";
-export const NUMPAD_5                         = "Numpad 5";
-export const INS_NUMPAD_5                     = "Insert+Numpad 5 (or CapsLock+Numpad 5)";
-export const INS_NUMPAD_6                     = "Insert+Numpad 6 (or CapsLock+Numpad 6)";
-export const NUMPAD_PLUS                      = "Numpad Plus";
-export const RIGHT                            = "Right Arrow";
-export const SPACE                            = "Space";
-export const TAB                              = "Tab";
-export const SHIFT_TAB                        = "Shift+Tab";
-export const TAB_AND_SHIFT_TAB                = "Tab / Shift+Tab";
-export const UP                               = "Up Arrow";
-export const CTRL_ALT_UP                               = "Control+Alt+Up";
-export const UP_AND_DOWN                      = "Up Arrow / Down Arrow";
-export const SHIFT_X                          = "Shift+X";
-export const X_AND_SHIFT_X                    = "X / Shift+X";
-export const A                                = "A";
-export const SHIFT_A                                = "Shift+A";
-export const B                                = "B";
-export const SHIFT_B                          = "Shift+B";
-export const C                                = "C";
-export const D                                = "D";
-export const E                                = "E";
-export const SHIFT_E                                = "Shift+E";
-export const F                                = "F";
-export const SHIFT_F                          = "Shift+F";
-export const G                                = "G";
-export const H                                = "H";
-export const I                                = "I";
-export const SHIFT_I                                = "Shift+I";
-export const J                                = "J";
-export const K                                = "K";
-export const SHIFT_K                                = "Shift+K";
-export const L                                = "L";
-export const SHIFT_L                                = "Shift+L";
-export const M                                = "M";
-export const N                                = "N";
-export const O                                = "O";
-export const P                                = "P";
-export const Q                                = "Q";
-export const R                                = "R";
-export const SHIFT_R                                = "Shift+R";
-export const S                                = "S";
-export const T                                = "T";
-export const SHIFT_T                                = "Shift+T";
-export const CTRL_OPT_CMD_T                                = "Control+Option+Command+T";
-export const T_THEN_DOWN                                = "T followed by Down Arrow";
-export const SHIFT_T_THEN_DOWN                                = "Shift+T followed by Down Arrow";
-export const U                                = "U";
-export const SHIFT_U                                = "Shift+U";
-export const V                                = "V";
-export const W                                = "W";
-export const X                                = "X";
-export const Y                                = "Y";
-export const CTRL_OPT_CMD_Y                                = "Control+Option+Command+Y";
-export const SHIFT_CTRL_OPT_CMD_Y                                = "Shift+Control+Option+Command+Y";
-export const Z                                = "Z";
-export const PAGE_DOWN                                = "Page Down";
-export const PAGE_UP                                = "Page Up";
+export const CTRL_OPT_F3 = "Control+Option+F3";
+export const CTRL_OPT_F4 = "Control+Option+F4";
+export const CTRL_OPT_SPACE = "Control+Option+Space";
+export const CTRL_OPT_SPACE_THEN_CTRL_OPT_RIGHT = "Control+Option+Space followed by Control+Option+Right";
+export const CTRL_U = "Control+U";
+export const CMD = "Command";
+export const CMD_LEFT = "Command+Left";
+export const CMD_RIGHT = "Command+Right";
+export const CMD_DOWN = "Command+Down";
+export const CMD_UP = "Command+Up";
+export const DOWN = "Down Arrow";
+export const END = "End";
+export const ENTER = "Enter";
+export const E_AND_SHIFT_E = "E / Shift+E";
+export const ESC = "Escape";
+export const F_AND_SHIFT_F = "F / Shift+F";
+export const HOME = "Home";
+export const INS_DOWN_OR_CAPS_DOWN = "Insert+Down (or CapsLock+Down)";
+export const INS_F7_OR_CAPS_F7 = "Insert+F7 (or CapsLock+F7)";
+export const INS_SPACE = "Insert+Space";
+export const INS_TAB = "Insert+Tab";
+export const INS_TAB_OR_CAPS_TAB = "Insert+Tab (or CapsLock+Tab)";
+export const INS_UP_OR_CAPS_I = "Insert+Up (or CapsLock+I)";
+export const INS_UP = "Insert+Up";
+export const INS_UP_OR_CAPS_UP = "Insert+Up (or CapsLock+Up)";
+export const INS_Z = "Insert+Z";
+export const LEFT_AND_RIGHT = "Left Arrow / Right Arrow";
+export const LEFT = "Left Arrow";
+export const NUMPAD_5 = "Numpad 5";
+export const INS_NUMPAD_5 = "Insert+Numpad 5 (or CapsLock+Numpad 5)";
+export const INS_NUMPAD_6 = "Insert+Numpad 6 (or CapsLock+Numpad 6)";
+export const NUMPAD_PLUS = "Numpad Plus";
+export const RIGHT = "Right Arrow";
+export const SPACE = "Space";
+export const TAB = "Tab";
+export const SHIFT_TAB = "Shift+Tab";
+export const TAB_AND_SHIFT_TAB = "Tab / Shift+Tab";
+export const UP = "Up Arrow";
+export const CTRL_ALT_UP = "Control+Alt+Up";
+export const UP_AND_DOWN = "Up Arrow / Down Arrow";
+export const SHIFT_X = "Shift+X";
+export const X_AND_SHIFT_X = "X / Shift+X";
+export const A = "A";
+export const SHIFT_A = "Shift+A";
+export const B = "B";
+export const SHIFT_B = "Shift+B";
+export const C = "C";
+export const D = "D";
+export const E = "E";
+export const SHIFT_E = "Shift+E";
+export const F = "F";
+export const SHIFT_F = "Shift+F";
+export const G = "G";
+export const H = "H";
+export const I = "I";
+export const SHIFT_I = "Shift+I";
+export const J = "J";
+export const K = "K";
+export const SHIFT_K = "Shift+K";
+export const L = "L";
+export const SHIFT_L = "Shift+L";
+export const M = "M";
+export const N = "N";
+export const O = "O";
+export const P = "P";
+export const Q = "Q";
+export const R = "R";
+export const SHIFT_R = "Shift+R";
+export const S = "S";
+export const T = "T";
+export const SHIFT_T = "Shift+T";
+export const CTRL_OPT_CMD_T = "Control+Option+Command+T";
+export const T_THEN_DOWN = "T followed by Down Arrow";
+export const SHIFT_T_THEN_DOWN = "Shift+T followed by Down Arrow";
+export const U = "U";
+export const SHIFT_U = "Shift+U";
+export const V = "V";
+export const W = "W";
+export const X = "X";
+export const Y = "Y";
+export const CTRL_OPT_CMD_Y = "Control+Option+Command+Y";
+export const SHIFT_CTRL_OPT_CMD_Y = "Shift+Control+Option+Command+Y";
+export const Z = "Z";
+export const PAGE_DOWN = "Page Down";
+export const PAGE_UP = "Page Up";
 export const SHIFT_D = "Shift+D";
 export const CTRL_OPT_CMD_G = "Control+Option+Command+G";
 export const CTRL_OPT_CMD_H = "Control+Option+Command+H";
diff --git a/tests/support.json b/tests/support.json
index 417222160..4b91b7f71 100644
--- a/tests/support.json
+++ b/tests/support.json
@@ -13,7 +13,7 @@
         "virtualCursor": {
           "screenText": "virtual cursor active",
           "instructions": [
-            "Press &lt;kbd&gt;Alt&lt;/kbd&gt;+&lt;kbd&gt;Delete &lt;/kbd&gt; to determine which cursor is active.",
+            "Press &lt;kbd&gt;Alt&lt;/kbd&gt;+&lt;kbd&gt;Delete&lt;/kbd&gt; to determine which cursor is active.",
             "If the PC cursor is active, press &lt;kbd&gt;Escape&lt;/kbd&gt; to activate the virtual cursor."
           ]
         },
@@ -39,15 +39,15 @@
         "browseMode": {
           "screenText": "browse mode on",
           "instructions": [
-            "Press &lt;kbd&gt;insert&lt;/kbd&gt;+&lt;kbd&gt;Space&lt;/kbd&gt;.",
-            "If NVDA made the focus mode sound , press &lt;kbd&gt;Insert&lt;/kbd&gt;+&lt;kbd&gt;Space&lt;/kbd&gt; again to turn browse mode back on."
+            "Press &lt;kbd&gt;Insert&lt;/kbd&gt;+&lt;kbd&gt;Space&lt;/kbd&gt;.",
+            "If NVDA made the focus mode sound, press &lt;kbd&gt;Insert&lt;/kbd&gt;+&lt;kbd&gt;Space&lt;/kbd&gt; again to turn browse mode back on."
           ]
         },
         "focusMode": {
           "screenText": "focus mode on",
           "instructions": [
-            "Press &lt;kbd&gt;insert&lt;/kbd&gt;+&lt;kbd&gt;Space&lt;/kbd&gt;.",
-            "If NVDA made the browse mode sound , press &lt;kbd&gt;Insert&lt;/kbd&gt;+&lt;kbd&gt;Space&lt;/kbd&gt; again to turn focus mode back on."
+            "Press &lt;kbd&gt;Insert&lt;/kbd&gt;+&lt;kbd&gt;Space&lt;/kbd&gt;.",
+            "If NVDA made the browse mode sound, press &lt;kbd&gt;Insert&lt;/kbd&gt;+&lt;kbd&gt;Space&lt;/kbd&gt; again to turn focus mode back on."
           ]
         }
       }
@@ -407,4 +407,4 @@
       }
     }
   }
-}
\ No newline at end of file
+}
diff --git a/types/aria-at-csv.js b/types/aria-at-csv.js
index 232c95ec2..185e6ed53 100644
--- a/types/aria-at-csv.js
+++ b/types/aria-at-csv.js
@@ -40,24 +40,82 @@
 /**
  * @typedef AriaATCSV.Reference
  * @property {string} refId
+ * @property {string} type
  * @property {string} value
+ * @property {string} linkText
+ */
+
+/**
+ * @typedef AriaATCSV.SupportTestPlanStrings
+ * @property {string} ariaSpecsPreface
+ * @property {string} openExampleInstruction
+ * @property {string} commandListPreface
+ * @property {string} commandListSettingsPreface
+ * @property {string} settingInstructionsPreface
+ * @property {string} assertionResponseQuestion
+ */
+
+/**
+ * @typedef AriaATCSV.SupportReference
+ * @property {string} baseUrl
+ * @property {string} linkText
+ * @property {object} fragmentIds
+ */
+
+/**
+ * @typedef AriaATCSV.SupportAtSetting
+ * @property {string} screenText
+ * @property {string[]} instructions
+ */
+
+/**
+ * @typedef AriaATCSV.SupportAt
+ * @property {string} key
+ * @property {string} name
+ * @property {string} defaultConfigurationInstructionsHTML
+ * @property {Object} assertionTokens
+ * @property {string} assertionTokens.screenReader
+ * @property {string} assertionTokens.readingMode
+ * @property {string} assertionTokens.interactionMode
+ * @property {Object<string, AriaATCSV.SupportAtSetting>} settings
  */
 
 /**
  * @typedef AriaATCSV.Support
- * @property {object[]} ats
- * @property {string} ats[].key
- * @property {string} ats[].name
+ * @property {AriaATCSV.SupportAt[]} ats
  * @property {Object<string, string[]>} applies_to
- * @property {object[]} examples
- * @property {string} examples[].directory
- * @property {string} examples[].name
+ * @property {AriaATCSV.SupportTestPlanStrings} testPlanStrings
+ * @property {object} references
+ * @property {AriaATCSV.SupportReference} references.aria
+ * @property {AriaATCSV.SupportReference} references.htmlAam
+ */
+
+/**
+ * @typedef AriaATCSV.AssertionCommandInfo
+ * @property {string} testId
+ * @property {string} command
+ * @property {string} settings
+ * @property {number} priority
+ * @property {string} assertionExceptions
+ */
+
+/**
+ * @typedef AriaATCSV.Assertion
+ * @property {string} assertionId
+ * @property {number} priority
+ * @property {string} assertionStatement
+ * @property {string} assertionPhrase
+ * @property {string} refIds
+ * @property {Object<string, AriaATCSV.AssertionCommandInfo>[]} commandInfo
  */
 
 /**
  * @typedef AriaATCSV.Test
  * @property {string} testId
  * @property {string} title
+ * @property {object} target
+ * @property {object[]} target.ats
+ * @property {number} presentationNumber
  * @property {string} appliesTo
  * @property {string} mode
  * @property {string} task
@@ -65,6 +123,8 @@
  * @property {string} setupScriptDescription
  * @property {string} refs
  * @property {string} instructions
+ * @property {AriaATCSV.Assertion[]} assertions
+ * @property {Object<string, AriaATCSV.AssertionCommandInfo[]>} commandsInfo
  * @property {string} [assertion1]
  * @property {string} [assertion2]
  * @property {string} [assertion3]
diff --git a/types/aria-at-file.js b/types/aria-at-file.js
index a85612a35..308dfc2dd 100644
--- a/types/aria-at-file.js
+++ b/types/aria-at-file.js
@@ -51,12 +51,14 @@
  * @typedef AriaATFile.Behavior
  * @property {string} setup_script_description
  * @property {string} setupTestPage
+ * @property {string} assertionResponseQuestion
  * @property {string[]} applies_to
  * @property {AriaATFile.ATMode | AriaATFile.ATMode[]} mode
  * @property {string} task
  * @property {string} specific_user_instruction
  * @property {string[][]} [output_assertions]
  * @property {Object<string, AriaATFile.StringNumber[][]>} [additional_assertions]
+ * @property {Object<string, AriaATCSV.AssertionCommandInfo[]>} commandsInfo
  */
 
 /**
diff --git a/types/aria-at-parsed.js b/types/aria-at-parsed.js
index 7ebd6bdb3..f43701ee9 100644
--- a/types/aria-at-parsed.js
+++ b/types/aria-at-parsed.js
@@ -47,15 +47,17 @@
 
 /**
  * @typedef AriaATParsed.Support
- * @property {object[]} ats
- * @property {string} ats[].key
- * @property {string} ats[].name
+ * @property {AriaATCSV.SupportAt[]} ats
  * @property {object[]} atGroups
  * @property {string} atGroups[].key
  * @property {string} atGroups[].name
  * @property {object[]} atGroups[].ats
  * @property {string} atGroups[].ats[].key
  * @property {string} atGroups[].ats[].name
+ * @property {AriaATCSV.SupportTestPlanStrings} testPlanStrings
+ * @property {object} references
+ * @property {AriaATCSV.SupportReference} references.aria
+ * @property {AriaATCSV.SupportReference} references.htmlAam
  */
 
 /**