From 9b6ccd9e5a915c2a9665872b3b45ce07f6b47316 Mon Sep 17 00:00:00 2001
From: Adam Wright <adam.j.wright82@gmail.com>
Date: Mon, 12 Oct 2026 08:00:28 +0000
Subject: [PATCH 1/2] Check every index read, everywhere:
 noUncheckedIndexedAccess in tsconfig.json

The workspace libraries' last 84 findings handled, so the flag moves from the
app's and the embed's own configs into tsconfig.json, and every build --
both libraries, the table web component, the app, the embed -- enforces it.
The counted check that held the libraries, its baseline and its CI and
preflight steps are removed.

reactome-table's store is the spreadsheet behind the GSA form's data entry
and had two unit tests. A session test now drives it through generate,
import, type, move, select, paste, delete, add and remove rows and columns,
and snapshots its state after every step; the snapshots were recorded
against the old code, and the rewrite reproduces them exactly. Reads that
always threw on a missing row or cell still do, through rowAt/cellAt/maxAt,
now saying where.

reactome-gsa-form: a parameter type the form does not know, one the GSA
service added since, is read as text rather than throwing (parserFor, with
a spec); an empty method list or an annotation table with no header row
gives an empty value rather than a crash.

With the flag in the root config, type-aware lint sees spec and e2e files
under it too: three index reads there are guarded.

Closes #345.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .github/workflows/tests.yml                   |    6 -
 e2e/reacfoam.spec.ts                          |    4 +-
 indexed-access-baseline.json                  |   15 -
 package.json                                  |    1 -
 .../tsconfig.app.json                         |    5 +-
 .../local-data/local-data.component.ts        |   13 +-
 .../statistical-design.component.ts           |    2 +-
 .../lib/services/analysis-methods.service.ts  |   12 +-
 .../src/lib/services/parse-parameter.spec.ts  |   18 +
 .../dataset-source/dataset-source.effect.ts   |    6 +-
 .../src/lib/state/dataset/dataset.effect.ts   |    3 +-
 .../src/lib/state/dataset/dataset.reducer.ts  |    7 +-
 .../src/lib/state/dataset/dataset.selector.ts |   11 +-
 .../src/lib/state/method/method.effect.ts     |    6 +-
 .../src/lib/state/method/method.reducer.ts    |    3 +-
 .../src/lib/utilities/species/species.pipe.ts |    3 +-
 .../lib/component/table/table.component.html  |    2 +-
 .../table.store.session.spec.ts.snap          | 1176 +++++++++++++++++
 .../src/lib/state/table.store.session.spec.ts |  187 +++
 .../src/lib/state/table.store.ts              |  146 +-
 .../src/lib/utils/table.util.ts               |   12 +-
 .../app/search/answer/chat-handoff.spec.ts    |    5 +-
 scripts/check-indexed-access.mjs              |  156 ---
 scripts/preflight.sh                          |    1 -
 .../check-indexed-access.spec.mjs             |   54 -
 tsconfig.app.json                             |    5 +-
 tsconfig.json                                 |   17 +-
 27 files changed, 1542 insertions(+), 334 deletions(-)
 delete mode 100644 indexed-access-baseline.json
 create mode 100644 projects/reactome-gsa-form/src/lib/services/parse-parameter.spec.ts
 create mode 100644 projects/reactome-table/src/lib/state/__snapshots__/table.store.session.spec.ts.snap
 create mode 100644 projects/reactome-table/src/lib/state/table.store.session.spec.ts
 delete mode 100644 scripts/check-indexed-access.mjs
 delete mode 100644 tools/indexed-access-check/check-indexed-access.spec.mjs

diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
index bd8ed972..16c23cf9 100644
--- a/.github/workflows/tests.yml
+++ b/.github/workflows/tests.yml
@@ -87,12 +87,6 @@ jobs:
       - name: Lint
         run: npm run check:lint
 
-      # noUncheckedIndexedAccess is a compiler flag with no warning level, so it
-      # is held at a per-file count until it reaches zero and can be enabled
-      # (#345). Like the lint warnings, a count can only go down.
-      - name: Unchecked indexed access has not increased
-        run: npm run check:indexed
-
       # eslint sees unused symbols within a file; knip sees whole files and
       # exports nothing imports, which was the bigger pile. Also baselined,
       # because some findings need someone who knows the data model to judge --
diff --git a/e2e/reacfoam.spec.ts b/e2e/reacfoam.spec.ts
index 2f533d81..104f3249 100644
--- a/e2e/reacfoam.spec.ts
+++ b/e2e/reacfoam.spec.ts
@@ -58,7 +58,9 @@ async function centreOf(page: Page, label: string) {
 function darkInTitleStrip(page: Page) {
   return page.evaluate(() => {
     const canvases = [...document.querySelectorAll<HTMLCanvasElement>('cr-reacfoam canvas')];
-    const { width, height } = canvases[0];
+    const [first] = canvases;
+    if (!first) throw new Error('no reacfoam canvas');
+    const { width, height } = first;
     const top = Math.floor(height * 0.85);
     const all = document.createElement('canvas');
     all.width = width;
diff --git a/indexed-access-baseline.json b/indexed-access-baseline.json
deleted file mode 100644
index 09f0bf9b..00000000
--- a/indexed-access-baseline.json
+++ /dev/null
@@ -1,15 +0,0 @@
-{
-  "total": 84,
-  "files": {
-    "projects/reactome-gsa-form/src/lib/dataset-form/datasets/select-dataset/dataset-types/local-data/local-data.component.ts": 4,
-    "projects/reactome-gsa-form/src/lib/state/dataset-source/dataset-source.effect.ts": 2,
-    "projects/reactome-gsa-form/src/lib/state/dataset/dataset.effect.ts": 1,
-    "projects/reactome-gsa-form/src/lib/state/dataset/dataset.reducer.ts": 3,
-    "projects/reactome-gsa-form/src/lib/state/dataset/dataset.selector.ts": 4,
-    "projects/reactome-gsa-form/src/lib/state/method/method.effect.ts": 2,
-    "projects/reactome-gsa-form/src/lib/state/method/method.reducer.ts": 1,
-    "projects/reactome-gsa-form/src/lib/utilities/species/species.pipe.ts": 1,
-    "projects/reactome-table/src/lib/state/table.store.ts": 63,
-    "projects/reactome-table/src/lib/utils/table.util.ts": 3
-  }
-}
diff --git a/package.json b/package.json
index df104867..07faf186 100644
--- a/package.json
+++ b/package.json
@@ -40,7 +40,6 @@
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
     "check:lint": "node scripts/check-lint.mjs",
-    "check:indexed": "node scripts/check-indexed-access.mjs",
     "check:dead": "node scripts/check-dead-code.mjs",
     "check:lockfile": "node scripts/check-lockfile.mjs",
     "dead": "knip",
diff --git a/projects/reactome-diagram-element/tsconfig.app.json b/projects/reactome-diagram-element/tsconfig.app.json
index 88902e4e..28bf5940 100644
--- a/projects/reactome-diagram-element/tsconfig.app.json
+++ b/projects/reactome-diagram-element/tsconfig.app.json
@@ -2,10 +2,7 @@
   "extends": "../../tsconfig.json",
   "compilerOptions": {
     "outDir": "../../out-tsc/reactome-diagram-element",
-    "types": [],
-    // Every index read checked (#345). Not yet in tsconfig.json: the workspace
-    // libraries have findings left, held at a count by scripts/check-indexed-access.mjs.
-    "noUncheckedIndexedAccess": true
+    "types": []
   },
   "files": ["src/main.ts"],
   "include": ["../pathway-browser/src/**/*.d.ts", "../../src/**/*.d.ts"]
diff --git a/projects/reactome-gsa-form/src/lib/dataset-form/datasets/select-dataset/dataset-types/local-data/local-data.component.ts b/projects/reactome-gsa-form/src/lib/dataset-form/datasets/select-dataset/dataset-types/local-data/local-data.component.ts
index d533cbcb..7c5ea7e6 100644
--- a/projects/reactome-gsa-form/src/lib/dataset-form/datasets/select-dataset/dataset-types/local-data/local-data.component.ts
+++ b/projects/reactome-gsa-form/src/lib/dataset-form/datasets/select-dataset/dataset-types/local-data/local-data.component.ts
@@ -141,10 +141,9 @@ export class LocalDataComponent {
         }
         const lines = text.trim().split('\n');
 
-        for (let i = 1; i < lines.length; i++) {
-          const columns = lines[i].split('\t');
-          for (let j = 1; j < columns.length; j++) {
-            const value = columns[j].trim();
+        for (const line of lines.slice(1)) {
+          for (const column of line.split('\t').slice(1)) {
+            const value = column.trim();
             if (!Number.isInteger(Number(value))) {
               return resolve(false);
             }
@@ -166,10 +165,10 @@ export class LocalDataComponent {
         this.readFile(fileRibo),
       ]);
 
-      const file1FirstLine = file1Content.split('\n')[0].trim();
-      const file2FirstLine = file2Content.split('\n')[0].trim();
+      const [file1FirstLine = ''] = file1Content.split('\n');
+      const [file2FirstLine = ''] = file2Content.split('\n');
 
-      return file1FirstLine === file2FirstLine;
+      return file1FirstLine.trim() === file2FirstLine.trim();
     } catch (error) {
       return false;
     }
diff --git a/projects/reactome-gsa-form/src/lib/dataset-form/datasets/statistical-design/statistical-design.component.ts b/projects/reactome-gsa-form/src/lib/dataset-form/datasets/statistical-design/statistical-design.component.ts
index 9c338f6b..520022d1 100644
--- a/projects/reactome-gsa-form/src/lib/dataset-form/datasets/statistical-design/statistical-design.component.ts
+++ b/projects/reactome-gsa-form/src/lib/dataset-form/datasets/statistical-design/statistical-design.component.ts
@@ -74,7 +74,7 @@ export class StatisticalDesignComponent implements OnInit {
     this.store.dispatch(datasetActions.setCovariatesValue({ id: this.datasetId(), value: value }));
   }
 
-  comparisonGroup2Values(groups: string[], group1: string) {
+  comparisonGroup2Values(groups: string[] | undefined, group1: string) {
     if (!groups) return [];
     return groups.filter((group) => group !== group1);
   }
diff --git a/projects/reactome-gsa-form/src/lib/services/analysis-methods.service.ts b/projects/reactome-gsa-form/src/lib/services/analysis-methods.service.ts
index a36cedcb..250afffe 100644
--- a/projects/reactome-gsa-form/src/lib/services/analysis-methods.service.ts
+++ b/projects/reactome-gsa-form/src/lib/services/analysis-methods.service.ts
@@ -6,7 +6,10 @@ import { extractErrorMessage } from '../utilities/utils';
 import { MatSnackBar } from '@angular/material/snack-bar';
 import { ConfigProvider, REACTOME_GSA_CONFIG } from '../config/gsa-config';
 
-export const typeToParse: { [p: string]: (value: string) => any } = {
+/** Reads a parameter's text as its type: a boolean, a number, or the text itself. */
+type Parser = (value: string) => any;
+
+const typeToParse: { [p: string]: Parser } = {
   bool: (value) => value.toLowerCase() === 'true',
   float: parseFloat,
   int: parseInt,
@@ -14,6 +17,13 @@ export const typeToParse: { [p: string]: (value: string) => any } = {
   string: (value) => value,
 };
 
+/**
+ * How to read a parameter of this type. A type this form does not know -- one
+ * the service added since -- is read as text, rather than taking the whole form
+ * down with it.
+ */
+export const parserFor = (type: string): Parser => typeToParse[type] ?? ((text: string) => text);
+
 @Injectable({
   providedIn: 'root',
 })
diff --git a/projects/reactome-gsa-form/src/lib/services/parse-parameter.spec.ts b/projects/reactome-gsa-form/src/lib/services/parse-parameter.spec.ts
new file mode 100644
index 00000000..d2f69be8
--- /dev/null
+++ b/projects/reactome-gsa-form/src/lib/services/parse-parameter.spec.ts
@@ -0,0 +1,18 @@
+import { describe, expect, it } from 'vitest';
+import { parserFor } from './analysis-methods.service';
+
+// A method's parameters come from the GSA service, typed by name. A type this
+// form does not know -- one added since -- is read as text rather than taking
+// the form down.
+describe('parserFor', () => {
+  it('reads each known type', () => {
+    expect(parserFor('bool')('True')).toBe(true);
+    expect(parserFor('float')('0.05')).toBe(0.05);
+    expect(parserFor('int')('7')).toBe(7);
+    expect(parserFor('string')('x')).toBe('x');
+  });
+
+  it('reads a type it does not know as text', () => {
+    expect(parserFor('ratio')('1:2')).toBe('1:2');
+  });
+});
diff --git a/projects/reactome-gsa-form/src/lib/state/dataset-source/dataset-source.effect.ts b/projects/reactome-gsa-form/src/lib/state/dataset-source/dataset-source.effect.ts
index 91dbf834..7f54c612 100644
--- a/projects/reactome-gsa-form/src/lib/state/dataset-source/dataset-source.effect.ts
+++ b/projects/reactome-gsa-form/src/lib/state/dataset-source/dataset-source.effect.ts
@@ -3,7 +3,7 @@ import { Injectable, inject } from '@angular/core';
 import { catchError, exhaustMap, map, mergeMap, of, take } from 'rxjs';
 import { FetchDatasetService } from '../../services/fetch-dataset.service';
 import { datasetSourceActions } from './dataset-source.action';
-import { typeToParse } from '../../services/analysis-methods.service';
+import { parserFor } from '../../services/analysis-methods.service';
 
 @Injectable()
 export class DatasetSourceEffects {
@@ -50,8 +50,8 @@ export class DatasetSourceEffects {
             externals.forEach((external) =>
               external.parameters.forEach((param) => {
                 //  param.id = `${external.id} - ${param.name}`;
-                param.value = typeToParse[param.type](param.default);
-                param.default = typeToParse[param.type](param.default);
+                param.value = parserFor(param.type)(param.default);
+                param.default = parserFor(param.type)(param.default);
               })
             );
             return externals;
diff --git a/projects/reactome-gsa-form/src/lib/state/dataset/dataset.effect.ts b/projects/reactome-gsa-form/src/lib/state/dataset/dataset.effect.ts
index 60a839e5..9377e617 100644
--- a/projects/reactome-gsa-form/src/lib/state/dataset/dataset.effect.ts
+++ b/projects/reactome-gsa-form/src/lib/state/dataset/dataset.effect.ts
@@ -211,7 +211,8 @@ export class DatasetEffects {
               ['', ...summary.sample_metadata.map((col) => col.name)],
               ...summary.sample_ids.map((sampleId, i) => [
                 sampleId,
-                ...summary.sample_metadata!.map((column) => column.values[i]),
+                // A missing value reads as an empty cell, as the table treats one.
+                ...summary.sample_metadata!.map((column) => column.values[i] ?? ''),
               ]),
             ];
         return datasetActions.setAnnotations({ annotations: table, id });
diff --git a/projects/reactome-gsa-form/src/lib/state/dataset/dataset.reducer.ts b/projects/reactome-gsa-form/src/lib/state/dataset/dataset.reducer.ts
index 31ebffed..02e8c98c 100644
--- a/projects/reactome-gsa-form/src/lib/state/dataset/dataset.reducer.ts
+++ b/projects/reactome-gsa-form/src/lib/state/dataset/dataset.reducer.ts
@@ -134,13 +134,14 @@ export const datasetReducer: ActionReducer<DatasetState> = createReducer(
           const annotations = dataset.annotations!;
 
           const annotationsWithSimpleIds = cp(annotations);
-          annotationsWithSimpleIds[0][0] = 'sample_ids';
+          const [header] = annotationsWithSimpleIds;
+          if (header) header[0] = 'sample_ids';
 
           return {
             id: dataset.id,
             changes: {
               annotationColumns: new Map<string, string[]>(
-                transpose(annotationsWithSimpleIds).map((col) => [col[0], col.slice(1)])
+                transpose(annotationsWithSimpleIds).map((col) => [col[0] ?? '', col.slice(1)])
               ),
             },
           };
@@ -213,7 +214,7 @@ export const datasetReducer: ActionReducer<DatasetState> = createReducer(
         ...dataset.statisticalDesign!,
         covariances:
           dataset.annotations?.[0]
-            .slice(1) //slice the first element, which is the empty string
+            ?.slice(1) //slice the first element, which is the empty string
             .filter((name) => name !== dataset.statisticalDesign!.analysisGroup)
             .map((name) => ({
               name,
diff --git a/projects/reactome-gsa-form/src/lib/state/dataset/dataset.selector.ts b/projects/reactome-gsa-form/src/lib/state/dataset/dataset.selector.ts
index 99628549..d02406ad 100644
--- a/projects/reactome-gsa-form/src/lib/state/dataset/dataset.selector.ts
+++ b/projects/reactome-gsa-form/src/lib/state/dataset/dataset.selector.ts
@@ -84,7 +84,7 @@ export const datasetFeature = createFeature({
           .slice(1) // Remove row ids column
           .map((column) => ({
             // Create groups with distinct values
-            name: column[0],
+            name: column[0] ?? '',
             values: new Set(column.slice(1).filter((s) => s)),
           }))
           .filter((group) => group.values.size >= 2) // Filter groups suitable for analysis
@@ -115,19 +115,20 @@ export const datasetFeature = createFeature({
           .slice(1) // Remove row ids column
           .map((column) => ({
             // Create groups with distinct values
-            name: column[0],
+            name: column[0] ?? '',
             values: column.slice(1),
           }))
           .filter((column) => dataset!.statisticalDesign!.analysisGroup !== column.name) // Remove analysis group
           .filter((column) => {
-            const group1Values = new Set<string>();
-            const group2Values = new Set<string>();
+            // A missing value counts as one, as it always has.
+            const group1Values = new Set<string | undefined>();
+            const group2Values = new Set<string | undefined>();
             for (let i = 0; i < analysisColumn.length; i++) {
               const analysedValue = analysisColumn[i];
               for (const [comparisonGroup, values] of [
                 [dataset!.statisticalDesign!.comparisonGroup1, group1Values],
                 [dataset!.statisticalDesign!.comparisonGroup2, group2Values],
-              ] as [string, Set<string>][]) {
+              ] as [string, Set<string | undefined>][]) {
                 if (analysedValue === comparisonGroup) {
                   const value = column.values[i];
                   if (values.has(value)) return false; // remove columns where a "pair" is associated more than once to the same condition
diff --git a/projects/reactome-gsa-form/src/lib/state/method/method.effect.ts b/projects/reactome-gsa-form/src/lib/state/method/method.effect.ts
index 573ff239..65e181cb 100644
--- a/projects/reactome-gsa-form/src/lib/state/method/method.effect.ts
+++ b/projects/reactome-gsa-form/src/lib/state/method/method.effect.ts
@@ -1,6 +1,6 @@
 import { Actions, createEffect, ofType } from '@ngrx/effects';
 import { Injectable, inject } from '@angular/core';
-import { AnalysisMethodsService, typeToParse } from '../../services/analysis-methods.service';
+import { AnalysisMethodsService, parserFor } from '../../services/analysis-methods.service';
 import { methodActions } from './method.action';
 import { catchError, exhaustMap, map, of } from 'rxjs';
 import { ParameterType } from '../../model/methods.model';
@@ -21,8 +21,8 @@ export class MethodEffects {
             methods.forEach((method) => {
               method.parameters.forEach((param) => {
                 param.type = param.name === 'email' ? ParameterType.email : param.type;
-                param.value = typeToParse[param.type](param.default);
-                param.default = typeToParse[param.type](param.default);
+                param.value = parserFor(param.type)(param.default);
+                param.default = parserFor(param.type)(param.default);
               });
               const server = method.parameters.find((param) => param.name === 'reactome_server');
               if (server) server.value = this.config().server;
diff --git a/projects/reactome-gsa-form/src/lib/state/method/method.reducer.ts b/projects/reactome-gsa-form/src/lib/state/method/method.reducer.ts
index 787c8b05..71e33bdf 100644
--- a/projects/reactome-gsa-form/src/lib/state/method/method.reducer.ts
+++ b/projects/reactome-gsa-form/src/lib/state/method/method.reducer.ts
@@ -15,7 +15,8 @@ export const methodReducer: ActionReducer<MethodState> = createReducer(
       })),
       {
         ...state,
-        commonParameters: methods[0].parameters.filter((param) => param.scope === 'common'), // They are transferred to global status
+        // They are transferred to global status; no methods have none.
+        commonParameters: methods[0]?.parameters.filter((param) => param.scope === 'common') ?? [],
       }
     )
   ),
diff --git a/projects/reactome-gsa-form/src/lib/utilities/species/species.pipe.ts b/projects/reactome-gsa-form/src/lib/utilities/species/species.pipe.ts
index 6c319f8c..b5b2b60d 100644
--- a/projects/reactome-gsa-form/src/lib/utilities/species/species.pipe.ts
+++ b/projects/reactome-gsa-form/src/lib/utilities/species/species.pipe.ts
@@ -4,6 +4,7 @@ import { Pipe, PipeTransform } from '@angular/core';
 export class SpeciesPipe implements PipeTransform {
   transform(value: string): unknown {
     const words = value.split(' ');
-    return words[0].charAt(0).toUpperCase() + '. ' + words.slice(1).join(' ');
+    const [genus = ''] = words;
+    return genus.charAt(0).toUpperCase() + '. ' + words.slice(1).join(' ');
   }
 }
diff --git a/projects/reactome-table/src/lib/component/table/table.component.html b/projects/reactome-table/src/lib/component/table/table.component.html
index f24d798c..f48dbe61 100644
--- a/projects/reactome-table/src/lib/component/table/table.component.html
+++ b/projects/reactome-table/src/lib/component/table/table.component.html
@@ -147,7 +147,7 @@
             @if (settings.addRow) {
               <tr>
                 <th class="rows">...</th>
-                <td class="no-padding add-row-button-container" [colSpan]="data[0].length">
+                <td class="no-padding add-row-button-container" [colSpan]="data[0]?.length ?? 1">
                   <button
                     (click)="addRow()"
                     (keydown.shift.tab)="focusLastCell($event)"
diff --git a/projects/reactome-table/src/lib/state/__snapshots__/table.store.session.spec.ts.snap b/projects/reactome-table/src/lib/state/__snapshots__/table.store.session.spec.ts.snap
new file mode 100644
index 00000000..c318dcaf
--- /dev/null
+++ b/projects/reactome-table/src/lib/state/__snapshots__/table.store.session.spec.ts.snap
@@ -0,0 +1,1176 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`TableStore through an editing session > adds and removes rows and columns 1`] = `
+{
+  "cleanData": [
+    [
+      "",
+      "A",
+    ],
+    [
+      "2",
+      "P3",
+    ],
+    [
+      "3",
+      "P5",
+    ],
+  ],
+  "colNames": [
+    "A",
+    "B",
+    "C",
+    "E",
+  ],
+  "columnByIndex": [
+    "A",
+    "P3",
+    "P5",
+    "",
+    "",
+  ],
+  "columnByName": [
+    "",
+    "",
+    "",
+    "",
+  ],
+  "hasData": true,
+  "range": [
+    [
+      "",
+    ],
+  ],
+  "rowByIndex": [
+    "2",
+    "P3",
+    "",
+    "",
+    "",
+  ],
+  "rowByName": [
+    "P3",
+    "",
+    "",
+    "",
+  ],
+  "rowNames": [
+    "2",
+    "3",
+    "4",
+    "6",
+  ],
+  "value": "",
+}
+`;
+
+exports[`TableStore through an editing session > clears back to the template 1`] = `
+{
+  "cleanData": [
+    [
+      "",
+    ],
+  ],
+  "colNames": [
+    "A",
+    "B",
+    "C",
+  ],
+  "columnByIndex": [
+    "A",
+    "",
+    "",
+    "",
+    "",
+  ],
+  "columnByName": [
+    "",
+    "",
+    "",
+    "",
+  ],
+  "hasData": false,
+  "range": [
+    [
+      "",
+    ],
+  ],
+  "rowByIndex": [
+    "1",
+    "",
+    "",
+    "",
+  ],
+  "rowByName": [
+    "",
+    "",
+    "",
+  ],
+  "rowNames": [
+    "1",
+    "2",
+    "3",
+    "4",
+  ],
+  "value": "",
+}
+`;
+
+exports[`TableStore through an editing session > generates a template 1`] = `
+{
+  "cleanData": [
+    [
+      "",
+    ],
+  ],
+  "colNames": [
+    "A",
+    "B",
+    "C",
+  ],
+  "columnByIndex": [
+    "A",
+    "",
+    "",
+    "",
+    "",
+  ],
+  "columnByName": [
+    "",
+    "",
+    "",
+    "",
+  ],
+  "hasData": false,
+  "range": [
+    [
+      "",
+    ],
+  ],
+  "rowByIndex": [
+    "1",
+    "",
+    "",
+    "",
+  ],
+  "rowByName": [
+    "",
+    "",
+    "",
+  ],
+  "rowNames": [
+    "1",
+    "2",
+    "3",
+    "4",
+  ],
+  "value": "",
+}
+`;
+
+exports[`TableStore through an editing session > imports a table, mapping its headers onto the template 1`] = `
+{
+  "cleanData": [
+    [
+      "",
+      "A",
+      "B",
+    ],
+    [
+      "1",
+      "TP53",
+      "2.5",
+    ],
+    [
+      "2",
+      "BRCA1",
+      "",
+    ],
+  ],
+  "colNames": [
+    "A",
+    "B",
+    "C",
+    "Extra",
+  ],
+  "columnByIndex": [
+    "A",
+    "TP53",
+    "BRCA1",
+    "",
+    "",
+    "ATM",
+  ],
+  "columnByName": [
+    "2.5",
+    "",
+    "",
+    "",
+    "-1",
+  ],
+  "hasData": true,
+  "range": [
+    [
+      "",
+    ],
+  ],
+  "rowByIndex": [
+    "1",
+    "TP53",
+    "2.5",
+    "",
+    "x",
+  ],
+  "rowByName": [
+    "BRCA1",
+    "",
+    "",
+    "y",
+  ],
+  "rowNames": [
+    "1",
+    "2",
+    "3",
+    "4",
+    "New",
+  ],
+  "value": "",
+}
+`;
+
+exports[`TableStore through an editing session > imports without mapping headers 1`] = `
+{
+  "cleanData": [
+    [
+      "h1",
+      "h2",
+    ],
+    [
+      "v1",
+      "v2",
+    ],
+  ],
+  "colNames": [
+    "h2",
+    "B",
+    "C",
+    "E",
+  ],
+  "columnByIndex": [
+    "h2",
+    "v2",
+    "",
+    "",
+    "",
+  ],
+  "columnByName": [
+    "",
+    "",
+    "",
+    "",
+  ],
+  "hasData": true,
+  "range": [
+    [
+      "h1",
+    ],
+  ],
+  "rowByIndex": [
+    "v1",
+    "v2",
+    "",
+    "",
+    "",
+  ],
+  "rowByName": [],
+  "rowNames": [
+    "v1",
+    "v3",
+    "4",
+    "6",
+  ],
+  "value": "h1",
+}
+`;
+
+exports[`TableStore through an editing session > pastes over a range, and deletes one 1`] = `
+{
+  "cleanData": [
+    [
+      "",
+      "A",
+    ],
+    [
+      "1",
+      "P1",
+    ],
+    [
+      "2",
+      "P3",
+    ],
+    [
+      "3",
+      "P5",
+    ],
+  ],
+  "colNames": [
+    "A",
+    "B",
+    "C",
+    "Extra",
+  ],
+  "columnByIndex": [
+    "A",
+    "P1",
+    "P3",
+    "P5",
+    "",
+    "ATM",
+  ],
+  "columnByName": [
+    "",
+    "",
+    "",
+    "",
+    "-1",
+  ],
+  "hasData": true,
+  "range": [
+    [
+      "",
+    ],
+    [
+      "",
+    ],
+    [
+      "",
+    ],
+  ],
+  "rowByIndex": [
+    "1",
+    "P1",
+    "",
+    "",
+    "x",
+  ],
+  "rowByName": [
+    "P3",
+    "",
+    "",
+    "y",
+  ],
+  "rowNames": [
+    "1",
+    "2",
+    "3",
+    "4",
+    "New",
+  ],
+  "value": "",
+}
+`;
+
+exports[`TableStore through an editing session > starts empty 1`] = `
+{
+  "cleanData": [
+    [
+      "",
+    ],
+  ],
+  "colNames": [],
+  "columnByIndex": [
+    undefined,
+  ],
+  "columnByName": [],
+  "hasData": false,
+  "range": [
+    [
+      "",
+    ],
+  ],
+  "rowByIndex": "no row 1",
+  "rowByName": [],
+  "rowNames": [],
+  "value": "",
+}
+`;
+
+exports[`TableStore through an editing session > types into the selected cell, moving the column maximum up and down 1`] = `
+{
+  "cleanData": [
+    [
+      "",
+      "A",
+      "B",
+    ],
+    [
+      "1",
+      "TP53",
+      "2.5",
+    ],
+    [
+      "2",
+      "X",
+      "",
+    ],
+  ],
+  "colNames": [
+    "A",
+    "B",
+    "C",
+    "Extra",
+  ],
+  "columnByIndex": [
+    "A",
+    "TP53",
+    "X",
+    "",
+    "",
+    "ATM",
+  ],
+  "columnByName": [
+    "2.5",
+    "",
+    "",
+    "",
+    "-1",
+  ],
+  "hasData": true,
+  "range": [
+    [
+      "X",
+    ],
+  ],
+  "rowByIndex": [
+    "1",
+    "TP53",
+    "2.5",
+    "",
+    "x",
+  ],
+  "rowByName": [
+    "X",
+    "",
+    "",
+    "y",
+  ],
+  "rowNames": [
+    "1",
+    "2",
+    "3",
+    "4",
+    "New",
+  ],
+  "value": "X",
+}
+`;
+
+exports[`TableStore through an editing session > went through every step as recorded 1`] = `
+[
+  {
+    "state": {
+      "cells": [
+        "·",
+      ],
+      "hasFocus": false,
+      "maxCols": [
+        "@0,0",
+      ],
+      "selected": 0,
+      "start": {
+        "x": 0,
+        "y": 0,
+      },
+      "stop": {
+        "x": 0,
+        "y": 0,
+      },
+    },
+    "step": "new",
+  },
+  {
+    "state": {
+      "cells": [
+        "· | A | B | C",
+        "1 | · | · | ·",
+        "2 | · | · | ·",
+        "3 | · | · | ·",
+        "4 | · | · | ·",
+      ],
+      "hasFocus": false,
+      "maxCols": [
+        "1@0,1",
+        "A@1,0",
+        "B@2,0",
+        "C@3,0",
+      ],
+      "selected": 0,
+      "start": {
+        "x": 0,
+        "y": 0,
+      },
+      "stop": {
+        "x": 0,
+        "y": 0,
+      },
+    },
+    "step": "init 4x5",
+  },
+  {
+    "state": {
+      "cells": [
+        "· | A | B | C | Extra",
+        "1 | TP53 | 2.5 | · | x",
+        "2 | BRCA1 | · | · | y",
+        "3 | · | · | · | ·",
+        "4 | · | · | · | ·",
+        "New | ATM | -1 | · | ·",
+      ],
+      "hasFocus": false,
+      "maxCols": [
+        "New@0,5",
+        "BRCA1@1,2",
+        "2.5@2,1",
+        "C@3,0",
+        "Extra@4,0",
+      ],
+      "selected": 0,
+      "start": {
+        "x": 0,
+        "y": 0,
+      },
+      "stop": {
+        "x": 0,
+        "y": 0,
+      },
+    },
+    "step": "import mapped",
+  },
+  {
+    "state": {
+      "cells": [
+        "· | A* | B | C | Extra",
+        "1 | TP53 | 2.5 | · | x",
+        "2* | A-much-longer-gene-name*^ | · | · | y",
+        "3 | · | · | · | ·",
+        "4 | · | · | · | ·",
+        "New | ATM | -1 | · | ·",
+      ],
+      "hasFocus": true,
+      "maxCols": [
+        "New@0,5",
+        "A-much-longer-gene-name@1,2",
+        "2.5@2,1",
+        "C@3,0",
+        "Extra@4,0",
+      ],
+      "selected": 3,
+      "start": {
+        "x": 1,
+        "y": 2,
+      },
+      "stop": {
+        "x": 1,
+        "y": 2,
+      },
+    },
+    "step": "write longer",
+  },
+  {
+    "state": {
+      "cells": [
+        "· | A* | B | C | Extra",
+        "1 | TP53 | 2.5 | · | x",
+        "2* | X*^ | · | · | y",
+        "3 | · | · | · | ·",
+        "4 | · | · | · | ·",
+        "New | ATM | -1 | · | ·",
+      ],
+      "hasFocus": true,
+      "maxCols": [
+        "New@0,5",
+        "TP53@1,1",
+        "2.5@2,1",
+        "C@3,0",
+        "Extra@4,0",
+      ],
+      "selected": 3,
+      "start": {
+        "x": 1,
+        "y": 2,
+      },
+      "stop": {
+        "x": 1,
+        "y": 2,
+      },
+    },
+    "step": "write shorter",
+  },
+  {
+    "state": {
+      "cells": [
+        "· | A* | B | C | Extra",
+        "1* | TP53*^ | 2.5 | · | x",
+        "2 | X | · | · | y",
+        "3 | · | · | · | ·",
+        "4 | · | · | · | ·",
+        "New | ATM | -1 | · | ·",
+      ],
+      "hasFocus": true,
+      "maxCols": [
+        "New@0,5",
+        "TP53@1,1",
+        "2.5@2,1",
+        "C@3,0",
+        "Extra@4,0",
+      ],
+      "selected": 3,
+      "start": {
+        "x": 1,
+        "y": 1,
+      },
+      "stop": {
+        "x": 1,
+        "y": 1,
+      },
+    },
+    "step": "focusFirst",
+  },
+  {
+    "state": {
+      "cells": [
+        "·* | A*^ | B | C | Extra",
+        "1 | TP53 | 2.5 | · | x",
+        "2 | X | · | · | y",
+        "3 | · | · | · | ·",
+        "4 | · | · | · | ·",
+        "New | ATM | -1 | · | ·",
+      ],
+      "hasFocus": true,
+      "maxCols": [
+        "New@0,5",
+        "TP53@1,1",
+        "2.5@2,1",
+        "C@3,0",
+        "Extra@4,0",
+      ],
+      "selected": 3,
+      "start": {
+        "x": 1,
+        "y": 0,
+      },
+      "stop": {
+        "x": 1,
+        "y": 0,
+      },
+    },
+    "step": "up wraps",
+  },
+  {
+    "state": {
+      "cells": [
+        "·*^ | A | B | C | Extra",
+        "1 | TP53 | 2.5 | · | x",
+        "2 | X | · | · | y",
+        "3 | · | · | · | ·",
+        "4 | · | · | · | ·",
+        "New | ATM | -1 | · | ·",
+      ],
+      "hasFocus": true,
+      "maxCols": [
+        "New@0,5",
+        "TP53@1,1",
+        "2.5@2,1",
+        "C@3,0",
+        "Extra@4,0",
+      ],
+      "selected": 3,
+      "start": {
+        "x": 0,
+        "y": 0,
+      },
+      "stop": {
+        "x": 0,
+        "y": 0,
+      },
+    },
+    "step": "left wraps",
+  },
+  {
+    "state": {
+      "cells": [
+        "·* | A | B | C | Extra",
+        "1*^ | TP53 | 2.5 | · | x",
+        "2 | X | · | · | y",
+        "3 | · | · | · | ·",
+        "4 | · | · | · | ·",
+        "New | ATM | -1 | · | ·",
+      ],
+      "hasFocus": true,
+      "maxCols": [
+        "New@0,5",
+        "TP53@1,1",
+        "2.5@2,1",
+        "C@3,0",
+        "Extra@4,0",
+      ],
+      "selected": 5,
+      "start": {
+        "x": 0,
+        "y": 1,
+      },
+      "stop": {
+        "x": 0,
+        "y": 0,
+      },
+    },
+    "step": "down shift",
+  },
+  {
+    "state": {
+      "cells": [
+        "·* | A* | B | C | Extra",
+        "1* | TP53*^ | 2.5 | · | x",
+        "2 | X | · | · | y",
+        "3 | · | · | · | ·",
+        "4 | · | · | · | ·",
+        "New | ATM | -1 | · | ·",
+      ],
+      "hasFocus": true,
+      "maxCols": [
+        "New@0,5",
+        "TP53@1,1",
+        "2.5@2,1",
+        "C@3,0",
+        "Extra@4,0",
+      ],
+      "selected": 10,
+      "start": {
+        "x": 1,
+        "y": 1,
+      },
+      "stop": {
+        "x": 0,
+        "y": 0,
+      },
+    },
+    "step": "right shift",
+  },
+  {
+    "state": {
+      "cells": [
+        "· | A | B | C | Extra*",
+        "1 | TP53 | 2.5 | · | x",
+        "2 | X | · | · | y",
+        "3 | · | · | · | ·",
+        "4 | · | · | · | ·",
+        "New* | ATM | -1 | · | ·*^",
+      ],
+      "hasFocus": true,
+      "maxCols": [
+        "New@0,5",
+        "TP53@1,1",
+        "2.5@2,1",
+        "C@3,0",
+        "Extra@4,0",
+      ],
+      "selected": 3,
+      "start": {
+        "x": 4,
+        "y": 5,
+      },
+      "stop": {
+        "x": 4,
+        "y": 5,
+      },
+    },
+    "step": "focusLast",
+  },
+  {
+    "state": {
+      "cells": [
+        "·*^ | A | B | C | Extra",
+        "1 | TP53 | 2.5 | · | x",
+        "2 | X | · | · | y",
+        "3 | · | · | · | ·",
+        "4 | · | · | · | ·",
+        "New | ATM | -1 | · | ·",
+      ],
+      "hasFocus": true,
+      "maxCols": [
+        "New@0,5",
+        "TP53@1,1",
+        "2.5@2,1",
+        "C@3,0",
+        "Extra@4,0",
+      ],
+      "selected": 3,
+      "start": {
+        "x": 0,
+        "y": 0,
+      },
+      "stop": {
+        "x": 0,
+        "y": 0,
+      },
+    },
+    "step": "down wraps",
+  },
+  {
+    "state": {
+      "cells": [
+        "· | A* | B* | C | Extra",
+        "1* | P1*^ | P2* | · | x",
+        "2* | P3* | ·* | · | y",
+        "3* | P5* | P6* | · | ·",
+        "4 | · | · | · | ·",
+        "New | ATM | -1 | · | ·",
+      ],
+      "hasFocus": true,
+      "maxCols": [
+        "New@0,5",
+        "ATM@1,5",
+        "P2@1,1",
+        "C@3,0",
+        "Extra@4,0",
+      ],
+      "selected": 14,
+      "start": {
+        "x": 1,
+        "y": 1,
+      },
+      "stop": {
+        "x": 2,
+        "y": 3,
+      },
+    },
+    "step": "paste",
+  },
+  {
+    "state": {
+      "cells": [
+        "· | A | B* | C | Extra",
+        "1* | P1 | ·*^ | · | x",
+        "2* | P3 | ·* | · | y",
+        "3* | P5 | ·* | · | ·",
+        "4 | · | · | · | ·",
+        "New | ATM | -1 | · | ·",
+      ],
+      "hasFocus": true,
+      "maxCols": [
+        "New@0,5",
+        "ATM@1,5",
+        "P2@1,1",
+        "C@3,0",
+        "Extra@4,0",
+      ],
+      "selected": 7,
+      "start": {
+        "x": 2,
+        "y": 1,
+      },
+      "stop": {
+        "x": 2,
+        "y": 3,
+      },
+    },
+    "step": "delete range",
+  },
+  {
+    "state": {
+      "cells": [
+        "·* | A | B | C | Extra | E*^",
+        "1 | P1 | · | · | x | ·",
+        "2 | P3 | · | · | y | ·",
+        "3 | P5 | · | · | · | ·",
+        "4 | · | · | · | · | ·",
+        "New | ATM | -1 | · | · | ·",
+      ],
+      "hasFocus": true,
+      "maxCols": [
+        "New@0,5",
+        "ATM@1,5",
+        "P2@1,1",
+        "C@3,0",
+        "Extra@4,0",
+        "E@5,0",
+      ],
+      "selected": 3,
+      "start": {
+        "x": 5,
+        "y": 0,
+      },
+      "stop": {
+        "x": 5,
+        "y": 0,
+      },
+    },
+    "step": "addColumn",
+  },
+  {
+    "state": {
+      "cells": [
+        "·* | A | B | C | Extra | E",
+        "1 | P1 | · | · | x | ·",
+        "2 | P3 | · | · | y | ·",
+        "3 | P5 | · | · | · | ·",
+        "4 | · | · | · | · | ·",
+        "New | ATM | -1 | · | · | ·",
+        "6*^ | · | · | · | · | ·",
+      ],
+      "hasFocus": true,
+      "maxCols": [
+        "New@0,5",
+        "ATM@1,5",
+        "P2@1,1",
+        "C@3,0",
+        "Extra@4,0",
+        "E@5,0",
+      ],
+      "selected": 3,
+      "start": {
+        "x": 0,
+        "y": 6,
+      },
+      "stop": {
+        "x": 0,
+        "y": 6,
+      },
+    },
+    "step": "addRow",
+  },
+  {
+    "state": {
+      "cells": [
+        "· | A | B | C | E",
+        "1 | P1 | · | · | ·",
+        "2 | P3 | · | · | ·",
+        "3 | P5 | · | · | ·",
+        "4 | · | · | · | ·",
+        "New | ATM | -1 | · | ·",
+        "6 | · | · | · | ·",
+      ],
+      "hasFocus": false,
+      "maxCols": [
+        "New@0,5",
+        "ATM@1,5",
+        "P2@1,1",
+        "C@3,0",
+        "E@5,0",
+      ],
+      "selected": 0,
+      "start": {
+        "x": 0,
+        "y": 0,
+      },
+      "stop": {
+        "x": 0,
+        "y": 0,
+      },
+    },
+    "step": "deleteColumn by name",
+  },
+  {
+    "state": {
+      "cells": [
+        "· | A | B | C | E",
+        "2 | P3 | · | · | ·",
+        "3 | P5 | · | · | ·",
+        "4 | · | · | · | ·",
+        "New | ATM | -1 | · | ·",
+        "6 | · | · | · | ·",
+      ],
+      "hasFocus": false,
+      "maxCols": [
+        "New@0,5",
+        "ATM@1,4",
+        "P2@1,1",
+        "C@3,0",
+        "E@5,0",
+      ],
+      "selected": 0,
+      "start": {
+        "x": 0,
+        "y": 0,
+      },
+      "stop": {
+        "x": 0,
+        "y": 0,
+      },
+    },
+    "step": "deleteRow by index",
+  },
+  {
+    "state": {
+      "cells": [
+        "· | A | B | C | E",
+        "2 | P3 | · | · | ·",
+        "3 | P5 | · | · | ·",
+        "4 | · | · | · | ·",
+        "6 | · | · | · | ·",
+      ],
+      "hasFocus": false,
+      "maxCols": [
+        "New@0,5",
+        "P3@1,1",
+        "P2@1,1",
+        "C@3,0",
+        "E@5,0",
+      ],
+      "selected": 0,
+      "start": {
+        "x": 0,
+        "y": 0,
+      },
+      "stop": {
+        "x": 0,
+        "y": 0,
+      },
+    },
+    "step": "deleteRow by name",
+  },
+  {
+    "state": {
+      "cells": [
+        "· | A | B | C | E",
+        "2 | P3 | · | · | ·",
+        "3 | P5 | · | · | ·",
+        "4 | · | · | · | ·",
+        "6 | · | · | · | ·",
+      ],
+      "hasFocus": false,
+      "maxCols": [
+        "New@0,5",
+        "P3@1,1",
+        "P2@1,1",
+        "C@3,0",
+        "E@5,0",
+      ],
+      "selected": 0,
+      "start": {
+        "x": 0,
+        "y": 0,
+      },
+      "stop": {
+        "x": 0,
+        "y": 0,
+      },
+    },
+    "step": "deleteColumn refused at 0",
+  },
+  {
+    "state": {
+      "cells": [
+        "h1 | h2 | B | C | E",
+        "v1 | v2 | · | · | ·",
+        "v3 | · | · | · | ·",
+        "4 | · | · | · | ·",
+        "6 | · | · | · | ·",
+      ],
+      "hasFocus": false,
+      "maxCols": [
+        "New@0,5",
+        "P3@1,1",
+        "P2@1,1",
+        "C@3,0",
+        "E@5,0",
+      ],
+      "selected": 0,
+      "start": {
+        "x": 0,
+        "y": 0,
+      },
+      "stop": {
+        "x": 0,
+        "y": 0,
+      },
+    },
+    "step": "import unmapped",
+  },
+  {
+    "state": {
+      "cells": [
+        "h1 | h2 | B | C | E",
+        "v1 | v2 | · | · | ·",
+        "v3 | · | · | · | ·",
+        "4 | · | · | · | ·",
+        "6 | · | · | · | ·",
+      ],
+      "hasFocus": false,
+      "maxCols": [
+        "New@0,5",
+        "P3@1,1",
+        "P2@1,1",
+        "C@3,0",
+        "E@5,0",
+      ],
+      "selected": 0,
+      "start": {
+        "x": 0,
+        "y": 0,
+      },
+      "stop": {
+        "x": 0,
+        "y": 0,
+      },
+    },
+    "step": "blur",
+  },
+  {
+    "state": {
+      "cells": [
+        "· | A | B | C",
+        "1 | · | · | ·",
+        "2 | · | · | ·",
+        "3 | · | · | ·",
+        "4 | · | · | ·",
+      ],
+      "hasFocus": false,
+      "maxCols": [
+        "@0,0",
+        "A@1,0",
+        "B@2,0",
+        "C@3,0",
+      ],
+      "selected": 0,
+      "start": {
+        "x": 0,
+        "y": 0,
+      },
+      "stop": {
+        "x": 0,
+        "y": 0,
+      },
+    },
+    "step": "clear",
+  },
+  {
+    "state": {
+      "cells": [
+        "· | A | B | C",
+        "1 | · | · | ·",
+        "2 | · | · | ·",
+        "3 | · | · | ·",
+        "4 | · | · | ·",
+      ],
+      "hasFocus": false,
+      "maxCols": [
+        "@0,0",
+        "A@1,0",
+        "B@2,0",
+        "C@3,0",
+      ],
+      "selected": 0,
+      "start": {
+        "x": 1,
+        "y": 1,
+      },
+      "stop": {
+        "x": 1,
+        "y": 1,
+      },
+    },
+    "step": "deselect",
+  },
+]
+`;
diff --git a/projects/reactome-table/src/lib/state/table.store.session.spec.ts b/projects/reactome-table/src/lib/state/table.store.session.spec.ts
new file mode 100644
index 00000000..593ecbf1
--- /dev/null
+++ b/projects/reactome-table/src/lib/state/table.store.session.spec.ts
@@ -0,0 +1,187 @@
+import { beforeAll, describe, expect, it } from 'vitest';
+import { firstValueFrom, type Observable } from 'rxjs';
+import { type Cell, TableStore, type TableState } from './table.store';
+
+/**
+ * The table store, held to what it does today, step by step through an
+ * editing session: generate, import, type, move, select, paste, delete, add and
+ * remove rows and columns, and read it back through every selector.
+ *
+ * Written before the store's index reads were rewritten for
+ * noUncheckedIndexedAccess (#345), so that rewrite can be shown to change
+ * nothing: the snapshots were recorded against the code as it was.
+ */
+
+/** Everything a step can change, in a form a snapshot shows plainly. */
+function view(state: TableState) {
+  return {
+    cells: state.dataset.map((row) =>
+      row
+        .map(
+          (cell) =>
+            (cell.value || '·') +
+            (cell.selected ? '*' : '') +
+            (cell.visibility === 'hidden' ? '^' : '')
+        )
+        .join(' | ')
+    ),
+    maxCols: state.maxCols.map((max) => `${max.value}@${max.coords.x},${max.coords.y}`),
+    start: state.start,
+    stop: state.stop,
+    selected: state.selectedCoords.length,
+    hasFocus: state.hasFocus,
+  };
+}
+
+/** A selector's first value, or the error it throws: both are behaviour. */
+async function read<T>(source: Observable<T>): Promise<T | string> {
+  try {
+    return await firstValueFrom(source);
+  } catch (error) {
+    return `threw ${error instanceof Error ? error.message : String(error)}`;
+  }
+}
+
+const values = (cells: (Cell | undefined)[] | string) =>
+  typeof cells === 'string' ? cells : cells.map((cell) => cell?.value);
+
+async function selectors(store: TableStore) {
+  return {
+    value: await read(store.value$),
+    colNames: await read(store.colNames$),
+    rowNames: await read(store.rowNames$),
+    range: await read(store.range$),
+    cleanData: await read(store.cleanData$),
+    hasData: await read(store.hasData$),
+    columnByName: values(await read(store.column$({ name: 'B' }))),
+    columnByIndex: values(await read(store.column$({ index: 1, includeName: true }))),
+    rowByName: values(await read(store.row$({ name: '2' }))),
+    // Asked only when there is a row 1: a selector that throws errors the
+    // store's shared state stream, and every later read would come back empty.
+    rowByIndex:
+      store.state().dataset.length > 1
+        ? values(await read(store.row$({ index: 1, includeName: true })))
+        : 'no row 1',
+  };
+}
+
+describe('TableStore through an editing session', () => {
+  let store: TableStore;
+  const steps: { step: string; state: ReturnType<typeof view> }[] = [];
+  const record = (step: string) => steps.push({ step, state: view(store.state()) });
+
+  // Built directly, not through TestBed: TestBed tears its injector down after
+  // every test, which would destroy the store between the session's steps.
+  beforeAll(() => {
+    store = new TableStore();
+  });
+
+  it('starts empty', async () => {
+    record('new');
+    expect(await selectors(store)).toMatchSnapshot();
+  });
+
+  it('generates a template', async () => {
+    store.init({ numberOfColumns: 4, numberOfRows: 5 });
+    record('init 4x5');
+    expect(await selectors(store)).toMatchSnapshot();
+  });
+
+  it('imports a table, mapping its headers onto the template', async () => {
+    store.import({
+      table: [
+        ['', 'A', 'B', 'Extra'],
+        ['1', 'TP53', '2.5', 'x'],
+        ['2', 'BRCA1', '', 'y'],
+        ['New', 'ATM', '-1', ''],
+      ],
+      hasRowNames: true,
+      hasColNames: true,
+    });
+    record('import mapped');
+    expect(await selectors(store)).toMatchSnapshot();
+  });
+
+  it('types into the selected cell, moving the column maximum up and down', async () => {
+    store.selectCell({ coords: { x: 1, y: 2 } });
+    store.write({ value: 'A-much-longer-gene-name' });
+    record('write longer');
+    store.write({ value: 'X' });
+    record('write shorter');
+    expect(await selectors(store)).toMatchSnapshot();
+  });
+
+  it('moves the selection, wrapping at the edges', () => {
+    store.focusFirst();
+    record('focusFirst');
+    store.up({ shift: false });
+    record('up wraps');
+    store.left({ shift: false });
+    record('left wraps');
+    store.down({ shift: true });
+    record('down shift');
+    store.right({ shift: true });
+    record('right shift');
+    store.focusLast();
+    record('focusLast');
+    store.down({ shift: false });
+    record('down wraps');
+  });
+
+  it('pastes over a range, and deletes one', async () => {
+    store.selectRange({ start: { x: 1, y: 1 }, stop: { x: 2, y: 2 } });
+    store.paste({
+      table: [
+        [' P1 ', 'P2'],
+        ['P3', ''],
+        ['P5', 'P6'],
+      ],
+    });
+    record('paste');
+    store.selectRange({ start: { x: 2, y: 1 }, stop: { x: 2, y: 3 } });
+    store.delete();
+    record('delete range');
+    expect(await selectors(store)).toMatchSnapshot();
+  });
+
+  it('adds and removes rows and columns', async () => {
+    store.addColumn();
+    record('addColumn');
+    store.addRow();
+    record('addRow');
+    store.deleteColumn({ name: 'Extra' });
+    record('deleteColumn by name');
+    store.deleteRow({ y: 1 });
+    record('deleteRow by index');
+    store.deleteRow({ name: 'New' });
+    record('deleteRow by name');
+    store.deleteColumn({ x: 0 });
+    record('deleteColumn refused at 0');
+    expect(await selectors(store)).toMatchSnapshot();
+  });
+
+  it('imports without mapping headers', async () => {
+    store.settings({ settings: { importMapHeaders: false } });
+    store.import({
+      table: [['h1', 'h2'], ['v1', 'v2'], ['v3']],
+      hasRowNames: false,
+      hasColNames: false,
+    });
+    record('import unmapped');
+    expect(await selectors(store)).toMatchSnapshot();
+  });
+
+  it('clears back to the template', async () => {
+    store.blur();
+    record('blur');
+    store.clear();
+    record('clear');
+    store.deselect();
+    record('deselect');
+    expect(await selectors(store)).toMatchSnapshot();
+  });
+
+  it('went through every step as recorded', () => {
+    expect(steps).toMatchSnapshot();
+  });
+});
diff --git a/projects/reactome-table/src/lib/state/table.store.ts b/projects/reactome-table/src/lib/state/table.store.ts
index 1c166f65..71265339 100644
--- a/projects/reactome-table/src/lib/state/table.store.ts
+++ b/projects/reactome-table/src/lib/state/table.store.ts
@@ -55,17 +55,47 @@ export const cell = (
 
 export const EMPTY_CELL: Cell = cell();
 
+/**
+ * The row at y. Out of range it throws, as reading a cell of it always did --
+ * now saying where rather than reading a property of undefined.
+ */
+function rowAt(dataset: Cell[][], y: number): Cell[] {
+  const row = dataset[y];
+  if (!row) throw new RangeError(`The table has no row ${y}.`);
+  return row;
+}
+
+/** The cell at x, y; out of range it throws, as reading it always did. */
+function cellAt(dataset: Cell[][], x: number, y: number): Cell {
+  const found = rowAt(dataset, y)[x];
+  if (!found) throw new RangeError(`The table has no cell at ${x}, ${y}.`);
+  return found;
+}
+
+/** The longest value in column x; out of range it throws, as reading it did. */
+function maxAt(state: TableState, x: number): LocatedValue {
+  const max = state.maxCols[x];
+  if (!max) throw new RangeError(`The table has no column ${x}.`);
+  return max;
+}
+
+/**
+ * Every row is as wide as the first: pushAll and addRow keep them so. A read
+ * across rows at one index therefore finds a cell in each.
+ */
+const atColumn = (row: Cell[], x: number) => row[x] as Cell;
+
 function addColumn(state: TableState, columnName?: string) {
   const x = pushAll(state.dataset, cell()) - 1;
   const value = columnName || numberToLetter(x);
-  state.dataset[0][x].value = value;
+  cellAt(state.dataset, x, 0).value = value;
   state.maxCols.push({ value, coords: { x: x, y: 0 } });
   return { x, value };
 }
 
 function addRow(state: TableState) {
-  const y = state.dataset.push(state.dataset[0].map(() => cell())) - 1;
-  state.dataset[y][0].value = '' + y;
+  const y = state.dataset.push(rowAt(state.dataset, 0).map(() => cell())) - 1;
+  cellAt(state.dataset, 0, y).value = '' + y;
   return y;
 }
 
@@ -136,9 +166,17 @@ export class TableStore extends ComponentStore<TableState> {
   readonly hasFocus$ = this.select((state) => state.hasFocus);
   readonly maxColumns$ = this.select((state) => state.maxCols);
 
-  readonly value$ = this.select((state) => state.dataset[state.start.y][state.start.x].value);
-  readonly colNames$ = this.select((state) => state.dataset[0].slice(1).map((cell) => cell.value));
-  readonly rowNames$ = this.select((state) => state.dataset.slice(1).map((cell) => cell[0].value));
+  readonly value$ = this.select(
+    (state) => cellAt(state.dataset, state.start.x, state.start.y).value
+  );
+  readonly colNames$ = this.select((state) =>
+    rowAt(state.dataset, 0)
+      .slice(1)
+      .map((cell) => cell.value)
+  );
+  readonly rowNames$ = this.select((state) =>
+    state.dataset.slice(1).map((row) => atColumn(row, 0).value)
+  );
   readonly range$ = this.select((state) => {
     const range = Ranges.minMax(state.start, state.stop);
     return state.dataset
@@ -149,19 +187,19 @@ export class TableStore extends ComponentStore<TableState> {
   readonly column$ = (props: ({ index: number } | Named) & { includeName?: boolean }) =>
     this.select((state) => {
       const x = isNamed(props)
-        ? state.dataset[0].findIndex((cell) => cell.value == props.name)
+        ? rowAt(state.dataset, 0).findIndex((cell) => cell.value == props.name)
         : props.index;
       if (x < 1) return [];
-      return state.dataset.map((row) => row[x]).slice(props.includeName ? 0 : 1);
+      return state.dataset.map((row) => atColumn(row, x)).slice(props.includeName ? 0 : 1);
     });
 
   readonly row$ = (props: ({ index: number } | Named) & { includeName?: boolean }) =>
     this.select((state) => {
       const y = isNamed(props)
-        ? state.dataset.findIndex((cell) => cell[0].value == props.name)
+        ? state.dataset.findIndex((row) => atColumn(row, 0).value == props.name)
         : props.index;
       if (y < 1) return [];
-      return state.dataset[y].slice(props.includeName ? 0 : 1);
+      return rowAt(state.dataset, y).slice(props.includeName ? 0 : 1);
     });
 
   // Writers (Reducers)
@@ -223,11 +261,10 @@ export class TableStore extends ComponentStore<TableState> {
     if (state.start) state.hasFocus = true;
     const x = state.start.x;
     const y = state.start.y;
-    const cell = state.dataset[y][x];
-
-    state.dataset[y][x] = { ...cell, value };
+    const row = rowAt(state.dataset, y);
+    row[x] = { ...(row[x] ?? cell()), value };
     state.start = { ...state.start };
-    const maxInColumn = state.maxCols[x];
+    const maxInColumn = maxAt(state, x);
 
     if (Ranges.equals(state.start, maxInColumn.coords)) {
       if (value.length > maxInColumn.value.length)
@@ -299,8 +336,8 @@ export class TableStore extends ComponentStore<TableState> {
     const colsToGetMax = new Set<number>();
     for (let y = range.y.min; y <= range.y.max; y++) {
       for (let x = range.x.min; x <= range.x.max; x++) {
-        state.dataset[y][x].value = '';
-        if (Ranges.equals(state.maxCols[x].coords, { x, y })) colsToGetMax.add(x);
+        cellAt(state.dataset, x, y).value = '';
+        if (Ranges.equals(maxAt(state, x).coords, { x, y })) colsToGetMax.add(x);
       }
     }
     colsToGetMax.forEach((x) => (state.maxCols[x] = Ranges.findMaximumOfColumn(state, x)));
@@ -312,16 +349,17 @@ export class TableStore extends ComponentStore<TableState> {
     const colsToGetMax = new Set<number>();
     const isGenerated = state.numberOfColumns && state.numberOfRows;
 
-    for (let yFrom = 0; yFrom < table.length; yFrom++) {
+    for (const [yFrom, pastedRow] of table.entries()) {
       const yTo = range.y.min + yFrom;
       if (isGenerated && yTo >= state.dataset.length) addRow(state);
-      for (let xFrom = 0; xFrom < table[yFrom].length; xFrom++) {
+      for (const [xFrom, pasted] of pastedRow.entries()) {
         const xTo = range.x.min + xFrom;
-        if (isGenerated && xTo >= state.dataset[0].length) addColumn(state);
-        if (state.dataset[yTo]?.[xTo]) {
-          const value = table[yFrom][xFrom].trim();
-          const maxCol = state.maxCols[xTo];
-          state.dataset[yTo][xTo].value = value;
+        if (isGenerated && xTo >= rowAt(state.dataset, 0).length) addColumn(state);
+        const target = state.dataset[yTo]?.[xTo];
+        if (target) {
+          const value = pasted.trim();
+          const maxCol = maxAt(state, xTo);
+          target.value = value;
           if (
             value.length > maxCol.value.length ||
             Ranges.equals(maxCol.coords, {
@@ -352,7 +390,7 @@ export class TableStore extends ComponentStore<TableState> {
       start: { x: 0, y: 0 },
       stop: { x: 0, y: 0 },
       dataset: dataset,
-      maxCols: dataset[0].map((cell, x) => ({ value: cell.value, coords: { x, y: 0 } })),
+      maxCols: rowAt(dataset, 0).map((cell, x) => ({ value: cell.value, coords: { x, y: 0 } })),
     };
   });
 
@@ -408,23 +446,28 @@ export class TableStore extends ComponentStore<TableState> {
       }
     ) => {
       if (state.settings.importMapHeaders) {
-        const nameToRowI = new Map(state.dataset.map((row, i) => [row[0].value, i]));
-        const nameToColI = new Map(state.dataset[0].map((cell, i) => [cell.value, i]));
+        // Keyed by name; a row or column of the import with no name has none.
+        const nameToRowI = new Map<string | undefined, number>(
+          state.dataset.map((row, i) => [atColumn(row, 0).value, i])
+        );
+        const nameToColI = new Map<string | undefined, number>(
+          rowAt(state.dataset, 0).map((cell, i) => [cell.value, i])
+        );
+        const header = table[0] ?? [];
 
-        for (let yFrom = 0; yFrom < table.length; yFrom++) {
+        for (const importedRow of table) {
           let xTo, yTo: number;
-          const rowName = table[yFrom][0];
+          const rowName = importedRow[0];
           if (hasRowNames && nameToRowI.has(rowName)) {
             // Row already present
             yTo = nameToRowI.get(rowName) as number;
           } else if (fullImport || state.settings.addRow) {
             // New row to add
-            yTo = state.dataset.push(state.dataset[0].map(() => cell())) - 1;
+            yTo = state.dataset.push(rowAt(state.dataset, 0).map(() => cell())) - 1;
             nameToRowI.set(rowName, yTo);
           } else continue; // skip row since not present and cannot be added
 
-          for (let xFrom = 0; xFrom < table[0].length; xFrom++) {
-            const colName = table[0][xFrom];
+          for (const [xFrom, colName] of header.entries()) {
             if (hasColNames && nameToColI.has(colName)) {
               // Column already present
               xTo = nameToColI.get(colName) as number;
@@ -434,24 +477,26 @@ export class TableStore extends ComponentStore<TableState> {
               nameToColI.set(colName, xTo);
             } else continue; // skip column since not present and cannot be added
 
-            const value = (table[yFrom][xFrom] || '').trim();
-            state.dataset[yTo][xTo].value = value;
-            if (value.length > state.maxCols[xTo].value.length)
+            const value = (importedRow[xFrom] || '').trim();
+            cellAt(state.dataset, xTo, yTo).value = value;
+            if (value.length > maxAt(state, xTo).value.length)
               state.maxCols[xTo] = { value, coords: { x: xTo, y: yTo } };
           }
         }
       } else {
         // Simple import without mapping
 
-        for (let yFrom = 0; yFrom < table.length; yFrom++) {
+        // As wide as the first row, whatever each row's own length.
+        const width = (table[0] ?? []).length;
+        for (const [yFrom, importedRow] of table.entries()) {
           const yTo = state.settings.renameCols ? yFrom : yFrom + 1;
           if (yTo >= state.dataset.length) addRow(state);
-          for (let xFrom = 0; xFrom < table[0].length; xFrom++) {
+          for (let xFrom = 0; xFrom < width; xFrom++) {
             const xTo = state.settings.renameRows ? xFrom : xFrom + 1;
-            if (xTo >= state.dataset[0].length) addColumn(state);
-            const value = (table[yFrom][xFrom] || '').trim();
-            state.dataset[yTo][xTo].value = value;
-            if (value.length > state.maxCols[xTo].value.length)
+            if (xTo >= rowAt(state.dataset, 0).length) addColumn(state);
+            const value = (importedRow[xFrom] || '').trim();
+            cellAt(state.dataset, xTo, yTo).value = value;
+            if (value.length > maxAt(state, xTo).value.length)
               state.maxCols[xTo] = { value, coords: { x: xTo, y: yTo } };
           }
         }
@@ -479,7 +524,7 @@ export class TableStore extends ComponentStore<TableState> {
 
   readonly deleteColumn = this.updater((state, props: { x: number } | Named) => {
     const x = isNamed(props)
-      ? state.dataset[0].findIndex((cell) => cell.value === props.name)
+      ? rowAt(state.dataset, 0).findIndex((cell) => cell.value === props.name)
       : props.x;
     if (x < 1) return state;
     state.dataset.forEach((row) => row.splice(x, 1));
@@ -492,7 +537,7 @@ export class TableStore extends ComponentStore<TableState> {
   });
   readonly deleteRow = this.updater((state, props: { y: number } | Named) => {
     const y = isNamed(props)
-      ? state.dataset.map((row) => row[0]).findIndex((cell) => cell.value === props.name)
+      ? state.dataset.findIndex((row) => atColumn(row, 0).value === props.name)
       : props.y;
     if (y < 1) return state;
     state.dataset.splice(y, 1);
@@ -567,11 +612,9 @@ export namespace Ranges {
   type Range = { x: MinMax; y: MinMax };
 
   export function minMax(start: Coords, stop: Coords): Range {
-    const [minX, maxX] = [start.x, stop.x].sort((a, b) => a - b);
-    const [minY, maxY] = [start.y, stop.y].sort((a, b) => a - b);
     return {
-      x: { min: minX, max: maxX },
-      y: { min: minY, max: maxY },
+      x: { min: Math.min(start.x, stop.x), max: Math.max(start.x, stop.x) },
+      y: { min: Math.min(start.y, stop.y), max: Math.max(start.y, stop.y) },
     };
   }
 
@@ -626,7 +669,8 @@ export namespace Ranges {
   }
 
   export function column<T>(table: T[][], x: number): T[] {
-    return table.map((row: T[]) => row[x]);
+    // Every row as wide as the first; see atColumn.
+    return table.map((row: T[]) => row[x] as T);
   }
 
   export function findMaximumOfColumn(state: TableState, x: number): LocatedValue {
@@ -638,7 +682,7 @@ export namespace Ranges {
               coords: { x, y },
             }
           : max,
-      { value: state.dataset[state.start.y][x].value, coords: state.start }
+      { value: cellAt(state.dataset, x, state.start.y).value, coords: state.start }
     );
   }
 }
@@ -646,7 +690,7 @@ export namespace Ranges {
 namespace Cells {
   export function select(state: TableState): TableState {
     state.selectedCoords.forEach((coords) => {
-      const cell = state.dataset[coords.y][coords.x];
+      const cell = rowAt(state.dataset, coords.y)[coords.x];
       if (cell) {
         cell.selected = false;
         cell.visibility = 'visible';
@@ -662,13 +706,13 @@ namespace Cells {
       }
       selectCell({ x, y: 0 }, state);
     }
-    const selectedCell = state.dataset[state.start.y][state.start.x];
+    const selectedCell = rowAt(state.dataset, state.start.y)[state.start.x];
     if (selectedCell) selectedCell.visibility = 'hidden';
     return state;
   }
 
   function selectCell(coords: Coords, state: TableState): Coords {
-    state.dataset[coords.y][coords.x].selected = true;
+    cellAt(state.dataset, coords.x, coords.y).selected = true;
     state.selectedCoords.push(coords);
     return coords;
   }
diff --git a/projects/reactome-table/src/lib/utils/table.util.ts b/projects/reactome-table/src/lib/utils/table.util.ts
index 58222aef..d0a74a5d 100644
--- a/projects/reactome-table/src/lib/utils/table.util.ts
+++ b/projects/reactome-table/src/lib/utils/table.util.ts
@@ -5,13 +5,21 @@ export enum TableOrder {
   ROW_BY_ROW,
 }
 
-export const width = (table: any[][]) => table[0].length - 1;
+/** The first row of a table; one with no rows throws, as reading its width did. */
+const firstRow = <T>(table: T[][]): T[] => {
+  const [first] = table;
+  if (!first) throw new RangeError('The table has no rows.');
+  return first;
+};
+
+export const width = (table: any[][]) => firstRow(table).length - 1;
 export const height = (table: any[][]) => table.length - 1;
 
 export const cp = <T>(obj: T) => JSON.parse(JSON.stringify(obj)) as T;
 
 export const transpose = <T>(table: T[][]): T[][] =>
-  table[0].map((_, colIndex) => table.map((row) => row[colIndex]));
+  // Rows as wide as the first, so each has a value at every index of it.
+  firstRow(table).map((_, colIndex) => table.map((row) => row[colIndex] as T));
 export const findColumnValuesByName = <T>(table: T[][], columnHeader: T): T[] | undefined =>
   transpose(table)
     .find((col) => col[0] === columnHeader)
diff --git a/projects/website-angular/src/app/search/answer/chat-handoff.spec.ts b/projects/website-angular/src/app/search/answer/chat-handoff.spec.ts
index be77bc08..b8d71729 100644
--- a/projects/website-angular/src/app/search/answer/chat-handoff.spec.ts
+++ b/projects/website-angular/src/app/search/answer/chat-handoff.spec.ts
@@ -47,8 +47,9 @@ describe('continuing in chat', () => {
     const { win } = fakes();
     const fetcher = respond({ status: 200, body: { path: '/chat/guest/#handoff=abc' } });
     await continueInChat('/chat-handoff', analysis, { win, fetcher });
-    const [, init] = (fetcher as unknown as { mock: { calls: [string, RequestInit][] } }).mock
-      .calls[0];
+    const [call] = (fetcher as unknown as { mock: { calls: [string, RequestInit][] } }).mock.calls;
+    if (!call) throw new Error('the handoff was never asked for');
+    const [, init] = call;
     expect(JSON.parse(init.body as string)).toEqual(analysis);
   });
 
diff --git a/scripts/check-indexed-access.mjs b/scripts/check-indexed-access.mjs
deleted file mode 100644
index 26b0bda7..00000000
--- a/scripts/check-indexed-access.mjs
+++ /dev/null
@@ -1,156 +0,0 @@
-#!/usr/bin/env node
-/**
- * Hold the `noUncheckedIndexedAccess` findings at today's count, file by file,
- * in the projects that do not have the flag yet (#345).
- *
- * The app and the embeddable diagram reached zero and have it in their own
- * tsconfig.app.json, so their builds enforce it. What is left is the workspace
- * libraries, listed in PROJECTS; when they reach zero too, the flag goes into
- * tsconfig.json for everything and this check goes.
- *
- * With the flag, `arr[i]` and `record[key]` are typed `T | undefined`, which is
- * the honest type: an index out of range or a missing key really is undefined,
- * and the code then dereferences it. It is a compiler flag, so it has no warning
- * level, and turning it on fails the build until every finding is handled. This
- * counts them instead, the way scripts/check-lint.mjs holds its warnings: per
- * file, because a total lets a new finding hide behind a fix elsewhere, and a
- * file the baseline does not list is held at zero.
- *
- * Moving or renaming a file with findings shows as an increase under its new
- * path. Check the total is unchanged, then run with --update.
- *
- * It runs each project's own build config with the flag added. A run that
- * fails without naming a single finding is a crash, not a clean result, and is
- * refused. (tsconfig.spec.json is left out: it cannot resolve vitest/globals,
- * as scripts/check-types.mjs says.)
- *
- *     node scripts/check-indexed-access.mjs           check against the baseline
- *     node scripts/check-indexed-access.mjs --update  record today's counts
- */
-import { spawnSync } from 'node:child_process';
-import { existsSync, readFileSync, writeFileSync } from 'node:fs';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { compare } from './check-lint.mjs';
-import { isEntry } from './is-entry.mjs';
-
-const ROOT = join(dirname(fileURLToPath(import.meta.url)), '..');
-const BASELINE = join(ROOT, 'indexed-access-baseline.json');
-const PROJECTS = [
-  'projects/reactome-table/tsconfig.lib.json',
-  'projects/reactome-gsa-form/tsconfig.lib.json',
-];
-
-/** `file(line,col): error TS…` lines, counted per file. */
-export function countErrors(/** @type {string} */ output) {
-  /** @type {Record<string, number>} */
-  const counts = {};
-  for (const line of output.split('\n')) {
-    const match = /^(.+?)\(\d+,\d+\): error TS\d+:/.exec(line);
-    if (match) counts[match[1]] = (counts[match[1]] ?? 0) + 1;
-  }
-  return counts;
-}
-
-/**
- * What a tsc run says: its findings, or that it could not be read as findings.
- * @param {number | null} status
- * @param {string} output
- */
-export function outcome(status, output) {
-  if (status === 0) return { ok: true, counts: {} };
-  const counts = countErrors(output);
-  // An error with no file -- a bad option, a missing tsconfig -- or a failure
-  // with nothing counted means tsc did not get as far as the code.
-  const global = output.split('\n').some((line) => /^error TS\d+:/.test(line));
-  // A syntax error (TS1xxx) stops tsc before the type check, so the findings
-  // it would have reported are missing, not fixed.
-  const syntax = /\): error TS1\d{3}:/m.test(output);
-  if (global || syntax || Object.keys(counts).length === 0) return { ok: false, counts };
-  return { ok: true, counts };
-}
-
-/**
- * Several projects' counts as one: a file two projects compile is counted
- * once, at the larger of its counts.
- * @param {Record<string, number>[]} perProject
- */
-export function mergeCounts(perProject) {
-  /** @type {Record<string, number>} */
-  const merged = {};
-  for (const counts of perProject) {
-    for (const [file, n] of Object.entries(counts)) merged[file] = Math.max(merged[file] ?? 0, n);
-  }
-  return merged;
-}
-
-const total = (/** @type {Record<string, number>} */ counts) =>
-  Object.values(counts).reduce((a, b) => a + b, 0);
-
-/** One project's findings per file, or exits when tsc did not get that far. */
-function countProject(/** @type {string} */ project) {
-  const result = spawnSync(
-    'npx',
-    ['tsc', '--noEmit', '--pretty', 'false', '-p', project, '--noUncheckedIndexedAccess'],
-    { cwd: ROOT, encoding: 'utf8', maxBuffer: 64 * 1024 * 1024 }
-  );
-  const output = `${result.stdout ?? ''}${result.stderr ?? ''}`;
-  const run = outcome(result.status, output);
-  if (!run.ok) {
-    console.error(
-      `tsc did not get as far as the type check of ${project} (exit ${result.status}), so it has nothing to count:`
-    );
-    console.error(output.trim());
-    process.exit(1);
-  }
-  return run.counts;
-}
-
-function main() {
-  const merged = mergeCounts(PROJECTS.map(countProject));
-  const counts = Object.fromEntries(Object.entries(merged).sort(([a], [b]) => a.localeCompare(b)));
-  if (process.argv.includes('--update')) {
-    writeFileSync(
-      BASELINE,
-      `${JSON.stringify({ total: total(counts), files: counts }, null, 2)}\n`
-    );
-    console.log(
-      `Baseline set to ${total(counts)} findings in ${Object.keys(counts).length} files.`
-    );
-    return;
-  }
-
-  if (!existsSync(BASELINE)) {
-    console.error(`No baseline at ${BASELINE}: record one with --update.`);
-    process.exit(1);
-  }
-  const baseline = /** @type {{ files: Record<string, number> }} */ (
-    JSON.parse(readFileSync(BASELINE, 'utf8'))
-  ).files;
-  const { increased, decreased } = compare(counts, baseline);
-  if (increased.length) {
-    console.error('Unchecked indexed access went up (noUncheckedIndexedAccess, #345):\n');
-    for (const { rule: file, was, now } of increased) console.error(`  ${file}: ${was} -> ${now}`);
-    console.error(
-      `\nGuard the new index reads in those files: an index out of range or a missing key is` +
-        ` undefined. See them with:\n\n${PROJECTS.map((project) => `  npx tsc --noEmit -p ${project} --noUncheckedIndexedAccess`).join('\n')}\n\n` +
-        `A file that was only moved or renamed shows here under its new path: if the total` +
-        ` (${total(counts)} now, ${total(baseline)} before) has not gone up, run with --update.\n`
-    );
-    process.exit(1);
-  }
-  const was = total(baseline);
-  const now = total(counts);
-  if (decreased.length) {
-    console.log(
-      `Unchecked indexed access down from ${was} to ${now}: run with --update to lock it in.`
-    );
-  } else {
-    console.log(`Unchecked indexed access: ${now}, unchanged from the baseline.`);
-  }
-  if (now === 0) {
-    console.log('None left: add noUncheckedIndexedAccess to tsconfig.json, and remove this check.');
-  }
-}
-
-if (isEntry(import.meta.url)) main();
diff --git a/scripts/preflight.sh b/scripts/preflight.sh
index 55c6fcc6..0c6ca678 100755
--- a/scripts/preflight.sh
+++ b/scripts/preflight.sh
@@ -93,7 +93,6 @@ step "format" npm run format:check
 step "libraries" npm run build:libs
 step "types" npm run check:types
 step "lint" npm run check:lint
-step "unchecked indexed access" npm run check:indexed
 step "dead code" npm run check:dead
 step "unit tests" npm test
 step "e2e recordings" npm run check:har
diff --git a/tools/indexed-access-check/check-indexed-access.spec.mjs b/tools/indexed-access-check/check-indexed-access.spec.mjs
deleted file mode 100644
index 68c3f49a..00000000
--- a/tools/indexed-access-check/check-indexed-access.spec.mjs
+++ /dev/null
@@ -1,54 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { countErrors, mergeCounts, outcome } from '../../scripts/check-indexed-access.mjs';
-
-// tsc's own output, as `tsc --noEmit` prints it without --pretty.
-const output = [
-  "projects/a/src/x.ts(10,5): error TS2532: Object is possibly 'undefined'.",
-  "projects/a/src/x.ts(12,9): error TS18048: 'row' is possibly 'undefined'.",
-  "projects/b/src/y.ts(3,1): error TS2345: Argument of type 'string | undefined' is not assignable.",
-  "  Type 'undefined' is not assignable to type 'string'.",
-].join('\n');
-
-describe('the indexed-access count', () => {
-  it('counts errors per file, ignoring continuation lines', () => {
-    expect(countErrors(output)).toEqual({ 'projects/a/src/x.ts': 2, 'projects/b/src/y.ts': 1 });
-  });
-
-  it('reads a clean run as no errors', () => {
-    expect(outcome(0, '')).toEqual({ ok: true, counts: {} });
-  });
-
-  it('reads errors from a run that failed on them', () => {
-    expect(outcome(2, output)).toEqual({ ok: true, counts: countErrors(output) });
-  });
-
-  // With a syntax error tsc reports only that, skipping the type check: the
-  // count drops to one, and --update would record it.
-  it('refuses a run that stopped at a syntax error', () => {
-    expect(
-      outcome(2, 'projects/a/src/x.ts(4,1): error TS1128: Declaration or statement expected.').ok
-    ).toBe(false);
-  });
-
-  // A crash prints no error lines, which would otherwise read as a clean run
-  // (scripts/check-types.mjs says how that cost an afternoon).
-  it('refuses a run that failed without reporting an error', () => {
-    expect(outcome(134, 'FATAL ERROR: JavaScript heap out of memory').ok).toBe(false);
-    expect(outcome(2, 'error TS5058: The specified path does not exist').ok).toBe(false);
-  });
-
-  // The projects still counted are separate libraries, but a file two of them
-  // compiled would be reported by both: once is the truth.
-  it('counts a file two projects compile once, at its larger count', () => {
-    expect(
-      mergeCounts([
-        { 'a.ts': 2, 'b.ts': 1 },
-        { 'b.ts': 3, 'c.ts': 1 },
-      ])
-    ).toEqual({
-      'a.ts': 2,
-      'b.ts': 3,
-      'c.ts': 1,
-    });
-  });
-});
diff --git a/tsconfig.app.json b/tsconfig.app.json
index a8c19fe1..8886e903 100644
--- a/tsconfig.app.json
+++ b/tsconfig.app.json
@@ -4,10 +4,7 @@
   "extends": "./tsconfig.json",
   "compilerOptions": {
     "outDir": "./out-tsc/app",
-    "types": [],
-    // Every index read checked (#345). Not yet in tsconfig.json: the workspace
-    // libraries have findings left, held at a count by scripts/check-indexed-access.mjs.
-    "noUncheckedIndexedAccess": true
+    "types": []
   },
   "files": ["src/main.ts"],
   "include": ["src/**/*.d.ts"]
diff --git a/tsconfig.json b/tsconfig.json
index 86ece533..e0d7d180 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -24,6 +24,7 @@
     "esModuleInterop": true,
     "strict": true,
     "noImplicitOverride": true,
+    "noUncheckedIndexedAccess": true,
     "noPropertyAccessFromIndexSignature": true,
     "allowJs": true,
     "noImplicitReturns": true,
@@ -52,16 +53,12 @@
   // the codebase before being switched on. strictTemplates cost 83 fixes and
   // was worth it; typeCheckHostBindings, strictStandalone and the checks below
   // all cost nothing. exactOptionalPropertyTypes (72) is not on -- worth
-  // revisiting, but not free. noUncheckedIndexedAccess is on for the app and the
-  // embeddable diagram, in their own tsconfig.app.json (#345), and held at a
-  // count for the workspace libraries by scripts/check-indexed-access.mjs until
-  // it can go here. It was first trialled and set aside:
-  // of its 185 findings, roughly 44% are places the code already checks .length
-  // or iterates a bounded loop and TypeScript simply cannot connect the check to
-  // the access, where the only "fix" is a non-null assertion that documents
-  // nothing. The remainder did contain two real bugs, both since fixed (see
-  // 0178da7). Worth revisiting as its own piece of work, but adopting it in one
-  // go would trade 185 edits, most of them assertions, for that handful.
+  // revisiting, but not free. noUncheckedIndexedAccess is on (#345): an index
+  // out of range or a missing key is undefined, and the code is made to say so.
+  // It took 346 findings across the app and the libraries, handled with guards
+  // and destructuring rather than non-null assertions, and turned up real bugs
+  // among them (an icon search that threw on no results, names and dates that
+  // read "undefined"). A first trial had set it aside as mostly assertions.
   // strictStandalone is deliberately absent: reactome-table is still an
   // NgModule library with declared, non-standalone components, and it is
   // published, so converting it is not a config change.

From 7ba74934eee1bce682d849f6f17d2ec3bfdedf4b Mon Sep 17 00:00:00 2001
From: Adam Wright <adam.j.wright82@gmail.com>
Date: Mon, 12 Oct 2026 08:16:25 +0000
Subject: [PATCH 2/2] Keep the table usable after deleting the selected row;
 missing values stay null

From review:
- Deleting the row (or column) the selection was in left selectedCoords
  pointing at it. Cells.select read that row to un-mark it and threw,
  which ended the store's state stream and left the GSA form's table
  unusable -- reachable with the delete-row button. Already on main. A cell
  that is gone has nothing to un-mark now; the session spec gains the step
  (fails without the fix; earlier snapshots unchanged).
- A GSA annotation value missing from a short values list was turned into
  "" by this PR; it stays undefined (sent as null), as it always was.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../src/lib/state/dataset/dataset.effect.ts   |  4 +-
 .../table.store.session.spec.ts.snap          | 76 +++++++++++++++++++
 .../src/lib/state/table.store.session.spec.ts | 12 +++
 .../src/lib/state/table.store.ts              |  5 +-
 4 files changed, 94 insertions(+), 3 deletions(-)

diff --git a/projects/reactome-gsa-form/src/lib/state/dataset/dataset.effect.ts b/projects/reactome-gsa-form/src/lib/state/dataset/dataset.effect.ts
index 9377e617..7b489f4f 100644
--- a/projects/reactome-gsa-form/src/lib/state/dataset/dataset.effect.ts
+++ b/projects/reactome-gsa-form/src/lib/state/dataset/dataset.effect.ts
@@ -211,8 +211,8 @@ export class DatasetEffects {
               ['', ...summary.sample_metadata.map((col) => col.name)],
               ...summary.sample_ids.map((sampleId, i) => [
                 sampleId,
-                // A missing value reads as an empty cell, as the table treats one.
-                ...summary.sample_metadata!.map((column) => column.values[i] ?? ''),
+                // A missing value stays missing (sent as null), as it always was.
+                ...summary.sample_metadata!.map((column) => column.values[i] as string),
               ]),
             ];
         return datasetActions.setAnnotations({ annotations: table, id });
diff --git a/projects/reactome-table/src/lib/state/__snapshots__/table.store.session.spec.ts.snap b/projects/reactome-table/src/lib/state/__snapshots__/table.store.session.spec.ts.snap
index c318dcaf..80d984c5 100644
--- a/projects/reactome-table/src/lib/state/__snapshots__/table.store.session.spec.ts.snap
+++ b/projects/reactome-table/src/lib/state/__snapshots__/table.store.session.spec.ts.snap
@@ -116,6 +116,55 @@ exports[`TableStore through an editing session > clears back to the template 1`]
 }
 `;
 
+exports[`TableStore through an editing session > deletes the last row while a cell in it is selected 1`] = `
+{
+  "cleanData": [
+    [
+      "",
+    ],
+  ],
+  "colNames": [
+    "A",
+    "B",
+    "C",
+  ],
+  "columnByIndex": [
+    "A",
+    "",
+    "",
+    "",
+  ],
+  "columnByName": [
+    "",
+    "",
+    "",
+  ],
+  "hasData": false,
+  "range": [
+    [
+      "",
+    ],
+  ],
+  "rowByIndex": [
+    "1",
+    "",
+    "",
+    "",
+  ],
+  "rowByName": [
+    "",
+    "",
+    "",
+  ],
+  "rowNames": [
+    "1",
+    "2",
+    "3",
+  ],
+  "value": "",
+}
+`;
+
 exports[`TableStore through an editing session > generates a template 1`] = `
 {
   "cleanData": [
@@ -1172,5 +1221,32 @@ exports[`TableStore through an editing session > went through every step as reco
     },
     "step": "deselect",
   },
+  {
+    "state": {
+      "cells": [
+        "· | A | B | C",
+        "1 | · | · | ·",
+        "2 | · | · | ·",
+        "3 | · | · | ·",
+      ],
+      "hasFocus": false,
+      "maxCols": [
+        "@0,0",
+        "A@1,0",
+        "B@2,0",
+        "C@3,0",
+      ],
+      "selected": 0,
+      "start": {
+        "x": 0,
+        "y": 0,
+      },
+      "stop": {
+        "x": 0,
+        "y": 0,
+      },
+    },
+    "step": "deleteRow of the selected last row",
+  },
 ]
 `;
diff --git a/projects/reactome-table/src/lib/state/table.store.session.spec.ts b/projects/reactome-table/src/lib/state/table.store.session.spec.ts
index 593ecbf1..1dc1f859 100644
--- a/projects/reactome-table/src/lib/state/table.store.session.spec.ts
+++ b/projects/reactome-table/src/lib/state/table.store.session.spec.ts
@@ -181,6 +181,18 @@ describe('TableStore through an editing session', () => {
     expect(await selectors(store)).toMatchSnapshot();
   });
 
+  // Deleting the row the selection is in left the selection pointing at a row
+  // that was gone; reading it threw, which ended the store's state stream and
+  // left the table unusable.
+  it('deletes the last row while a cell in it is selected', async () => {
+    store.focusLast();
+    const last = store.state().dataset.length - 1;
+    store.deleteRow({ y: last });
+    record('deleteRow of the selected last row');
+    expect(store.state().dataset.length).toBe(last);
+    expect(await selectors(store)).toMatchSnapshot();
+  });
+
   it('went through every step as recorded', () => {
     expect(steps).toMatchSnapshot();
   });
diff --git a/projects/reactome-table/src/lib/state/table.store.ts b/projects/reactome-table/src/lib/state/table.store.ts
index 71265339..be44a06a 100644
--- a/projects/reactome-table/src/lib/state/table.store.ts
+++ b/projects/reactome-table/src/lib/state/table.store.ts
@@ -690,7 +690,10 @@ export namespace Ranges {
 namespace Cells {
   export function select(state: TableState): TableState {
     state.selectedCoords.forEach((coords) => {
-      const cell = rowAt(state.dataset, coords.y)[coords.x];
+      // The previous selection, to un-mark: a cell of a row or column deleted
+      // since is gone, with nothing to un-mark. Reading its row used to throw,
+      // ending the store's state stream and leaving the table unusable.
+      const cell = state.dataset[coords.y]?.[coords.x];
       if (cell) {
         cell.selected = false;
         cell.visibility = 'visible';