From 5843b742547973fe6cd2ab3f4297d5323a03c302 Mon Sep 17 00:00:00 2001
From: Elena Erokhina <erohinaelena1@yandex.ru>
Date: Tue, 25 Aug 2026 16:14:26 +0200
Subject: [PATCH 01/13] MILAB-6720: announce the file scan and block Run until
 it finishes

Picking a file left the panel silent while every column of it was profiled, and
the profile outputs are retentive, so the dropdowns kept answering with the
previous file's headers as though nothing was happening. A mapping that had
passed against that previous file also still satisfied bareSetValid, so Run
stayed live over a file nobody had looked at and over headers it might not have.

Prerun now states which file the profile came from, and the model pairs the two
under retentive: getIsReadyOrError marks the read unstable, so the reported id
stays the old file's until the new scan lands. The panel compares it with the
loaded file, announces the wait, and withholds the mapping until the columns on
offer are really this file's. Keyed to the file rather than to "prerun is busy"
because prerun also re-runs on every mapping edit to re-check the identity
column for collisions.

Picking a different file drops the parts of the mapping that name columns,
keeping the receptor declaration and the numbering scheme. That is what disables
Run, and it is done on the gesture: args is a pure function of data and cannot
consult prerun, and mirroring prerun's verdict back into data is the pattern
this block is shedding. Re-picking the same file is not a swap.

The import itself now shows the block's loader, which it never did, scoped to
the main run so it cannot cover the settings panel during prerun.
---
 ...announce-the-file-scan-and-gate-the-run.md | 33 +++++++++++++
 model/src/index.ts                            | 24 +++++++++
 test/src/wf.test.ts                           |  6 +++
 ui/src/app.ts                                 |  5 +-
 ui/src/pages/MainPage.vue                     | 49 +++++++++++++++++--
 workflow/src/prerun.tpl.tengo                 |  5 +-
 6 files changed, 117 insertions(+), 5 deletions(-)
 create mode 100644 .changeset/announce-the-file-scan-and-gate-the-run.md

diff --git a/.changeset/announce-the-file-scan-and-gate-the-run.md b/.changeset/announce-the-file-scan-and-gate-the-run.md
new file mode 100644
index 0000000..9209a04
--- /dev/null
+++ b/.changeset/announce-the-file-scan-and-gate-the-run.md
@@ -0,0 +1,33 @@
+---
+'@platforma-open/milaboratories.import-vdj.workflow': patch
+'@platforma-open/milaboratories.import-vdj.model': patch
+'@platforma-open/milaboratories.import-vdj.ui': patch
+'@platforma-open/milaboratories.import-vdj': patch
+---
+
+Say when a loaded file is being read, and stop the run until it has been
+
+Picking a file left the panel silent. Every column of the file is profiled before anything can be
+mapped — a whole-file pass, minutes on remote storage — and nothing said so: the profile outputs
+are retentive, so the dropdowns kept answering with the *previous* file's headers as though
+nothing had happened. Worse, a mapping that had passed every check against that previous file
+still satisfied the validity rule, so Run stayed live over a file nobody had looked at yet, and
+over headers it might not even contain.
+
+Three changes:
+
+- Prerun states which file the profile was taken from (`profiledSampleId`), and the model pairs
+  the two under `retentive` — while the new scan runs, the reported id stays the old file's. The
+  panel compares it with the loaded file and announces the wait, withholding the mapping until
+  the columns on offer are really this file's. Keyed to the file rather than to "prerun is busy"
+  on purpose: prerun also re-runs on every mapping edit, to re-check the identity column for
+  collisions, and a message that appeared on each dropdown pick would train the scientist to
+  ignore it.
+- Picking a different file drops the parts of the mapping that name columns, keeping the receptor
+  declaration and the numbering scheme, which are statements about the data rather than about one
+  file. That is what disables Run. Done on the gesture rather than by reconciling against the new
+  profile: `args` is a pure function of the block's data and cannot consult prerun, and mirroring
+  prerun's verdict back into that data is the pattern this block is trying to shed. Re-picking the
+  same file is not a swap and keeps the mapping.
+- The import itself now shows the block's loader, which it never did. Scoped to the main run: the
+  loader covers the whole block, and prerun runs while the settings panel is being edited.
diff --git a/model/src/index.ts b/model/src/index.ts
index 1d1479a..7295cd4 100644
--- a/model/src/index.ts
+++ b/model/src/index.ts
@@ -264,6 +264,30 @@ export const platforma = BlockModelV3.create(blockDataModel)
     }
   })
 
+  /**
+   * Which file the profile the UI currently sees was taken from, so a mismatch with
+   * `data.fileSource.sampleId` means "the panel is showing the last file's columns".
+   *
+   * Keyed to the file, not to whether prerun is busy: `prerunArgs` carries `bareSet`, so prerun
+   * re-runs on every mapping edit to re-check the identity column for collisions.
+   */
+  .retentiveOutput("profiledSampleId", (ctx) => {
+    const profile = ctx.prerun?.resolve({ field: "columnProfile", allowPermanentAbsence: true });
+    if (profile === undefined) return undefined;
+    // Marks the read unstable (pl-tree/src/accessors.ts:347), so `retentive` keeps reporting the
+    // previous file's id until the new profile lands — the id and the profile can never disagree.
+    if (!profile.getIsReadyOrError()) return undefined;
+    return ctx.prerun
+      ?.resolve({ field: "profiledSampleId", allowPermanentAbsence: true })
+      ?.getDataAsJsonOrUndefined<string>();
+  })
+
+  /**
+   * Drives the block's loader (`ui/src/app.ts`). Excludes prerun: the loader covers the whole
+   * block, and prerun re-runs while the settings panel is being edited.
+   */
+  .output("isRunning", (ctx) => ctx.outputs?.getIsReadyOrError() === false)
+
   /** Headers of the dataset selected from the pool. Absent on the file door. */
   .retentiveOutput("datasetColumns", (ctx) => {
     const headers = ctx.prerun
diff --git a/test/src/wf.test.ts b/test/src/wf.test.ts
index 61fa2b2..da47757 100644
--- a/test/src/wf.test.ts
+++ b/test/src/wf.test.ts
@@ -511,6 +511,12 @@ blockTest(
       "Affinity (nM)": "Double",
     });
 
+    // The profile names the file it came from. The panel reads this to tell this file's columns
+    // from the previous file's, still retained while the new one is scanned.
+    expect((state.outputs?.profiledSampleId as { value?: string } | undefined)?.value).toBe(
+      "SDIRECT000000000000000001",
+    );
+
     // Indistinguishable from the pool door: same axes, same key, same columns — abundance
     // alone on [sampleId, variantKey], every property of the record on the record axis.
     for (const c of columns) {
diff --git a/ui/src/app.ts b/ui/src/app.ts
index 064ee1d..d3004f4 100644
--- a/ui/src/app.ts
+++ b/ui/src/app.ts
@@ -3,8 +3,11 @@ import { defineAppV3 } from "@platforma-sdk/ui-vue";
 import MainPage from "./pages/MainPage.vue";
 import { watch } from "vue";
 
-export const sdkPlugin = defineAppV3(platforma, () => {
+export const sdkPlugin = defineAppV3(platforma, (app) => {
   return {
+    // Main run only: this loader covers the whole block, and prerun re-runs while the settings
+    // panel is being edited. The file scan is announced inside the panel instead.
+    progress: () => app.model.outputs.isRunning,
     routes: {
       "/": () => MainPage,
     },
diff --git a/ui/src/pages/MainPage.vue b/ui/src/pages/MainPage.vue
index 401fd9c..378edec 100644
--- a/ui/src/pages/MainPage.vue
+++ b/ui/src/pages/MainPage.vue
@@ -239,7 +239,15 @@ function setBareScheme(value: string | undefined) {
   a.bareSet = { ...a.bareSet, scheme: value as BareSetArgs["scheme"] };
 }
 
-const isBareSet = computed(() => app.model.data.bareSet !== undefined);
+/**
+ * A column has been assigned. Not `bareSet !== undefined`: picking a new file keeps the receptor
+ * declaration and the scheme (see forgetMappedColumns), so the object outlives the mapping.
+ */
+const isBareSet = computed(() => {
+  const bare = app.model.data.bareSet;
+  if (bare === undefined) return false;
+  return !!bare.identity || Object.values(bare.sequences ?? {}).some(Boolean);
+});
 
 /** Identity values the file repeats on rows that are not identical. The run cannot start
  *  while any exist: the record key is the identity's hash, so a repeat would merge two
@@ -407,6 +415,30 @@ function setSource(value: string | undefined) {
 /** The file door is showing exactly when a file is loaded. No stored flag decides it. */
 const loadFromFile = computed(() => app.model.data.fileSource !== undefined);
 
+/**
+ * The loaded file is still being profiled — the columns on offer are the previous file's, since
+ * the profile outputs are retentive. True between picking a file and its scan finishing.
+ */
+const fileScanning = computed(() => {
+  const file = app.model.data.fileSource;
+  if (file === undefined) return false;
+  return app.model.outputs.profiledSampleId !== file.sampleId;
+});
+
+/**
+ * The mapping with everything that names a column dropped. The receptor declaration and the
+ * numbering scheme describe the biology and outlive any one file; the column names do not.
+ */
+function forgetMappedColumns(bare: BareSetArgs | undefined): BareSetArgs | undefined {
+  if (bare === undefined) return undefined;
+  return {
+    identity: "",
+    chainSelection: bare.chainSelection,
+    sequences: {},
+    scheme: bare.scheme,
+  };
+}
+
 async function setFile(handle: ImportFileHandle | undefined) {
   fileSourceError.value = "";
   const a = app.model.data;
@@ -415,6 +447,7 @@ async function setFile(handle: ImportFileHandle | undefined) {
     return;
   }
 
+  const previous = a.fileSource;
   const name = getFileNameFromHandle(handle);
   // A workbook is identified by its name — there is no first line to read, and the workflow
   // converts it to csv before anything else looks at it. For text files the delimiter is
@@ -435,6 +468,12 @@ async function setFile(handle: ImportFileHandle | undefined) {
     extension,
   };
   a.datasetRef = undefined;
+
+  // This is what disables Run: a mapping that passed against the last file still satisfies
+  // `bareSetValid`, so otherwise the block stays runnable over a file nothing has read yet.
+  // Cleared on the gesture because `args` sees only `data` and cannot consult prerun.
+  // Re-picking the same file is not a swap — the dialog is also how a file gets re-read.
+  if (previous?.handle !== handle) a.bareSet = forgetMappedColumns(a.bareSet);
 }
 
 function setReceptors(selected: string[]) {
@@ -686,7 +725,11 @@ watch(
           {{ fileSourceError }}
         </PlAlert>
 
-        <template v-if="headerOptions.length > 0">
+        <PlAlert v-if="fileScanning" type="info" :style="{ width: '100%' }">
+          Checking the file's columns. This can take a moment, please wait...
+        </PlAlert>
+
+        <template v-if="!fileScanning && headerOptions.length > 0">
           <PlSectionSeparator>Columns to import</PlSectionSeparator>
           <PlAlert v-if="identityCollisionMessage" type="warn" :style="{ width: '100%' }">
             <template #title>Id column is not unique</template>
@@ -735,7 +778,7 @@ watch(
         <!-- Not a column mapping: it chooses how the mapped sequences are numbered, and the
              region boundaries every downstream block reads follow from it. Kept apart from the
              mapping so it does not read as one more column to assign. -->
-        <template v-if="isBareSet">
+        <template v-if="isBareSet && !fileScanning">
           <PlSectionSeparator>Region annotation</PlSectionSeparator>
           <div class="field-col">
             <PlDropdown
diff --git a/workflow/src/prerun.tpl.tengo b/workflow/src/prerun.tpl.tengo
index 11b9cbf..7c8d074 100644
--- a/workflow/src/prerun.tpl.tengo
+++ b/workflow/src/prerun.tpl.tengo
@@ -46,7 +46,10 @@ wf.body(func(args) {
 		outputs := {
 			// getImportProgress on this is what starts the upload.
 			fileImports: imported.handle,
-			columnProfile: profile.output("profile")
+			columnProfile: profile.output("profile"),
+			// Which file the profile above describes. Stated here because nothing exposes the args
+			// a staging context was built with, so the model cannot work it out.
+			profiledSampleId: smart.createJsonResource(args.fileSource.sampleId)
 		}
 
 		if args.bareSet != undefined {

From cd7b8c4b6bf3387c54b4f57f603f5fea6c590e20 Mon Sep 17 00:00:00 2001
From: Elena Erokhina <erohinaelena1@yandex.ru>
Date: Tue, 25 Aug 2026 16:41:42 +0200
Subject: [PATCH 02/13] MILAB-6720: show the headings on the warning alerts

PlAlert declares only a default slot and takes its heading from the `label`
prop, so the four `<template #title>` headings in the panel had never rendered.
The bodies showed with nothing above them.
---
 .../alert-headings-were-never-rendered.md     | 12 +++++++
 ui/src/pages/MainPage.vue                     | 32 ++++++++++++++-----
 2 files changed, 36 insertions(+), 8 deletions(-)
 create mode 100644 .changeset/alert-headings-were-never-rendered.md

diff --git a/.changeset/alert-headings-were-never-rendered.md b/.changeset/alert-headings-were-never-rendered.md
new file mode 100644
index 0000000..cd38c5e
--- /dev/null
+++ b/.changeset/alert-headings-were-never-rendered.md
@@ -0,0 +1,12 @@
+---
+'@platforma-open/milaboratories.import-vdj.ui': patch
+'@platforma-open/milaboratories.import-vdj': patch
+---
+
+Show the headings on the warning alerts
+
+Four alerts passed their heading as `<template #title>`, but `PlAlert` declares only a default
+slot — it takes a heading through the `label` prop. The headings had therefore never rendered:
+"Id column is not unique", "Two headers would become one column", "Invalid <format> dataset" and
+"No clonotypes imported" all showed their body text with nothing above it, so a warning about a
+non-unique id column read as an unlabelled wall of values.
diff --git a/ui/src/pages/MainPage.vue b/ui/src/pages/MainPage.vue
index 378edec..163830f 100644
--- a/ui/src/pages/MainPage.vue
+++ b/ui/src/pages/MainPage.vue
@@ -731,8 +731,12 @@ watch(
 
         <template v-if="!fileScanning && headerOptions.length > 0">
           <PlSectionSeparator>Columns to import</PlSectionSeparator>
-          <PlAlert v-if="identityCollisionMessage" type="warn" :style="{ width: '100%' }">
-            <template #title>Id column is not unique</template>
+          <PlAlert
+            v-if="identityCollisionMessage"
+            type="warn"
+            label="Id column is not unique"
+            :style="{ width: '100%' }"
+          >
             {{ identityCollisionMessage }}
           </PlAlert>
           <div class="field-col">
@@ -769,8 +773,12 @@ watch(
               />
             </template>
           </div>
-          <PlAlert v-if="propertyCollisionMessage" type="warn" :style="{ width: '100%' }">
-            <template #title>Two headers would become one column</template>
+          <PlAlert
+            v-if="propertyCollisionMessage"
+            type="warn"
+            label="Two headers would become one column"
+            :style="{ width: '100%' }"
+          >
             {{ propertyCollisionMessage }}
           </PlAlert>
         </template>
@@ -800,8 +808,12 @@ watch(
           required
         />
 
-        <PlAlert v-if="validationMessage" type="warn" :style="{ width: '100%' }">
-          <template #title>Invalid {{ formatLabel(validationResult?.format) }} dataset</template>
+        <PlAlert
+          v-if="validationMessage"
+          type="warn"
+          :label="`Invalid ${formatLabel(validationResult?.format)} dataset`"
+          :style="{ width: '100%' }"
+        >
           {{ validationMessage }}
         </PlAlert>
 
@@ -964,8 +976,12 @@ watch(
       </template>
     </PlSlideModal>
 
-    <PlAlert v-if="emptySamplesMessage" type="warn" :style="{ width: '100%' }">
-      <template #title>No clonotypes imported</template>
+    <PlAlert
+      v-if="emptySamplesMessage"
+      type="warn"
+      label="No clonotypes imported"
+      :style="{ width: '100%' }"
+    >
       {{ emptySamplesMessage }}
     </PlAlert>
 

From 5c82e13c11b3c7bbe0b1acce396ada427a7d268a Mon Sep 17 00:00:00 2001
From: Elena Erokhina <erohinaelena1@yandex.ru>
Date: Tue, 25 Aug 2026 16:53:15 +0200
Subject: [PATCH 03/13] MILAB-6720: tie the id-collision warning to the column
 it is about

The panel quoted bareSet.identity, which updates on the pick, against
collisions produced for the previous column, so changing an offending column
flashed the old verdict under the new column's name. Prerun now states which
column it checked and the model reports both as one value, so the panel can
tell a current verdict from a stale one.

Also cuts the listed values from ten to three: the list buried the sentence
saying what to do about them.
---
 .../collision-warning-names-its-column.md     | 17 ++++++++++
 model/src/index.ts                            | 18 ++++++++++-
 test/src/wf.test.ts                           | 13 ++++++--
 ui/src/pages/MainPage.vue                     | 31 +++++++++++++------
 workflow/src/prerun.tpl.tengo                 |  6 +++-
 5 files changed, 71 insertions(+), 14 deletions(-)
 create mode 100644 .changeset/collision-warning-names-its-column.md

diff --git a/.changeset/collision-warning-names-its-column.md b/.changeset/collision-warning-names-its-column.md
new file mode 100644
index 0000000..b373d44
--- /dev/null
+++ b/.changeset/collision-warning-names-its-column.md
@@ -0,0 +1,17 @@
+---
+'@platforma-open/milaboratories.import-vdj.workflow': patch
+'@platforma-open/milaboratories.import-vdj.model': patch
+'@platforma-open/milaboratories.import-vdj.ui': patch
+'@platforma-open/milaboratories.import-vdj': patch
+---
+
+Tie the id-collision warning to the column it is about, and shorten it
+
+Changing an offending id column flashed the old verdict under the new column's name: the panel
+quoted `bareSet.identity`, which updates on the pick, against collisions the previous column's
+prerun had produced. Prerun now states which column it checked, the model reports the two as one
+value so they cannot come from different runs, and the panel shows the warning only while it is
+about the column now selected — so picking a clean column clears it instead of re-accusing it.
+
+The message also listed up to ten repeated values, which buried the sentence saying what to do.
+It now shows three and a count.
diff --git a/model/src/index.ts b/model/src/index.ts
index 7295cd4..7c3c87c 100644
--- a/model/src/index.ts
+++ b/model/src/index.ts
@@ -177,7 +177,23 @@ export const platforma = BlockModelV3.create(blockDataModel)
     { isActive: true },
   )
 
+  /**
+   * Identity values the file repeats on rows that are not identical, and the column they were
+   * found in.
+   *
+   * Reported as one value because the two must never be read from different runs: the panel used
+   * to quote `data.bareSet.identity`, which updates the instant a new column is picked, against
+   * collisions the previous column's run had produced — so changing an offending column flashed
+   * the old verdict under the new column's name.
+   *
+   * Not `retentive`: this reports a defect, so a briefly absent verdict beats a stale one.
+   */
   .output("identityCollisions", (ctx) => {
+    const identity = ctx.prerun
+      ?.resolve({ field: "collisionsFor", allowPermanentAbsence: true })
+      ?.getDataAsJsonOrUndefined<string>();
+    if (identity === undefined) return undefined;
+
     const raw = ctx.prerun
       ?.resolve({ field: "identityCollisions", allowPermanentAbsence: true })
       ?.getDataAsString();
@@ -188,7 +204,7 @@ export const platforma = BlockModelV3.create(blockDataModel)
       .split("\n")
       .map((l) => l.trim())
       .filter((l) => l.length > 0);
-    return lines.slice(1);
+    return { identity, values: lines.slice(1) };
   })
 
   .retentiveOutput("datasetOptions", (ctx) => {
diff --git a/test/src/wf.test.ts b/test/src/wf.test.ts
index da47757..9969101 100644
--- a/test/src/wf.test.ts
+++ b/test/src/wf.test.ts
@@ -317,10 +317,17 @@ blockTest(
     };
 
     const wrapped = state.outputs?.identityCollisions as
-      | { value?: string[] }
-      | string[]
+      | { value?: { identity: string; values: string[] } }
+      | { identity: string; values: string[] }
       | undefined;
-    const collisions = (Array.isArray(wrapped) ? wrapped : (wrapped?.value ?? [])) as string[];
+    const found = (wrapped && "identity" in wrapped ? wrapped : wrapped?.value) as
+      | { identity: string; values: string[] }
+      | undefined;
+
+    // The verdict names the column it is about. Without this the panel could quote the freshly
+    // picked column against the previous one's collisions, which is what it used to do.
+    expect(found?.identity).toBe("mAb ID");
+    const collisions = found?.values ?? [];
 
     // The differing pair is reported, so the scientist is told which value to fix.
     expect(collisions).toContain("AB-001");
diff --git a/ui/src/pages/MainPage.vue b/ui/src/pages/MainPage.vue
index 163830f..4fe43ce 100644
--- a/ui/src/pages/MainPage.vue
+++ b/ui/src/pages/MainPage.vue
@@ -249,12 +249,20 @@ const isBareSet = computed(() => {
   return !!bare.identity || Object.values(bare.sequences ?? {}).some(Boolean);
 });
 
-/** Identity values the file repeats on rows that are not identical. The run cannot start
- *  while any exist: the record key is the identity's hash, so a repeat would merge two
- *  different records into one. */
-const identityCollisions = computed<string[]>(
-  () => (app.model.outputs.identityCollisions as string[] | undefined) ?? [],
-);
+/**
+ * Identity values the file repeats on rows that are not identical — but only once they are known
+ * to be about the column now selected. The record key is the identity's hash, so a repeat merges
+ * two different records into one.
+ *
+ * The output carries the column it was computed for; anything else is a verdict about a column
+ * the scientist has already moved on from.
+ */
+const identityCollisions = computed<string[]>(() => {
+  const found = app.model.outputs.identityCollisions;
+  if (found === undefined) return [];
+  if (found.identity !== app.model.data.bareSet?.identity) return [];
+  return found.values;
+});
 
 /** Headers not taken by a sequence or the identity — offered as record properties rather than
  *  dropped, which is what the block used to do with them. */
@@ -295,12 +303,17 @@ const propertyCollisionMessage = computed(() => {
   return `These headers would become the same column: ${pairs}. Rename one in the file — importing both is not possible, and dropping one silently would lose a column you asked for.`;
 });
 
+// Enough values to recognise the problem in the file, not enough to bury the sentence that says
+// what to do about it.
+const COLLISIONS_SHOWN = 3;
+
 const identityCollisionMessage = computed(() => {
   const values = identityCollisions.value;
   if (values.length === 0) return "";
-  const shown = values.slice(0, 10).join(", ");
-  const rest = values.length > 10 ? ` and ${values.length - 10} more` : "";
-  return `These values of "${app.model.data.bareSet?.identity}" appear on rows that are not identical: ${shown}${rest}. Each record needs its own identifier — two rows sharing one would become a single record. Fix them in the file, or choose a different identity column.`;
+  const shown = values.slice(0, COLLISIONS_SHOWN).join(", ");
+  const rest =
+    values.length > COLLISIONS_SHOWN ? ` and ${values.length - COLLISIONS_SHOWN} more` : "";
+  return `Repeated on rows that are not identical: ${shown}${rest}. Two rows sharing an id become one record — pick a different column, or fix the file.`;
 });
 
 const countTypeOptions = [
diff --git a/workflow/src/prerun.tpl.tengo b/workflow/src/prerun.tpl.tengo
index 7c8d074..0447845 100644
--- a/workflow/src/prerun.tpl.tengo
+++ b/workflow/src/prerun.tpl.tengo
@@ -63,6 +63,9 @@ wf.body(func(args) {
 			}
 
 			if bare.identity != "" && len(mappedChains) > 0 {
+				// Which column the collisions below are about, so the panel cannot pair them with a
+				// different one the scientist has since picked.
+				outputs.collisionsFor = smart.createJsonResource(bare.identity)
 				outputs.identityCollisions = render.create(collisionsTpl, {
 					dataset: {
 						spec: {
@@ -117,7 +120,8 @@ wf.body(func(args) {
 
 			return {
 				outputs: {
-					identityCollisions: collisions
+					identityCollisions: collisions,
+					collisionsFor: smart.createJsonResource(bare.identity)
 				},
 				exports: {}
 			}

From c3bc65e4a3794abe3b6056cb650d06c48eb3f6da Mon Sep 17 00:00:00 2001
From: Elena Erokhina <erohinaelena1@yandex.ru>
Date: Tue, 25 Aug 2026 17:17:23 +0200
Subject: [PATCH 04/13] MILAB-6720: refuse to run a bare set whose id column
 repeats

The record key is the identity's hash, so a value repeated on rows that are not
identical merges two records into one. Prerun found these and the panel warned,
but Run stayed live and the API imported the merged set without complaint.

Run is now refused while the verdict for the selected column is outstanding and
when it says the column repeats, and the panel says which. The platform enforces
it too: invalid args leave no production to render.

The args projection sees only data, and no gesture can capture this fact -- the
scientist picks a column and only then does the check discover whether it is
sound -- so the UI mirrors the verdict in. The rules that keep that safe are
stated on BlockData.prerunChecks for the checks still to come.
---
 .changeset/refuse-an-unchecked-id-column.md | 25 ++++++++++++
 model/src/index.ts                          | 21 ++++++++++
 model/src/types.ts                          | 25 ++++++++++++
 test/src/wf.test.ts                         | 32 ++++++++++-----
 ui/src/app.ts                               | 44 ++++++++++++++++++++-
 ui/src/pages/MainPage.vue                   | 17 +++++++-
 6 files changed, 153 insertions(+), 11 deletions(-)
 create mode 100644 .changeset/refuse-an-unchecked-id-column.md

diff --git a/.changeset/refuse-an-unchecked-id-column.md b/.changeset/refuse-an-unchecked-id-column.md
new file mode 100644
index 0000000..a5024b0
--- /dev/null
+++ b/.changeset/refuse-an-unchecked-id-column.md
@@ -0,0 +1,25 @@
+---
+'@platforma-open/milaboratories.import-vdj.model': patch
+'@platforma-open/milaboratories.import-vdj.ui': patch
+'@platforma-open/milaboratories.import-vdj': patch
+---
+
+Refuse to run a bare set whose id column repeats
+
+The record key is the identity column's hash, so a value that repeats on rows that are not
+identical merges two different records into one — silently, and the block would import it anyway.
+Prerun has always found these and the panel has always warned about them, but the warning was only
+a warning: Run stayed live, and a run driven through the API imported the merged set without
+complaint.
+
+Run is now refused both while the verdict for the selected column is still outstanding and when it
+says the column repeats, and the panel says which of the two it is waiting on. The platform
+enforces it as well as the interface — invalid args leave nothing to render a production from.
+
+Getting there needs prerun's verdict inside the args projection, which sees only the block's own
+data, so the UI mirrors it in. That is a hairpin, and deliberately so: unlike a column mapping
+there is no gesture at which the fact could be captured, because the scientist picks a column and
+only then does the check discover whether it is sound. The two rules that keep it safe — a verdict
+carries what it is about, and is dropped when the source changes — are stated on
+`BlockData.prerunChecks`, and further prerun checks should follow them. It can all go once
+`argsValid` can read prerun directly.
diff --git a/model/src/index.ts b/model/src/index.ts
index 7c3c87c..eee0b13 100644
--- a/model/src/index.ts
+++ b/model/src/index.ts
@@ -38,6 +38,25 @@ function withoutDatasetDoorMapping(args: BlockArgs): BlockArgs {
   };
 }
 
+/**
+ * Refuse a bare set whose id column prerun has not cleared.
+ *
+ * The check itself cannot live here — it reads the whole file — so this reads the verdict the UI
+ * mirrored into `data.prerunChecks`, and refuses both a verdict that says the column repeats and
+ * the absence of one for the column currently selected. Refusing the absence is the point: the
+ * record key is the identity's hash, so starting a run before the answer is in is exactly how two
+ * different records silently become one.
+ */
+function requireCheckedIdentity(data: BlockData): void {
+  const identity = data.bareSet?.identity;
+  if (identity === undefined || identity === "") return; // bareSetValid has already refused
+  const checks = data.prerunChecks;
+  if (checks?.identity !== identity) throw new Error("Checking the id column for repeats");
+  if (checks.identityCollides) {
+    throw new Error(`"${identity}" repeats on rows that are not identical`);
+  }
+}
+
 /**
  * The workflow's view of the block, and the only place validation lives.
  *
@@ -72,6 +91,7 @@ function projectArgs(data: BlockData): BlockArgs {
   // mapping unfurled under a format nobody had chosen.
   if (fileSource !== undefined) {
     if (!bareSetValid(data.bareSet)) throw new Error("Finish mapping the file's columns");
+    requireCheckedIdentity(data);
     return withoutDatasetDoorMapping(args);
   }
 
@@ -85,6 +105,7 @@ function projectArgs(data: BlockData): BlockArgs {
     // identity column, because the key is the identity's hash and the label is its value.
     if (data.bareSet !== undefined) {
       if (!bareSetValid(data.bareSet)) throw new Error("Finish mapping the record's columns");
+      requireCheckedIdentity(data);
       return withoutDatasetDoorMapping(args);
     }
 
diff --git a/model/src/types.ts b/model/src/types.ts
index 6ef71ee..e561773 100644
--- a/model/src/types.ts
+++ b/model/src/types.ts
@@ -222,6 +222,31 @@ export type BlockData = {
   // --- bare set. Its presence is what selects the bare path in the workflow.
   bareSet?: BareSetMapping;
 
+  /**
+   * Verdicts prerun reached, mirrored here so `args` can refuse a run on them.
+   *
+   * `args` is a pure function of this data and cannot read prerun, and unlike the column mapping
+   * there is no gesture at which a verdict could be snapshotted: the scientist picks a column, and
+   * only then does the check discover whether it is sound. So the UI mirrors it in
+   * (`ui/src/app.ts`) — the hairpin the harness warns about, made safe by two rules every entry
+   * here must follow:
+   *
+   * - it carries what it is *about*, so a verdict for something nobody has selected any more is
+   *   ignored rather than applied;
+   * - it is cleared when the source changes, so a verdict cannot survive into a different file.
+   *
+   * Together those make the write idempotent — every client derives the same value from the same
+   * output, so concurrent writes agree instead of racing. Add further checks as sibling fields
+   * following the same two rules. The whole field goes away once args can read prerun directly
+   * (SDK request "Simplify prerun checks").
+   */
+  prerunChecks?: {
+    /** The id column the verdict below was reached for. */
+    identity: string;
+    /** That column repeats on rows that are not identical, so two records would merge into one. */
+    identityCollides: boolean;
+  };
+
   // --- view state. None of this is projected anywhere.
   tableState: PlDataTableStateV2;
   settingsOpen: boolean;
diff --git a/test/src/wf.test.ts b/test/src/wf.test.ts
index 9969101..4a5aa9e 100644
--- a/test/src/wf.test.ts
+++ b/test/src/wf.test.ts
@@ -29,6 +29,7 @@ import { ImportVdjBlockPointer } from "this-block";
  * visibly `tableState`, which the stats table is built from.
  */
 function blockData(fields: Record<string, unknown>): Record<string, unknown> {
+  const bareSet = fields.bareSet as { identity?: string } | undefined;
   return {
     defaultBlockLabel: "",
     customBlockLabel: "",
@@ -40,6 +41,12 @@ function blockData(fields: Record<string, unknown>): Record<string, unknown> {
     mixcrColumnsPresent: false,
     crColumnsPresent: false,
     airrColumnsPresent: false,
+    // `args` refuses a bare set whose id column prerun has not cleared, and the verdict reaches
+    // data through a UI watcher these tests never run. So stand in for it — clean unless the test
+    // passes its own `prerunChecks`, which `...fields` below lets it do.
+    ...(bareSet?.identity !== undefined && bareSet.identity !== ""
+      ? { prerunChecks: { identity: bareSet.identity, identityCollides: false } }
+      : {}),
     ...fields,
   };
 }
@@ -307,15 +314,24 @@ blockTest(
           sequences: { IGHeavy: "VH", IGLight: "VL" },
           scheme: SCHEME,
         },
+        // What the UI mirrors in once prerun answers. Stated here because the mirror is a UI
+        // watcher and these tests drive the block directly.
+        prerunChecks: { identity: "mAb ID", identityCollides: true },
       }),
     });
 
     const state = (await awaitStableState(project.getBlockState(blockId), 300000)) as {
       outputs?: Record<string, unknown>;
-      inputsValid?: boolean;
-      canRun?: boolean;
     };
 
+    // The refusal the block's name promises: a colliding id column makes args invalid, so the
+    // interface offers no Run. Read from the overview, not the block state — the block state
+    // carries outputs, and runnability lives on the overview.
+    const overview = (await project.overview.getValue())!;
+    const blockOverview = overview.blocks.find((b) => b.id === blockId)!;
+    expect(blockOverview.inputsValid).toBe(false);
+    expect(blockOverview.canRun).toBe(false);
+
     const wrapped = state.outputs?.identityCollisions as
       | { value?: { identity: string; values: string[] } }
       | { identity: string; values: string[] }
@@ -334,13 +350,11 @@ blockTest(
     // The identical pair is not: repeating a record verbatim discards nothing.
     expect(collisions).not.toContain("AB-002");
 
-    // GAP, verified here rather than assumed: `argsValid` disables Run in the interface, but
-    // the platform does not enforce it — `project.runBlock` resolves happily on an invalid
-    // block. So "the run does not start" holds for a scientist clicking Run and not for an API
-    // caller, and a colliding set driven through the API would still import and merge records.
-    // Closing that needs a workflow-side refusal, which is data-dependent and therefore a
-    // separate awaiting template.
-    await expect(project.runBlock(blockId)).resolves.toBeUndefined();
+    // Enforced by the platform, not only by the interface: invalid args means no args to render a
+    // production from, so an API caller cannot drive a colliding set through either. This was a
+    // documented gap while the collision verdict sat outside the gate — args stayed valid, and
+    // `runBlock` imported a set that merged records without complaint.
+    await expect(project.runBlock(blockId)).rejects.toThrow(/currentArgs not set/);
   },
 );
 
diff --git a/ui/src/app.ts b/ui/src/app.ts
index d3004f4..4e034f2 100644
--- a/ui/src/app.ts
+++ b/ui/src/app.ts
@@ -1,9 +1,11 @@
 import { platforma } from "@platforma-open/milaboratories.import-vdj.model";
 import { defineAppV3 } from "@platforma-sdk/ui-vue";
 import MainPage from "./pages/MainPage.vue";
-import { watch } from "vue";
+import { watch, watchEffect } from "vue";
 
 export const sdkPlugin = defineAppV3(platforma, (app) => {
+  syncPrerunChecks(app.model);
+
   return {
     // Main run only: this loader covers the whole block, and prerun re-runs while the settings
     // panel is being edited. The file scan is announced inside the panel instead.
@@ -16,6 +18,46 @@ export const sdkPlugin = defineAppV3(platforma, (app) => {
 
 export const useApp = sdkPlugin.useApp;
 
+type AppModel = ReturnType<typeof useApp>["model"];
+
+/**
+ * Carry prerun's verdicts into `data` so the args projection can refuse the run on them.
+ *
+ * This is the hairpin — an output written back into the state a derivation reads — and it is here
+ * because nothing else can be: args sees only `data`, and no user gesture can establish whether a
+ * column the scientist just picked repeats. The contract that keeps it safe is stated on
+ * `BlockData.prerunChecks`; both halves below are that contract.
+ */
+function syncPrerunChecks(model: AppModel) {
+  // Idempotent by construction: every client derives the same verdict from the same output, and
+  // the equality guard means agreeing clients do not write at all.
+  watchEffect(() => {
+    const found = model.outputs.identityCollisions;
+    if (found === undefined) return;
+    const next = { identity: found.identity, identityCollides: found.values.length > 0 };
+    const current = model.data.prerunChecks;
+    if (current?.identity === next.identity && current.identityCollides === next.identityCollides) {
+      return;
+    }
+    model.data.prerunChecks = next;
+  });
+
+  // A verdict cannot outlive the file or dataset it was reached for — the same column name in a
+  // different file is a different column, and one that repeated there may be sound here. Watching
+  // the primitives rather than the refs so a server patch swapping the data object does not clear
+  // it spuriously.
+  watch(
+    () => [
+      model.data.fileSource?.sampleId,
+      model.data.datasetRef?.blockId,
+      model.data.datasetRef?.name,
+    ],
+    () => {
+      model.data.prerunChecks = undefined;
+    },
+  );
+}
+
 // Make sure labels are initialized
 const unwatch = watch(sdkPlugin, ({ loaded }) => {
   if (!loaded) return;
diff --git a/ui/src/pages/MainPage.vue b/ui/src/pages/MainPage.vue
index 4fe43ce..20421d5 100644
--- a/ui/src/pages/MainPage.vue
+++ b/ui/src/pages/MainPage.vue
@@ -11,7 +11,7 @@ import {
   CHAIN_SLOTS,
   SCHEMES_FOR_SELECTION,
 } from "@platforma-open/milaboratories.import-vdj.model";
-import { propertyCollisions } from "@platforma-open/milaboratories.import-vdj.model";
+import { bareSetValid, propertyCollisions } from "@platforma-open/milaboratories.import-vdj.model";
 import type { ImportFileHandle, PlRef } from "@platforma-sdk/model";
 import { getFileNameFromHandle, uniquePlId } from "@platforma-sdk/model";
 import canonicalize from "canonicalize";
@@ -303,6 +303,18 @@ const propertyCollisionMessage = computed(() => {
   return `These headers would become the same column: ${pairs}. Rename one in the file — importing both is not possible, and dropping one silently would lose a column you asked for.`;
 });
 
+/**
+ * The mapping is finished but prerun has not yet said whether the id column repeats.
+ *
+ * Run is disabled meanwhile (the args projection refuses an unchecked column), and this block's
+ * layout does not surface the args error, so the reason has to be said here.
+ */
+const identityCheckPending = computed(() => {
+  const bare = app.model.data.bareSet;
+  if (bare === undefined || !bareSetValid(bare)) return false;
+  return app.model.data.prerunChecks?.identity !== bare.identity;
+});
+
 // Enough values to recognise the problem in the file, not enough to bury the sentence that says
 // what to do about it.
 const COLLISIONS_SHOWN = 3;
@@ -752,6 +764,9 @@ watch(
           >
             {{ identityCollisionMessage }}
           </PlAlert>
+          <PlAlert v-else-if="identityCheckPending" type="info" :style="{ width: '100%' }">
+            Checking the id column for repeats. This can take a moment, please wait...
+          </PlAlert>
           <div class="field-col">
             <PlDropdown
               :model-value="bareField('identity')"

From 065faac9275dab251dbbbd9362f64b5135655ca8 Mon Sep 17 00:00:00 2001
From: Elena Erokhina <erohinaelena1@yandex.ru>
Date: Tue, 25 Aug 2026 17:28:05 +0200
Subject: [PATCH 05/13] MILAB-6720: let the id column be cleared

Clearing it left the field reading "Value not available" in red. `identity` is a
required string, so "nothing chosen" is stored as "", and a dropdown treats any
non-undefined value as chosen -- "" is a chosen value that is not in the
options. The field now reports nothing chosen.

Also: clearing a mapping only reset it when the mapped chains were the IG pair,
so a TCR mapping could never clear itself.

The message shown while the checks are outstanding is now phrased for the checks
in general rather than naming the id column, since more of them are coming.
---
 .../clearing-the-id-column-looked-broken.md   | 15 +++++++++++
 .changeset/refuse-an-unchecked-id-column.md   |  5 ++--
 model/src/index.ts                            | 18 +++++++------
 ui/src/pages/MainPage.vue                     | 27 ++++++++++++-------
 4 files changed, 45 insertions(+), 20 deletions(-)
 create mode 100644 .changeset/clearing-the-id-column-looked-broken.md

diff --git a/.changeset/clearing-the-id-column-looked-broken.md b/.changeset/clearing-the-id-column-looked-broken.md
new file mode 100644
index 0000000..69db756
--- /dev/null
+++ b/.changeset/clearing-the-id-column-looked-broken.md
@@ -0,0 +1,15 @@
+---
+'@platforma-open/milaboratories.import-vdj.ui': patch
+'@platforma-open/milaboratories.import-vdj': patch
+---
+
+Let the id column be cleared
+
+Clearing the id column left the field reading "Value not available" in red, as though the choice
+had broken rather than been cleared. `identity` is a required string, so "nothing chosen" is stored
+as an empty string, and a dropdown treats any value that is not `undefined` as chosen — an empty
+string is simply a chosen value absent from the options. The field now reports nothing chosen,
+which is what happened.
+
+One thing nearby: clearing every mapped column only reset the mapping when the mapped chains were
+the IG pair, so a TCR mapping could never clear itself. It now checks every slot.
diff --git a/.changeset/refuse-an-unchecked-id-column.md b/.changeset/refuse-an-unchecked-id-column.md
index a5024b0..9d493eb 100644
--- a/.changeset/refuse-an-unchecked-id-column.md
+++ b/.changeset/refuse-an-unchecked-id-column.md
@@ -13,8 +13,9 @@ a warning: Run stayed live, and a run driven through the API imported the merged
 complaint.
 
 Run is now refused both while the verdict for the selected column is still outstanding and when it
-says the column repeats, and the panel says which of the two it is waiting on. The platform
-enforces it as well as the interface — invalid args leave nothing to render a production from.
+says the column repeats, and the panel says which of the two it is waiting on — worded for the
+checks in general, since more of them are coming. The platform enforces it as well as the
+interface: invalid args leave nothing to render a production from.
 
 Getting there needs prerun's verdict inside the args projection, which sees only the block's own
 data, so the UI mirrors it in. That is a hairpin, and deliberately so: unlike a column mapping
diff --git a/model/src/index.ts b/model/src/index.ts
index eee0b13..a388035 100644
--- a/model/src/index.ts
+++ b/model/src/index.ts
@@ -39,19 +39,21 @@ function withoutDatasetDoorMapping(args: BlockArgs): BlockArgs {
 }
 
 /**
- * Refuse a bare set whose id column prerun has not cleared.
+ * Refuse a bare set whose mapped columns prerun has not cleared.
  *
- * The check itself cannot live here — it reads the whole file — so this reads the verdict the UI
- * mirrored into `data.prerunChecks`, and refuses both a verdict that says the column repeats and
- * the absence of one for the column currently selected. Refusing the absence is the point: the
+ * The checks themselves cannot live here — they read the whole file — so this reads the verdicts
+ * the UI mirrored into `data.prerunChecks`, and refuses both a verdict that reports a defect and
+ * the absence of one for the columns currently selected. Refusing the absence is the point: the
  * record key is the identity's hash, so starting a run before the answer is in is exactly how two
  * different records silently become one.
+ *
+ * Phrased for the checks rather than for the id column, because it is about to cover more of them.
  */
-function requireCheckedIdentity(data: BlockData): void {
+function requireCheckedColumns(data: BlockData): void {
   const identity = data.bareSet?.identity;
   if (identity === undefined || identity === "") return; // bareSetValid has already refused
   const checks = data.prerunChecks;
-  if (checks?.identity !== identity) throw new Error("Checking the id column for repeats");
+  if (checks?.identity !== identity) throw new Error("Validating the selected columns");
   if (checks.identityCollides) {
     throw new Error(`"${identity}" repeats on rows that are not identical`);
   }
@@ -91,7 +93,7 @@ function projectArgs(data: BlockData): BlockArgs {
   // mapping unfurled under a format nobody had chosen.
   if (fileSource !== undefined) {
     if (!bareSetValid(data.bareSet)) throw new Error("Finish mapping the file's columns");
-    requireCheckedIdentity(data);
+    requireCheckedColumns(data);
     return withoutDatasetDoorMapping(args);
   }
 
@@ -105,7 +107,7 @@ function projectArgs(data: BlockData): BlockArgs {
     // identity column, because the key is the identity's hash and the label is its value.
     if (data.bareSet !== undefined) {
       if (!bareSetValid(data.bareSet)) throw new Error("Finish mapping the record's columns");
-      requireCheckedIdentity(data);
+      requireCheckedColumns(data);
       return withoutDatasetDoorMapping(args);
     }
 
diff --git a/ui/src/pages/MainPage.vue b/ui/src/pages/MainPage.vue
index 20421d5..8c2442b 100644
--- a/ui/src/pages/MainPage.vue
+++ b/ui/src/pages/MainPage.vue
@@ -204,7 +204,11 @@ function setChainSelection(value: string | undefined) {
 function bareField(field: "identity" | BareSetChain): string | undefined {
   const bare = getBare();
   if (!bare) return undefined;
-  return field === "identity" ? bare.identity : bare.sequences?.[field];
+  if (field !== "identity") return bare.sequences?.[field];
+  // `identity` is a required string, so "nothing chosen" is stored as "". A dropdown counts any
+  // non-undefined value as chosen, so handing it "" showed an italic red "Value not available"
+  // instead of an empty field, and clearing the id column looked like it had broken it.
+  return bare.identity === "" ? undefined : bare.identity;
 }
 
 /** Written on user gesture only, never from a watcher on an output. */
@@ -228,8 +232,9 @@ function setBareField(field: "identity" | BareSetChain, value: string | undefine
   }
 
   // Cleared right back out when nothing is mapped, so its mere presence stays a reliable
-  // signal that this is a bare set.
-  const empty = !next.identity && !next.sequences.IGHeavy && !next.sequences.IGLight;
+  // signal that this is a bare set. Every slot, not just the two IG ones — naming those two left
+  // a TCR mapping unable to clear itself.
+  const empty = !next.identity && !Object.values(next.sequences).some(Boolean);
   a.bareSet = empty ? undefined : next;
 }
 
@@ -304,19 +309,21 @@ const propertyCollisionMessage = computed(() => {
 });
 
 /**
- * The mapping is finished but prerun has not yet said whether the id column repeats.
+ * The mapping is finished but prerun has not yet cleared the columns it names.
  *
- * Run is disabled meanwhile (the args projection refuses an unchecked column), and this block's
- * layout does not surface the args error, so the reason has to be said here.
+ * Run is disabled meanwhile (the args projection refuses unchecked columns), and this block's
+ * layout does not surface the args error, so the reason has to be said here. Named and worded for
+ * the checks in general — the id column's uniqueness is the only one today.
  */
-const identityCheckPending = computed(() => {
+const columnChecksPending = computed(() => {
   const bare = app.model.data.bareSet;
   if (bare === undefined || !bareSetValid(bare)) return false;
   return app.model.data.prerunChecks?.identity !== bare.identity;
 });
 
 // Enough values to recognise the problem in the file, not enough to bury the sentence that says
-// what to do about it.
+// what to do about it. Printed whole and left to scroll: the id column can hold sequences, and
+// trimming those removes the very part that tells two of them apart.
 const COLLISIONS_SHOWN = 3;
 
 const identityCollisionMessage = computed(() => {
@@ -764,8 +771,8 @@ watch(
           >
             {{ identityCollisionMessage }}
           </PlAlert>
-          <PlAlert v-else-if="identityCheckPending" type="info" :style="{ width: '100%' }">
-            Checking the id column for repeats. This can take a moment, please wait...
+          <PlAlert v-else-if="columnChecksPending" type="info" :style="{ width: '100%' }">
+            Validating the selected columns. This can take a moment, please wait...
           </PlAlert>
           <div class="field-col">
             <PlDropdown

From 0ce6b7b5d20bf3725dff86467614ee4d9ce924e9 Mon Sep 17 00:00:00 2001
From: Elena Erokhina <erohinaelena1@yandex.ru>
Date: Tue, 25 Aug 2026 17:40:44 +0200
Subject: [PATCH 06/13] MILAB-6720: fold the changesets into one

Five separate entries for one PR's worth of related work read as five
independent releases in the changelog. One entry, same package list.
---
 .../alert-headings-were-never-rendered.md     | 12 -----
 ...announce-the-file-scan-and-gate-the-run.md | 33 -------------
 .../clearing-the-id-column-looked-broken.md   | 15 ------
 .../collision-warning-names-its-column.md     | 17 -------
 .changeset/prerun-feedback-and-run-gate.md    | 48 +++++++++++++++++++
 .changeset/refuse-an-unchecked-id-column.md   | 26 ----------
 6 files changed, 48 insertions(+), 103 deletions(-)
 delete mode 100644 .changeset/alert-headings-were-never-rendered.md
 delete mode 100644 .changeset/announce-the-file-scan-and-gate-the-run.md
 delete mode 100644 .changeset/clearing-the-id-column-looked-broken.md
 delete mode 100644 .changeset/collision-warning-names-its-column.md
 create mode 100644 .changeset/prerun-feedback-and-run-gate.md
 delete mode 100644 .changeset/refuse-an-unchecked-id-column.md

diff --git a/.changeset/alert-headings-were-never-rendered.md b/.changeset/alert-headings-were-never-rendered.md
deleted file mode 100644
index cd38c5e..0000000
--- a/.changeset/alert-headings-were-never-rendered.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-'@platforma-open/milaboratories.import-vdj.ui': patch
-'@platforma-open/milaboratories.import-vdj': patch
----
-
-Show the headings on the warning alerts
-
-Four alerts passed their heading as `<template #title>`, but `PlAlert` declares only a default
-slot — it takes a heading through the `label` prop. The headings had therefore never rendered:
-"Id column is not unique", "Two headers would become one column", "Invalid <format> dataset" and
-"No clonotypes imported" all showed their body text with nothing above it, so a warning about a
-non-unique id column read as an unlabelled wall of values.
diff --git a/.changeset/announce-the-file-scan-and-gate-the-run.md b/.changeset/announce-the-file-scan-and-gate-the-run.md
deleted file mode 100644
index 9209a04..0000000
--- a/.changeset/announce-the-file-scan-and-gate-the-run.md
+++ /dev/null
@@ -1,33 +0,0 @@
----
-'@platforma-open/milaboratories.import-vdj.workflow': patch
-'@platforma-open/milaboratories.import-vdj.model': patch
-'@platforma-open/milaboratories.import-vdj.ui': patch
-'@platforma-open/milaboratories.import-vdj': patch
----
-
-Say when a loaded file is being read, and stop the run until it has been
-
-Picking a file left the panel silent. Every column of the file is profiled before anything can be
-mapped — a whole-file pass, minutes on remote storage — and nothing said so: the profile outputs
-are retentive, so the dropdowns kept answering with the *previous* file's headers as though
-nothing had happened. Worse, a mapping that had passed every check against that previous file
-still satisfied the validity rule, so Run stayed live over a file nobody had looked at yet, and
-over headers it might not even contain.
-
-Three changes:
-
-- Prerun states which file the profile was taken from (`profiledSampleId`), and the model pairs
-  the two under `retentive` — while the new scan runs, the reported id stays the old file's. The
-  panel compares it with the loaded file and announces the wait, withholding the mapping until
-  the columns on offer are really this file's. Keyed to the file rather than to "prerun is busy"
-  on purpose: prerun also re-runs on every mapping edit, to re-check the identity column for
-  collisions, and a message that appeared on each dropdown pick would train the scientist to
-  ignore it.
-- Picking a different file drops the parts of the mapping that name columns, keeping the receptor
-  declaration and the numbering scheme, which are statements about the data rather than about one
-  file. That is what disables Run. Done on the gesture rather than by reconciling against the new
-  profile: `args` is a pure function of the block's data and cannot consult prerun, and mirroring
-  prerun's verdict back into that data is the pattern this block is trying to shed. Re-picking the
-  same file is not a swap and keeps the mapping.
-- The import itself now shows the block's loader, which it never did. Scoped to the main run: the
-  loader covers the whole block, and prerun runs while the settings panel is being edited.
diff --git a/.changeset/clearing-the-id-column-looked-broken.md b/.changeset/clearing-the-id-column-looked-broken.md
deleted file mode 100644
index 69db756..0000000
--- a/.changeset/clearing-the-id-column-looked-broken.md
+++ /dev/null
@@ -1,15 +0,0 @@
----
-'@platforma-open/milaboratories.import-vdj.ui': patch
-'@platforma-open/milaboratories.import-vdj': patch
----
-
-Let the id column be cleared
-
-Clearing the id column left the field reading "Value not available" in red, as though the choice
-had broken rather than been cleared. `identity` is a required string, so "nothing chosen" is stored
-as an empty string, and a dropdown treats any value that is not `undefined` as chosen — an empty
-string is simply a chosen value absent from the options. The field now reports nothing chosen,
-which is what happened.
-
-One thing nearby: clearing every mapped column only reset the mapping when the mapped chains were
-the IG pair, so a TCR mapping could never clear itself. It now checks every slot.
diff --git a/.changeset/collision-warning-names-its-column.md b/.changeset/collision-warning-names-its-column.md
deleted file mode 100644
index b373d44..0000000
--- a/.changeset/collision-warning-names-its-column.md
+++ /dev/null
@@ -1,17 +0,0 @@
----
-'@platforma-open/milaboratories.import-vdj.workflow': patch
-'@platforma-open/milaboratories.import-vdj.model': patch
-'@platforma-open/milaboratories.import-vdj.ui': patch
-'@platforma-open/milaboratories.import-vdj': patch
----
-
-Tie the id-collision warning to the column it is about, and shorten it
-
-Changing an offending id column flashed the old verdict under the new column's name: the panel
-quoted `bareSet.identity`, which updates on the pick, against collisions the previous column's
-prerun had produced. Prerun now states which column it checked, the model reports the two as one
-value so they cannot come from different runs, and the panel shows the warning only while it is
-about the column now selected — so picking a clean column clears it instead of re-accusing it.
-
-The message also listed up to ten repeated values, which buried the sentence saying what to do.
-It now shows three and a count.
diff --git a/.changeset/prerun-feedback-and-run-gate.md b/.changeset/prerun-feedback-and-run-gate.md
new file mode 100644
index 0000000..2b00c83
--- /dev/null
+++ b/.changeset/prerun-feedback-and-run-gate.md
@@ -0,0 +1,48 @@
+---
+'@platforma-open/milaboratories.import-vdj.workflow': patch
+'@platforma-open/milaboratories.import-vdj.model': patch
+'@platforma-open/milaboratories.import-vdj.ui': patch
+'@platforma-open/milaboratories.import-vdj': patch
+---
+
+Say what the block is checking, and refuse to run until it has
+
+Loading a file left the panel silent while every column of it was profiled — a whole-file pass,
+minutes on remote storage — and the profile outputs are retentive, so the dropdowns went on
+answering with the *previous* file's headers as though nothing had happened. A mapping that had
+passed every check against that previous file also still counted as valid, so Run stayed live over
+a file nobody had read yet, against headers it might not even contain.
+
+- **The wait is announced.** Prerun now states which file a profile was taken from, and the model
+  pairs the two so the reported file cannot get ahead of the profile. The panel announces the scan
+  and withholds the mapping until the columns on offer are really this file's. Keyed to the file
+  rather than to "prerun is busy", because prerun also re-runs on every mapping edit to re-check
+  the id column. The import itself now shows the block's loader, which it never did.
+- **Loading a second file disables Run.** Picking a different file drops the parts of the mapping
+  that name columns, keeping the receptor declaration and the numbering scheme, which describe the
+  data rather than one file. Re-picking the same file is not a swap and keeps the mapping.
+- **A repeated id column now stops the run.** The record key is the identity's hash, so a value
+  repeated on rows that are not identical merges two records into one. Prerun always found these
+  and the panel always warned, but the warning was only a warning, and a run driven through the API
+  imported the merged set without complaint. Run is now refused both while the verdict is
+  outstanding and when it reports a repeat, and the platform enforces it as well as the interface.
+- **The warning names the column it is about.** It used to quote the freshly picked column against
+  the previous one's verdict, so changing an offending column flashed the old accusation under the
+  new column's name. It also listed up to ten repeated values; it now lists three and a count,
+  printed whole, since the id column can hold sequences and trimming those hides what tells them
+  apart.
+- **Alert headings appear.** Four alerts passed their heading to a slot `PlAlert` does not have, so
+  the headings had never rendered — a warning about a non-unique id column read as an unlabelled
+  wall of values.
+- **The id column can be cleared.** Clearing it left the field reading "Value not available" in
+  red: "nothing chosen" is stored as an empty string, and a dropdown counts any value that is not
+  `undefined` as chosen. Relatedly, clearing a mapping only reset it for the IG chain pair, so a
+  TCR mapping could never clear itself.
+
+Refusing the run on a prerun verdict needs that verdict inside the args projection, which sees only
+the block's own data, so the UI mirrors it in. That is a hairpin, and deliberate: unlike a column
+mapping there is no gesture at which the fact could be captured, because the scientist picks a
+column and only then does the check discover whether it is sound. The two rules that keep it safe —
+a verdict carries what it is about, and is dropped when the source changes — are stated on
+`BlockData.prerunChecks`, and the checks still to come should follow them. It can all go once
+`argsValid` can read prerun directly.
diff --git a/.changeset/refuse-an-unchecked-id-column.md b/.changeset/refuse-an-unchecked-id-column.md
deleted file mode 100644
index 9d493eb..0000000
--- a/.changeset/refuse-an-unchecked-id-column.md
+++ /dev/null
@@ -1,26 +0,0 @@
----
-'@platforma-open/milaboratories.import-vdj.model': patch
-'@platforma-open/milaboratories.import-vdj.ui': patch
-'@platforma-open/milaboratories.import-vdj': patch
----
-
-Refuse to run a bare set whose id column repeats
-
-The record key is the identity column's hash, so a value that repeats on rows that are not
-identical merges two different records into one — silently, and the block would import it anyway.
-Prerun has always found these and the panel has always warned about them, but the warning was only
-a warning: Run stayed live, and a run driven through the API imported the merged set without
-complaint.
-
-Run is now refused both while the verdict for the selected column is still outstanding and when it
-says the column repeats, and the panel says which of the two it is waiting on — worded for the
-checks in general, since more of them are coming. The platform enforces it as well as the
-interface: invalid args leave nothing to render a production from.
-
-Getting there needs prerun's verdict inside the args projection, which sees only the block's own
-data, so the UI mirrors it in. That is a hairpin, and deliberately so: unlike a column mapping
-there is no gesture at which the fact could be captured, because the scientist picks a column and
-only then does the check discover whether it is sound. The two rules that keep it safe — a verdict
-carries what it is about, and is dropped when the source changes — are stated on
-`BlockData.prerunChecks`, and further prerun checks should follow them. It can all go once
-`argsValid` can read prerun directly.

From 82191cae45f2a38effc9f928a45d400ade1c141b Mon Sep 17 00:00:00 2001
From: Elena Erokhina <erohinaelena1@yandex.ru>
Date: Tue, 25 Aug 2026 17:58:31 +0200
Subject: [PATCH 07/13] MILAB-6720: split the bare-set form out of MainPage

MainPage had grown to 1037 lines, over half of it one subject: mapping a file of
bare sequences onto records. That form, the checks that gate it and the numbering
that follows from it now live in pages/components/BareSetForm.vue, leaving
MainPage with the two doors, the dataset-door format mapping and the table (720
lines). The parent still decides whether the shape is being mapped at all -- a
file is loaded and its columns are known -- and passes the header list it already
computes for the other door.

SCHEME_LABELS and forgetMappedColumns move to the model: both are shared with
MainPage, and both are data-shape facts that sit naturally beside CHAIN_SLOT_LABELS
and bareSetValid.

Fixes a latent bug carried along in the move: propertyCandidates excluded only
IGHeavy and IGLight from the property candidates, so a TCR mapping was offered
its own sequence columns as record properties.
---
 .changeset/prerun-feedback-and-run-gate.md |   5 +-
 model/src/types.ts                         |  24 ++
 ui/src/pages/MainPage.vue                  | 340 +-------------------
 ui/src/pages/components/BareSetForm.vue    | 345 +++++++++++++++++++++
 4 files changed, 380 insertions(+), 334 deletions(-)
 create mode 100644 ui/src/pages/components/BareSetForm.vue

diff --git a/.changeset/prerun-feedback-and-run-gate.md b/.changeset/prerun-feedback-and-run-gate.md
index 2b00c83..5171753 100644
--- a/.changeset/prerun-feedback-and-run-gate.md
+++ b/.changeset/prerun-feedback-and-run-gate.md
@@ -36,8 +36,9 @@ a file nobody had read yet, against headers it might not even contain.
   wall of values.
 - **The id column can be cleared.** Clearing it left the field reading "Value not available" in
   red: "nothing chosen" is stored as an empty string, and a dropdown counts any value that is not
-  `undefined` as chosen. Relatedly, clearing a mapping only reset it for the IG chain pair, so a
-  TCR mapping could never clear itself.
+  `undefined` as chosen. Relatedly, two places named the IG chain pair where they meant every
+  mapped chain, so a TCR mapping could never clear itself and was offered its own sequence columns
+  as record properties.
 
 Refusing the run on a prerun verdict needs that verdict inside the args projection, which sees only
 the block's own data, so the UI mirrors it in. That is a hairpin, and deliberate: unlike a column
diff --git a/model/src/types.ts b/model/src/types.ts
index e561773..b4f804d 100644
--- a/model/src/types.ts
+++ b/model/src/types.ts
@@ -110,6 +110,13 @@ export const CHAIN_SLOT_LABELS: Record<BareSetChain, string> = {
   TCRGamma: "TCR-ɣ",
 };
 
+/** What to call each numbering scheme in front of the scientist. */
+export const SCHEME_LABELS: Record<BareSetScheme, string> = {
+  imgt: "IMGT",
+  kabat: "Kabat",
+  chothia: "Chothia",
+};
+
 /** What a column can hold, decided by profiling every row of the file. */
 export type ColumnValueType = "Long" | "Double" | "String";
 
@@ -303,6 +310,23 @@ export function propertyCollisions(properties: ImportedProperty[]): Record<strin
   return Object.fromEntries(Object.entries(byToken).filter(([, hs]) => hs.length > 1));
 }
 
+/**
+ * The mapping with everything that names a column dropped.
+ *
+ * The receptor declaration and the numbering scheme describe the biology and outlive any one file;
+ * the identity column, the sequence columns and the accepted properties name headers, and mean
+ * nothing once the headers change.
+ */
+export function forgetMappedColumns(bare: BareSetMapping | undefined): BareSetMapping | undefined {
+  if (bare === undefined) return undefined;
+  return {
+    identity: "",
+    chainSelection: bare.chainSelection,
+    sequences: {},
+    scheme: bare.scheme,
+  };
+}
+
 /**
  * Whether a bare-set mapping is complete enough to run.
  *
diff --git a/ui/src/pages/MainPage.vue b/ui/src/pages/MainPage.vue
index 8c2442b..2e881a4 100644
--- a/ui/src/pages/MainPage.vue
+++ b/ui/src/pages/MainPage.vue
@@ -1,17 +1,9 @@
 <script setup lang="ts">
-import type {
-  BareSetChain,
-  BareSetScheme,
-  BlockData,
-  ChainSelection,
-  ImportedProperty,
-} from "@platforma-open/milaboratories.import-vdj.model";
+import type { BareSetScheme } from "@platforma-open/milaboratories.import-vdj.model";
 import {
-  CHAIN_SLOT_LABELS,
-  CHAIN_SLOTS,
-  SCHEMES_FOR_SELECTION,
+  forgetMappedColumns,
+  SCHEME_LABELS,
 } from "@platforma-open/milaboratories.import-vdj.model";
-import { bareSetValid, propertyCollisions } from "@platforma-open/milaboratories.import-vdj.model";
 import type { ImportFileHandle, PlRef } from "@platforma-sdk/model";
 import { getFileNameFromHandle, uniquePlId } from "@platforma-sdk/model";
 import canonicalize from "canonicalize";
@@ -35,6 +27,7 @@ import {
 import type { ImportedFiles } from "@platforma-sdk/ui-vue";
 import { computed, ref, watch, watchEffect } from "vue";
 import { useApp } from "../app";
+import BareSetForm from "./components/BareSetForm.vue";
 
 const app = useApp();
 
@@ -78,25 +71,6 @@ const emptySamplesMessage = computed(() => {
   return `After receptor chain filtering, no clonotypes found in sample(s) ${samples}`;
 });
 
-const SCHEME_LABELS: Record<BareSetScheme, string> = {
-  imgt: "IMGT",
-  kabat: "Kabat",
-  chothia: "Chothia",
-};
-
-/**
- * Only the schemes the declared chains can actually be numbered under. Kabat and Chothia are
- * antibody schemes — ANARCI implements them for heavy and light only and raises for a TCR chain
- * — so a TCR selection narrows this to IMGT rather than offering a choice that fails the run.
- */
-const schemeOptions = computed(() => {
-  const selection = app.model.data.bareSet?.chainSelection;
-  const allowed = selection
-    ? (SCHEMES_FOR_SELECTION[selection] ?? (["imgt"] as BareSetScheme[]))
-    : (["imgt", "kabat", "chothia"] as BareSetScheme[]);
-  return allowed.map((s) => ({ label: SCHEME_LABELS[s], value: s }));
-});
-
 // updating defaultBlockLabel
 watchEffect(() => {
   const args = app.model.data as any;
@@ -133,208 +107,6 @@ watchEffect(() => {
   args.defaultBlockLabel = parts.filter(Boolean).join(" - ");
 });
 
-// A bare set is not a mode the scientist declares up front — whether a set is bare is
-// something the block works out from what they mapped. So there is no toggle: the slots are
-// always offered, and filling the identity slot plus at least one chain is what makes it one.
-type BareSetArgs = NonNullable<BlockData["bareSet"]>;
-
-function getBare(): BareSetArgs | undefined {
-  return app.model.data.bareSet;
-}
-
-/**
- * What is being imported. Receptors expand to both their chains; a single chain is its own
- * entry, which is how a heavy-only panel is declared rather than inferred from an unfilled slot.
- *
- * The more diverse chain — the one recombining a D segment — comes first in every pair, which is
- * MiXCR's rule and the order its receptorInfos uses. TCR is numbered under IMGT only; the scheme
- * dropdown narrows itself from the selection.
- */
-const chainSelectionOptions = [
-  // Receptors then chains, with the labels mixcr-clonotyping's combined receptor-or-chain list
-  // uses (SettingsPanel.vue:288-301) — the same control, so the same words.
-  { label: "IG", value: "IG" },
-  { label: "TCR-αβ", value: "TCRAB" },
-  { label: "TCR-ɣδ", value: "TCRGD" },
-  { label: "IG Heavy", value: "IGHeavy" },
-  { label: "IG Light", value: "IGLight" },
-  { label: "TCR-α", value: "TCRAlpha" },
-  { label: "TCR-β", value: "TCRBeta" },
-  { label: "TCR-ɣ", value: "TCRGamma" },
-  { label: "TCR-δ", value: "TCRDelta" },
-];
-
-/** The slots the current declaration asks for, in emission order. */
-const chainSlots = computed<BareSetChain[]>(() => {
-  const selection = app.model.data.bareSet?.chainSelection;
-  return selection ? (CHAIN_SLOTS[selection] ?? []) : [];
-});
-
-function slotLabel(slot: BareSetChain): string {
-  return CHAIN_SLOT_LABELS[slot];
-}
-
-function setChainSelection(value: string | undefined) {
-  const a = app.model.data;
-  const current: BareSetArgs = a.bareSet ?? {
-    identity: "",
-    chainSelection: "IG",
-    sequences: {},
-    scheme: "imgt",
-  };
-  if (!value) return;
-
-  const selection = value as ChainSelection;
-  // Columns mapped to a slot the new declaration does not ask for are dropped. Keeping them
-  // would leave the block emitting a chain the scientist just said they were not importing.
-  const kept: Partial<Record<BareSetChain, string>> = {};
-  for (const slot of CHAIN_SLOTS[selection] ?? []) {
-    const existing = current.sequences?.[slot];
-    if (existing) kept[slot] = existing;
-  }
-
-  // A scheme the new chains cannot be numbered under would fail the run rather than the
-  // mapping, so it is reset here rather than left for ANARCI to reject.
-  const allowed = SCHEMES_FOR_SELECTION[selection] ?? (["imgt"] as BareSetScheme[]);
-  const scheme = allowed.includes(current.scheme) ? current.scheme : allowed[0];
-
-  a.bareSet = { ...current, chainSelection: selection, sequences: kept, scheme };
-}
-
-function bareField(field: "identity" | BareSetChain): string | undefined {
-  const bare = getBare();
-  if (!bare) return undefined;
-  if (field !== "identity") return bare.sequences?.[field];
-  // `identity` is a required string, so "nothing chosen" is stored as "". A dropdown counts any
-  // non-undefined value as chosen, so handing it "" showed an italic red "Value not available"
-  // instead of an empty field, and clearing the id column looked like it had broken it.
-  return bare.identity === "" ? undefined : bare.identity;
-}
-
-/** Written on user gesture only, never from a watcher on an output. */
-function setBareField(field: "identity" | BareSetChain, value: string | undefined) {
-  const a = app.model.data;
-  const current: BareSetArgs = a.bareSet ?? {
-    identity: "",
-    chainSelection: "IG",
-    sequences: {},
-    scheme: "imgt",
-  };
-  const next: BareSetArgs = {
-    identity: field === "identity" ? (value ?? "") : current.identity,
-    chainSelection: current.chainSelection,
-    sequences: { ...current.sequences },
-    scheme: current.scheme,
-  };
-  if (field !== "identity") {
-    if (value) next.sequences[field] = value;
-    else delete next.sequences[field];
-  }
-
-  // Cleared right back out when nothing is mapped, so its mere presence stays a reliable
-  // signal that this is a bare set. Every slot, not just the two IG ones — naming those two left
-  // a TCR mapping unable to clear itself.
-  const empty = !next.identity && !Object.values(next.sequences).some(Boolean);
-  a.bareSet = empty ? undefined : next;
-}
-
-function setBareScheme(value: string | undefined) {
-  const a = app.model.data;
-  if (!a.bareSet || !value) return;
-  a.bareSet = { ...a.bareSet, scheme: value as BareSetArgs["scheme"] };
-}
-
-/**
- * A column has been assigned. Not `bareSet !== undefined`: picking a new file keeps the receptor
- * declaration and the scheme (see forgetMappedColumns), so the object outlives the mapping.
- */
-const isBareSet = computed(() => {
-  const bare = app.model.data.bareSet;
-  if (bare === undefined) return false;
-  return !!bare.identity || Object.values(bare.sequences ?? {}).some(Boolean);
-});
-
-/**
- * Identity values the file repeats on rows that are not identical — but only once they are known
- * to be about the column now selected. The record key is the identity's hash, so a repeat merges
- * two different records into one.
- *
- * The output carries the column it was computed for; anything else is a verdict about a column
- * the scientist has already moved on from.
- */
-const identityCollisions = computed<string[]>(() => {
-  const found = app.model.outputs.identityCollisions;
-  if (found === undefined) return [];
-  if (found.identity !== app.model.data.bareSet?.identity) return [];
-  return found.values;
-});
-
-/** Headers not taken by a sequence or the identity — offered as record properties rather than
- *  dropped, which is what the block used to do with them. */
-const propertyCandidates = computed(() => {
-  const bare = app.model.data.bareSet;
-  const taken = new Set(
-    [bare?.identity, bare?.sequences?.IGHeavy, bare?.sequences?.IGLight].filter(
-      Boolean,
-    ) as string[],
-  );
-  // File door only — record properties exist only for a bare set.
-  return (app.model.outputs.fileColumns ?? []).filter((h) => !taken.has(h));
-});
-
-const acceptedProperties = computed<string[]>({
-  get: () => (app.model.data.bareSet?.properties ?? []).map((p) => p.header),
-  set: (headers) => {
-    const a = app.model.data;
-    if (!a.bareSet) return;
-    // The type is written here, on the accept gesture, from the profile prerun produced by
-    // reading every row. The panel asks no type question — see ColumnProfile — and taking a
-    // snapshot at the gesture keeps the args projection a pure function of `data`.
-    const types = app.model.outputs.columnProfile?.types ?? {};
-    a.bareSet = {
-      ...a.bareSet,
-      properties: headers.map(
-        (h): ImportedProperty => ({ header: h, valueType: types[h] ?? "String" }),
-      ),
-    };
-  },
-});
-
-const propertyCollisionMessage = computed(() => {
-  const collisions = propertyCollisions(app.model.data.bareSet?.properties ?? []);
-  const groups = Object.values(collisions);
-  if (groups.length === 0) return "";
-  const pairs = groups.map((hs) => hs.join(" / ")).join("; ");
-  return `These headers would become the same column: ${pairs}. Rename one in the file — importing both is not possible, and dropping one silently would lose a column you asked for.`;
-});
-
-/**
- * The mapping is finished but prerun has not yet cleared the columns it names.
- *
- * Run is disabled meanwhile (the args projection refuses unchecked columns), and this block's
- * layout does not surface the args error, so the reason has to be said here. Named and worded for
- * the checks in general — the id column's uniqueness is the only one today.
- */
-const columnChecksPending = computed(() => {
-  const bare = app.model.data.bareSet;
-  if (bare === undefined || !bareSetValid(bare)) return false;
-  return app.model.data.prerunChecks?.identity !== bare.identity;
-});
-
-// Enough values to recognise the problem in the file, not enough to bury the sentence that says
-// what to do about it. Printed whole and left to scroll: the id column can hold sequences, and
-// trimming those removes the very part that tells two of them apart.
-const COLLISIONS_SHOWN = 3;
-
-const identityCollisionMessage = computed(() => {
-  const values = identityCollisions.value;
-  if (values.length === 0) return "";
-  const shown = values.slice(0, COLLISIONS_SHOWN).join(", ");
-  const rest =
-    values.length > COLLISIONS_SHOWN ? ` and ${values.length - COLLISIONS_SHOWN} more` : "";
-  return `Repeated on rows that are not identical: ${shown}${rest}. Two rows sharing an id become one record — pick a different column, or fix the file.`;
-});
-
 const countTypeOptions = [
   { label: "Reads", value: "read" },
   { label: "UMIs", value: "umi" },
@@ -457,20 +229,6 @@ const fileScanning = computed(() => {
   return app.model.outputs.profiledSampleId !== file.sampleId;
 });
 
-/**
- * The mapping with everything that names a column dropped. The receptor declaration and the
- * numbering scheme describe the biology and outlive any one file; the column names do not.
- */
-function forgetMappedColumns(bare: BareSetArgs | undefined): BareSetArgs | undefined {
-  if (bare === undefined) return undefined;
-  return {
-    identity: "",
-    chainSelection: bare.chainSelection,
-    sequences: {},
-    scheme: bare.scheme,
-  };
-}
-
 async function setFile(handle: ImportFileHandle | undefined) {
   fileSourceError.value = "";
   const a = app.model.data;
@@ -601,20 +359,6 @@ const headerOptions = computed(() => {
   return (columns ?? []).map((h) => ({ label: h, value: h }));
 });
 
-/** Headers whose sampled values actually read as amino-acid variable domains. The workflow
- *  works this out at prerun by reading a few rows — a header cannot say it, and offering every
- *  column here lets an antibody's *name* be mapped into a sequence slot, which imports cleanly
- *  and leaves every record Failed after ANARCI declines to number it.
- *
- *  Falls back to every header when the classification is empty, which happens before the file
- *  is read and on a file whose rows could not be sampled. An empty dropdown would be a worse
- *  failure than an unfiltered one: the scientist could not proceed at all. */
-const sequenceOptions = computed(() => {
-  const aminoAcid = app.model.outputs.aminoAcidColumns ?? [];
-  if (aminoAcid.length === 0) return headerOptions.value;
-  return aminoAcid.map((h) => ({ label: h, value: h }));
-});
-
 function getMapping(key: string): string | undefined {
   const a = app.model.data as unknown as { customMapping?: Record<string, string | undefined> };
   return a.customMapping?.[key];
@@ -761,78 +505,10 @@ watch(
           Checking the file's columns. This can take a moment, please wait...
         </PlAlert>
 
-        <template v-if="!fileScanning && headerOptions.length > 0">
-          <PlSectionSeparator>Columns to import</PlSectionSeparator>
-          <PlAlert
-            v-if="identityCollisionMessage"
-            type="warn"
-            label="Id column is not unique"
-            :style="{ width: '100%' }"
-          >
-            {{ identityCollisionMessage }}
-          </PlAlert>
-          <PlAlert v-else-if="columnChecksPending" type="info" :style="{ width: '100%' }">
-            Validating the selected columns. This can take a moment, please wait...
-          </PlAlert>
-          <div class="field-col">
-            <PlDropdown
-              :model-value="bareField('identity')"
-              :options="headerOptions"
-              label="Select id column"
-              clearable
-              required
-              @update:model-value="(v: string | undefined) => setBareField('identity', v)"
-            />
-            <PlDropdown
-              :model-value="app.model.data.bareSet?.chainSelection"
-              :options="chainSelectionOptions"
-              label="Receptors"
-              required
-              @update:model-value="(v: string | undefined) => setChainSelection(v)"
-            />
-            <PlDropdown
-              v-for="slot in chainSlots"
-              :key="slot"
-              :model-value="bareField(slot)"
-              :options="sequenceOptions"
-              :label="slotLabel(slot)"
-              clearable
-              required
-              @update:model-value="(v: string | undefined) => setBareField(slot, v)"
-            />
-            <template v-if="isBareSet">
-              <PlDropdownMulti
-                v-model="acceptedProperties"
-                :options="propertyCandidates.map((h) => ({ label: h, value: h }))"
-                label="Import as record properties"
-              />
-            </template>
-          </div>
-          <PlAlert
-            v-if="propertyCollisionMessage"
-            type="warn"
-            label="Two headers would become one column"
-            :style="{ width: '100%' }"
-          >
-            {{ propertyCollisionMessage }}
-          </PlAlert>
-        </template>
-
-        <!-- Not a column mapping: it chooses how the mapped sequences are numbered, and the
-             region boundaries every downstream block reads follow from it. Kept apart from the
-             mapping so it does not read as one more column to assign. -->
-        <template v-if="isBareSet && !fileScanning">
-          <PlSectionSeparator>Region annotation</PlSectionSeparator>
-          <div class="field-col">
-            <PlDropdown
-              :model-value="app.model.data.bareSet?.scheme"
-              :options="schemeOptions"
-              label="Numbering scheme"
-              required
-              @update:model-value="(v: string | undefined) => setBareScheme(v)"
-            />
-          </div>
-        </template>
+        <BareSetForm
+          v-if="!fileScanning && headerOptions.length > 0"
+          :header-options="headerOptions"
+        />
       </template>
 
       <template v-else>
diff --git a/ui/src/pages/components/BareSetForm.vue b/ui/src/pages/components/BareSetForm.vue
new file mode 100644
index 0000000..36e4596
--- /dev/null
+++ b/ui/src/pages/components/BareSetForm.vue
@@ -0,0 +1,345 @@
+<script setup lang="ts">
+/**
+ * Mapping a file of bare sequences onto records: which column identifies a record, which chains
+ * are being imported, which column carries each one, what else to keep, and how to number it.
+ *
+ * A form for one shape of input, kept whole — its dropdowns, the checks that gate them and the
+ * numbering that follows from them are one subject, and they were the larger half of MainPage.
+ * The parent decides *whether* this shape is being mapped at all (a file is loaded and its columns
+ * are known); everything from there down is here.
+ */
+import type {
+  BareSetChain,
+  BareSetMapping,
+  BareSetScheme,
+  ChainSelection,
+  ImportedProperty,
+} from "@platforma-open/milaboratories.import-vdj.model";
+import {
+  bareSetValid,
+  CHAIN_SLOT_LABELS,
+  CHAIN_SLOTS,
+  propertyCollisions,
+  SCHEME_LABELS,
+  SCHEMES_FOR_SELECTION,
+} from "@platforma-open/milaboratories.import-vdj.model";
+import { PlAlert, PlDropdown, PlDropdownMulti, PlSectionSeparator } from "@platforma-sdk/ui-vue";
+import { computed } from "vue";
+import { useApp } from "../../app";
+
+const { headerOptions } = defineProps<{
+  /** Every column of the loaded file. Computed by the parent, which needs it for the other door. */
+  headerOptions: { label: string; value: string }[];
+}>();
+
+const app = useApp();
+
+/**
+ * Only the schemes the declared chains can actually be numbered under. Kabat and Chothia are
+ * antibody schemes — ANARCI implements them for heavy and light only and raises for a TCR chain
+ * — so a TCR selection narrows this to IMGT rather than offering a choice that fails the run.
+ */
+const schemeOptions = computed(() => {
+  const selection = app.model.data.bareSet?.chainSelection;
+  const allowed = selection
+    ? (SCHEMES_FOR_SELECTION[selection] ?? (["imgt"] as BareSetScheme[]))
+    : (["imgt", "kabat", "chothia"] as BareSetScheme[]);
+  return allowed.map((s) => ({ label: SCHEME_LABELS[s], value: s }));
+});
+
+// A bare set is not a mode the scientist declares up front — whether a set is bare is something
+// the block works out from what they mapped. So there is no toggle: the slots are always offered,
+// and filling the identity slot plus at least one chain is what makes it one.
+function getBare(): BareSetMapping | undefined {
+  return app.model.data.bareSet;
+}
+
+/**
+ * What is being imported. Receptors expand to both their chains; a single chain is its own entry,
+ * which is how a heavy-only panel is declared rather than inferred from an unfilled slot.
+ *
+ * The labels are the ones mixcr-clonotyping's combined receptor-or-chain list uses
+ * (SettingsPanel.vue:288-301) — the same control, so the same words. The more diverse chain, the
+ * one recombining a D segment, comes first in every pair, which is MiXCR's rule.
+ */
+const chainSelectionOptions = [
+  { label: "IG", value: "IG" },
+  { label: "TCR-αβ", value: "TCRAB" },
+  { label: "TCR-ɣδ", value: "TCRGD" },
+  { label: "IG Heavy", value: "IGHeavy" },
+  { label: "IG Light", value: "IGLight" },
+  { label: "TCR-α", value: "TCRAlpha" },
+  { label: "TCR-β", value: "TCRBeta" },
+  { label: "TCR-ɣ", value: "TCRGamma" },
+  { label: "TCR-δ", value: "TCRDelta" },
+];
+
+/** The slots the current declaration asks for, in emission order. */
+const chainSlots = computed<BareSetChain[]>(() => {
+  const selection = app.model.data.bareSet?.chainSelection;
+  return selection ? (CHAIN_SLOTS[selection] ?? []) : [];
+});
+
+function slotLabel(slot: BareSetChain): string {
+  return CHAIN_SLOT_LABELS[slot];
+}
+
+function setChainSelection(value: string | undefined) {
+  const a = app.model.data;
+  const current: BareSetMapping = a.bareSet ?? {
+    identity: "",
+    chainSelection: "IG",
+    sequences: {},
+    scheme: "imgt",
+  };
+  if (!value) return;
+
+  const selection = value as ChainSelection;
+  // Columns mapped to a slot the new declaration does not ask for are dropped. Keeping them would
+  // leave the block emitting a chain the scientist just said they were not importing.
+  const kept: Partial<Record<BareSetChain, string>> = {};
+  for (const slot of CHAIN_SLOTS[selection] ?? []) {
+    const existing = current.sequences?.[slot];
+    if (existing) kept[slot] = existing;
+  }
+
+  // A scheme the new chains cannot be numbered under would fail the run rather than the mapping,
+  // so it is reset here rather than left for ANARCI to reject.
+  const allowed = SCHEMES_FOR_SELECTION[selection] ?? (["imgt"] as BareSetScheme[]);
+  const scheme = allowed.includes(current.scheme) ? current.scheme : allowed[0];
+
+  a.bareSet = { ...current, chainSelection: selection, sequences: kept, scheme };
+}
+
+function bareField(field: "identity" | BareSetChain): string | undefined {
+  const bare = getBare();
+  if (!bare) return undefined;
+  if (field !== "identity") return bare.sequences?.[field];
+  // `identity` is a required string, so "nothing chosen" is stored as "". A dropdown counts any
+  // non-undefined value as chosen, so handing it "" showed an italic red "Value not available"
+  // instead of an empty field, and clearing the id column looked like it had broken it.
+  return bare.identity === "" ? undefined : bare.identity;
+}
+
+/** Written on user gesture only, never from a watcher on an output. */
+function setBareField(field: "identity" | BareSetChain, value: string | undefined) {
+  const a = app.model.data;
+  const current: BareSetMapping = a.bareSet ?? {
+    identity: "",
+    chainSelection: "IG",
+    sequences: {},
+    scheme: "imgt",
+  };
+  const next: BareSetMapping = {
+    identity: field === "identity" ? (value ?? "") : current.identity,
+    chainSelection: current.chainSelection,
+    sequences: { ...current.sequences },
+    scheme: current.scheme,
+  };
+  if (field !== "identity") {
+    if (value) next.sequences[field] = value;
+    else delete next.sequences[field];
+  }
+
+  // Cleared right back out when nothing is mapped, so its mere presence stays a reliable signal
+  // that this is a bare set. Every slot, not just the two IG ones — naming those two left a TCR
+  // mapping unable to clear itself.
+  const empty = !next.identity && !Object.values(next.sequences).some(Boolean);
+  a.bareSet = empty ? undefined : next;
+}
+
+function setBareScheme(value: string | undefined) {
+  const a = app.model.data;
+  if (!a.bareSet || !value) return;
+  a.bareSet = { ...a.bareSet, scheme: value as BareSetScheme };
+}
+
+/**
+ * A column has been assigned. Not `bareSet !== undefined`: picking a new file keeps the receptor
+ * declaration and the scheme (see forgetMappedColumns), so the object outlives the mapping.
+ */
+const isBareSet = computed(() => {
+  const bare = app.model.data.bareSet;
+  if (bare === undefined) return false;
+  return !!bare.identity || Object.values(bare.sequences ?? {}).some(Boolean);
+});
+
+/**
+ * Headers whose sampled values actually read as amino-acid variable domains. The workflow works
+ * this out at prerun by reading the file — a header cannot say it, and offering every column here
+ * lets an antibody's *name* be mapped into a sequence slot, which imports cleanly and leaves every
+ * record Failed after ANARCI declines to number it.
+ *
+ * Falls back to every header when the classification is empty, which happens before the file is
+ * read and on a file whose rows could not be sampled. An empty dropdown would be a worse failure
+ * than an unfiltered one: the scientist could not proceed at all.
+ */
+const sequenceOptions = computed(() => {
+  const aminoAcid = app.model.outputs.aminoAcidColumns ?? [];
+  if (aminoAcid.length === 0) return headerOptions;
+  return aminoAcid.map((h) => ({ label: h, value: h }));
+});
+
+/**
+ * Identity values the file repeats on rows that are not identical — but only once they are known
+ * to be about the column now selected. The record key is the identity's hash, so a repeat merges
+ * two different records into one.
+ *
+ * The output carries the column it was computed for; anything else is a verdict about a column the
+ * scientist has already moved on from.
+ */
+const identityCollisions = computed<string[]>(() => {
+  const found = app.model.outputs.identityCollisions;
+  if (found === undefined) return [];
+  if (found.identity !== app.model.data.bareSet?.identity) return [];
+  return found.values;
+});
+
+/**
+ * The mapping is finished but prerun has not yet cleared the columns it names.
+ *
+ * Run is disabled meanwhile (the args projection refuses unchecked columns), and this block's
+ * layout does not surface the args error, so the reason has to be said here. Named and worded for
+ * the checks in general — the id column's uniqueness is the only one today.
+ */
+const columnChecksPending = computed(() => {
+  const bare = app.model.data.bareSet;
+  if (bare === undefined || !bareSetValid(bare)) return false;
+  return app.model.data.prerunChecks?.identity !== bare.identity;
+});
+
+// Enough values to recognise the problem in the file, not enough to bury the sentence that says
+// what to do about it. Printed whole and left to scroll: the id column can hold sequences, and
+// trimming those removes the very part that tells two of them apart.
+const COLLISIONS_SHOWN = 3;
+
+const identityCollisionMessage = computed(() => {
+  const values = identityCollisions.value;
+  if (values.length === 0) return "";
+  const shown = values.slice(0, COLLISIONS_SHOWN).join(", ");
+  const rest =
+    values.length > COLLISIONS_SHOWN ? ` and ${values.length - COLLISIONS_SHOWN} more` : "";
+  return `Repeated on rows that are not identical: ${shown}${rest}. Two rows sharing an id become one record — pick a different column, or fix the file.`;
+});
+
+/**
+ * Headers not taken by a sequence or the identity — offered as record properties rather than
+ * dropped, which is what the block used to do with them.
+ */
+const propertyCandidates = computed(() => {
+  const bare = app.model.data.bareSet;
+  const taken = new Set(
+    [bare?.identity, ...Object.values(bare?.sequences ?? {})].filter(Boolean) as string[],
+  );
+  return (app.model.outputs.fileColumns ?? []).filter((h) => !taken.has(h));
+});
+
+const acceptedProperties = computed<string[]>({
+  get: () => (app.model.data.bareSet?.properties ?? []).map((p) => p.header),
+  set: (headers) => {
+    const a = app.model.data;
+    if (!a.bareSet) return;
+    // The type is written here, on the accept gesture, from the profile prerun produced by reading
+    // every row. The panel asks no type question — see ColumnProfile — and taking a snapshot at the
+    // gesture keeps the args projection a pure function of `data`.
+    const types = app.model.outputs.columnProfile?.types ?? {};
+    a.bareSet = {
+      ...a.bareSet,
+      properties: headers.map(
+        (h): ImportedProperty => ({ header: h, valueType: types[h] ?? "String" }),
+      ),
+    };
+  },
+});
+
+const propertyCollisionMessage = computed(() => {
+  const collisions = propertyCollisions(app.model.data.bareSet?.properties ?? []);
+  const groups = Object.values(collisions);
+  if (groups.length === 0) return "";
+  const pairs = groups.map((hs) => hs.join(" / ")).join("; ");
+  return `These headers would become the same column: ${pairs}. Rename one in the file — importing both is not possible, and dropping one silently would lose a column you asked for.`;
+});
+</script>
+
+<template>
+  <PlSectionSeparator>Columns to import</PlSectionSeparator>
+
+  <PlAlert
+    v-if="identityCollisionMessage"
+    type="warn"
+    label="Id column is not unique"
+    :style="{ width: '100%' }"
+  >
+    {{ identityCollisionMessage }}
+  </PlAlert>
+  <PlAlert v-else-if="columnChecksPending" type="info" :style="{ width: '100%' }">
+    Validating the selected columns. This can take a moment, please wait...
+  </PlAlert>
+
+  <div class="field-col">
+    <PlDropdown
+      :model-value="bareField('identity')"
+      :options="headerOptions"
+      label="Select id column"
+      clearable
+      required
+      @update:model-value="(v: string | undefined) => setBareField('identity', v)"
+    />
+    <PlDropdown
+      :model-value="app.model.data.bareSet?.chainSelection"
+      :options="chainSelectionOptions"
+      label="Receptors"
+      required
+      @update:model-value="(v: string | undefined) => setChainSelection(v)"
+    />
+    <PlDropdown
+      v-for="slot in chainSlots"
+      :key="slot"
+      :model-value="bareField(slot)"
+      :options="sequenceOptions"
+      :label="slotLabel(slot)"
+      clearable
+      required
+      @update:model-value="(v: string | undefined) => setBareField(slot, v)"
+    />
+    <PlDropdownMulti
+      v-if="isBareSet"
+      v-model="acceptedProperties"
+      :options="propertyCandidates.map((h) => ({ label: h, value: h }))"
+      label="Import as record properties"
+    />
+  </div>
+
+  <PlAlert
+    v-if="propertyCollisionMessage"
+    type="warn"
+    label="Two headers would become one column"
+    :style="{ width: '100%' }"
+  >
+    {{ propertyCollisionMessage }}
+  </PlAlert>
+
+  <!-- Not a column mapping: it chooses how the mapped sequences are numbered, and the region
+       boundaries every downstream block reads follow from it. Kept apart from the mapping so it
+       does not read as one more column to assign. -->
+  <template v-if="isBareSet">
+    <PlSectionSeparator>Region annotation</PlSectionSeparator>
+    <div class="field-col">
+      <PlDropdown
+        :model-value="app.model.data.bareSet?.scheme"
+        :options="schemeOptions"
+        label="Numbering scheme"
+        required
+        @update:model-value="(v: string | undefined) => setBareScheme(v)"
+      />
+    </div>
+  </template>
+</template>
+
+<style scoped>
+.field-col {
+  display: grid;
+  grid-template-columns: 1fr;
+  gap: 12px;
+}
+</style>

From 2e68cd941318c782d7a5ccb069faf9d4e692cb7b Mon Sep 17 00:00:00 2001
From: Elena Erokhina <erohinaelena1@yandex.ru>
Date: Tue, 25 Aug 2026 18:21:16 +0200
Subject: [PATCH 08/13] MILAB-6720: key a collision verdict on the whole
 mapping

A collision is not "the id column repeats" -- it is an id repeated on rows whose
other mapped cells differ, so remapping a chain can turn a clean set into a
colliding one and back. Keying the verdict on the id alone meant a chain remap
left the previous verdict standing: a clean one enabled a mapping nothing had
checked and merged distinct rows into one record, and a stale colliding one kept
a valid mapping blocked until prerun caught up.

Prerun now states the identity and the mapped sequence columns it checked, and
one shared rule (collisionCheckKey) decides whether a verdict is about the
current mapping. The panel, the run gate and the mirror all use it, so they
cannot disagree about what "the same mapping" means. Exposed on the facade so the
tests state the verdict with the same rule the gate applies rather than
rebuilding it.
---
 .changeset/prerun-feedback-and-run-gate.md |  8 ++--
 block/src/block-extra.ts                   |  6 +++
 model/src/index.ts                         | 37 ++++++++++-------
 model/src/types.ts                         | 30 ++++++++++++--
 test/src/wf.test.ts                        | 48 ++++++++++++++--------
 ui/src/app.ts                              |  4 +-
 ui/src/pages/components/BareSetForm.vue    | 10 +++--
 workflow/src/bare-set-specs.lib.tengo      | 12 ++++++
 workflow/src/prerun.tpl.tengo              | 15 +++++--
 9 files changed, 121 insertions(+), 49 deletions(-)

diff --git a/.changeset/prerun-feedback-and-run-gate.md b/.changeset/prerun-feedback-and-run-gate.md
index 5171753..8e5828d 100644
--- a/.changeset/prerun-feedback-and-run-gate.md
+++ b/.changeset/prerun-feedback-and-run-gate.md
@@ -26,9 +26,11 @@ a file nobody had read yet, against headers it might not even contain.
   and the panel always warned, but the warning was only a warning, and a run driven through the API
   imported the merged set without complaint. Run is now refused both while the verdict is
   outstanding and when it reports a repeat, and the platform enforces it as well as the interface.
-- **The warning names the column it is about.** It used to quote the freshly picked column against
-  the previous one's verdict, so changing an offending column flashed the old accusation under the
-  new column's name. It also listed up to ten repeated values; it now lists three and a count,
+- **The warning names the mapping it is about.** It used to compare against the freshly picked
+  column while the verdict was still the previous mapping's, so changing an offending column flashed
+  the old accusation under the new selection. What a verdict covers is the id column *and* the
+  sequence columns, since a collision is a repeated id whose other mapped cells differ — keyed on
+  the id alone, a clean verdict outlived a remapped chain and the run gate accepted it. It also listed up to ten repeated values; it now lists three and a count,
   printed whole, since the id column can hold sequences and trimming those hides what tells them
   apart.
 - **Alert headings appear.** Four alerts passed their heading to a slot `PlAlert` does not have, so
diff --git a/block/src/block-extra.ts b/block/src/block-extra.ts
index fc00cdd..603d743 100644
--- a/block/src/block-extra.ts
+++ b/block/src/block-extra.ts
@@ -7,3 +7,9 @@
 // BlockPointer, platforma, or the block-named <PascalName>Block*
 // aliases — those names come from ./index and `export *` from this
 // file would shadow them.
+
+// The rule that decides whether a collision verdict is about the mapping now selected. Exposed
+// because the run gate depends on it and the block's own tests have to state the verdict the UI
+// would have mirrored in; a test that rebuilt the rule by hand would drift from the gate it means
+// to exercise.
+export { collisionCheckKey } from "@platforma-open/milaboratories.import-vdj.model";
diff --git a/model/src/index.ts b/model/src/index.ts
index a388035..3f9c454 100644
--- a/model/src/index.ts
+++ b/model/src/index.ts
@@ -6,8 +6,14 @@ import {
   TreeNodeAccessor,
 } from "@platforma-sdk/model";
 import { blockDataModel } from "./data-model";
-import type { BlockArgs, BlockData, ColumnDescription, ColumnProfile } from "./types";
-import { bareSetValid } from "./types";
+import type {
+  BareSetMapping,
+  BlockArgs,
+  BlockData,
+  ColumnDescription,
+  ColumnProfile,
+} from "./types";
+import { bareSetValid, collisionCheckKey } from "./types";
 
 export * from "./types";
 export { upgradeLegacyData } from "./data-model";
@@ -50,12 +56,12 @@ function withoutDatasetDoorMapping(args: BlockArgs): BlockArgs {
  * Phrased for the checks rather than for the id column, because it is about to cover more of them.
  */
 function requireCheckedColumns(data: BlockData): void {
-  const identity = data.bareSet?.identity;
-  if (identity === undefined || identity === "") return; // bareSetValid has already refused
+  const columns = collisionCheckKey(data.bareSet);
+  if (columns === undefined) return; // bareSetValid has already refused
   const checks = data.prerunChecks;
-  if (checks?.identity !== identity) throw new Error("Validating the selected columns");
+  if (checks?.columns !== columns) throw new Error("Validating the selected columns");
   if (checks.identityCollides) {
-    throw new Error(`"${identity}" repeats on rows that are not identical`);
+    throw new Error(`"${data.bareSet?.identity}" repeats on rows that are not identical`);
   }
 }
 
@@ -201,21 +207,22 @@ export const platforma = BlockModelV3.create(blockDataModel)
   )
 
   /**
-   * Identity values the file repeats on rows that are not identical, and the column they were
-   * found in.
+   * Identity values the file repeats on rows that are not identical, and the mapping they were
+   * found under.
    *
    * Reported as one value because the two must never be read from different runs: the panel used
-   * to quote `data.bareSet.identity`, which updates the instant a new column is picked, against
-   * collisions the previous column's run had produced — so changing an offending column flashed
-   * the old verdict under the new column's name.
+   * to compare against `data.bareSet`, which updates the instant a column is picked, while the
+   * collisions were still the previous mapping's — so changing an offending column flashed the old
+   * verdict under the new selection.
    *
    * Not `retentive`: this reports a defect, so a briefly absent verdict beats a stale one.
    */
   .output("identityCollisions", (ctx) => {
-    const identity = ctx.prerun
+    const mapping = ctx.prerun
       ?.resolve({ field: "collisionsFor", allowPermanentAbsence: true })
-      ?.getDataAsJsonOrUndefined<string>();
-    if (identity === undefined) return undefined;
+      ?.getDataAsJsonOrUndefined<Pick<BareSetMapping, "identity" | "sequences">>();
+    const key = collisionCheckKey(mapping);
+    if (key === undefined) return undefined;
 
     const raw = ctx.prerun
       ?.resolve({ field: "identityCollisions", allowPermanentAbsence: true })
@@ -227,7 +234,7 @@ export const platforma = BlockModelV3.create(blockDataModel)
       .split("\n")
       .map((l) => l.trim())
       .filter((l) => l.length > 0);
-    return { identity, values: lines.slice(1) };
+    return { key, values: lines.slice(1) };
   })
 
   .retentiveOutput("datasetOptions", (ctx) => {
diff --git a/model/src/types.ts b/model/src/types.ts
index b4f804d..8f08c99 100644
--- a/model/src/types.ts
+++ b/model/src/types.ts
@@ -248,9 +248,9 @@ export type BlockData = {
    * (SDK request "Simplify prerun checks").
    */
   prerunChecks?: {
-    /** The id column the verdict below was reached for. */
-    identity: string;
-    /** That column repeats on rows that are not identical, so two records would merge into one. */
+    /** The mapping the verdicts below were reached for — see {@link collisionCheckKey}. */
+    columns: string;
+    /** The id column repeats on rows whose other mapped cells differ, so two records would merge. */
     identityCollides: boolean;
   };
 
@@ -310,6 +310,30 @@ export function propertyCollisions(properties: ImportedProperty[]): Record<strin
   return Object.fromEntries(Object.entries(byToken).filter(([, hs]) => hs.length > 1));
 }
 
+/**
+ * What a collision verdict is about: the identity column *and* the sequence columns.
+ *
+ * The sequence columns are load-bearing, not incidental. A collision is not "the identity
+ * repeats" — it is an identity repeated on rows whose other mapped cells differ, so remapping a
+ * chain can turn a clean set into a colliding one and back (`bare-set-collisions.tpl.tengo`).
+ * Keying a verdict on the identity alone let a clean verdict outlive the mapping it was reached
+ * for, and the run gate would accept it: records merged.
+ *
+ * Sorted by slot so the key does not depend on the order the columns were picked in, and shared
+ * between the panel, the run gate and the mirror so all three agree on what "the same mapping"
+ * means.
+ */
+export function collisionCheckKey(
+  mapping: Pick<BareSetMapping, "identity" | "sequences"> | undefined,
+): string | undefined {
+  if (mapping === undefined || !mapping.identity) return undefined;
+  const mapped = Object.entries(mapping.sequences ?? {})
+    .filter(([, column]) => Boolean(column))
+    .sort(([a], [b]) => a.localeCompare(b))
+    .map(([slot, column]) => `${slot}=${column}`);
+  return [mapping.identity, ...mapped].join("\u0000");
+}
+
 /**
  * The mapping with everything that names a column dropped.
  *
diff --git a/test/src/wf.test.ts b/test/src/wf.test.ts
index 4a5aa9e..67dfcc8 100644
--- a/test/src/wf.test.ts
+++ b/test/src/wf.test.ts
@@ -19,7 +19,7 @@ import { blockSpec as sequencePropertiesSpec } from "@platforma-open/milaborator
 import type { PTableHandle } from "@platforma-sdk/model";
 import { createPlDataTableStateV2, uniquePlId } from "@platforma-sdk/model";
 import { awaitStableState, blockTest } from "@platforma-sdk/test";
-import { ImportVdjBlockPointer } from "this-block";
+import { collisionCheckKey, ImportVdjBlockPointer } from "this-block";
 
 /**
  * A complete `BlockData` from the fields a test actually cares about.
@@ -29,7 +29,9 @@ import { ImportVdjBlockPointer } from "this-block";
  * visibly `tableState`, which the stats table is built from.
  */
 function blockData(fields: Record<string, unknown>): Record<string, unknown> {
-  const bareSet = fields.bareSet as { identity?: string } | undefined;
+  const bareSet = fields.bareSet as
+    | { identity: string; sequences: Record<string, string> }
+    | undefined;
   return {
     defaultBlockLabel: "",
     customBlockLabel: "",
@@ -41,11 +43,12 @@ function blockData(fields: Record<string, unknown>): Record<string, unknown> {
     mixcrColumnsPresent: false,
     crColumnsPresent: false,
     airrColumnsPresent: false,
-    // `args` refuses a bare set whose id column prerun has not cleared, and the verdict reaches
-    // data through a UI watcher these tests never run. So stand in for it — clean unless the test
-    // passes its own `prerunChecks`, which `...fields` below lets it do.
-    ...(bareSet?.identity !== undefined && bareSet.identity !== ""
-      ? { prerunChecks: { identity: bareSet.identity, identityCollides: false } }
+    // `args` refuses a bare set whose columns prerun has not cleared, and the verdict reaches data
+    // through a UI watcher these tests never run. So stand in for it — clean unless the test passes
+    // its own `prerunChecks`, which `...fields` below lets it do. Keyed with the block's own rule,
+    // so a change to what a verdict covers fails here rather than silently passing.
+    ...(collisionCheckKey(bareSet) !== undefined
+      ? { prerunChecks: { columns: collisionCheckKey(bareSet), identityCollides: false } }
       : {}),
     ...fields,
   };
@@ -316,7 +319,13 @@ blockTest(
         },
         // What the UI mirrors in once prerun answers. Stated here because the mirror is a UI
         // watcher and these tests drive the block directly.
-        prerunChecks: { identity: "mAb ID", identityCollides: true },
+        prerunChecks: {
+          columns: collisionCheckKey({
+            identity: "mAb ID",
+            sequences: { IGHeavy: "VH", IGLight: "VL" },
+          }),
+          identityCollides: true,
+        },
       }),
     });
 
@@ -332,17 +341,20 @@ blockTest(
     expect(blockOverview.inputsValid).toBe(false);
     expect(blockOverview.canRun).toBe(false);
 
-    const wrapped = state.outputs?.identityCollisions as
-      | { value?: { identity: string; values: string[] } }
-      | { identity: string; values: string[] }
-      | undefined;
-    const found = (wrapped && "identity" in wrapped ? wrapped : wrapped?.value) as
-      | { identity: string; values: string[] }
-      | undefined;
+    type Verdict = { key: string; values: string[] };
+    const wrapped = state.outputs?.identityCollisions as { value?: Verdict } | Verdict | undefined;
+    const found = (wrapped && "key" in wrapped ? wrapped : wrapped?.value) as Verdict | undefined;
 
-    // The verdict names the column it is about. Without this the panel could quote the freshly
-    // picked column against the previous one's collisions, which is what it used to do.
-    expect(found?.identity).toBe("mAb ID");
+    // The verdict names the mapping it is about — the id column AND the sequence columns, since a
+    // collision is a repeated id whose other mapped cells differ. Keyed on the id alone, a clean
+    // verdict outlived a remapped chain and the run gate accepted it, merging records.
+    expect(found?.key).toBe(
+      collisionCheckKey({ identity: "mAb ID", sequences: { IGHeavy: "VH", IGLight: "VL" } }),
+    );
+    // Remapping a chain is a different question, so the old verdict must not answer it.
+    expect(found?.key).not.toBe(
+      collisionCheckKey({ identity: "mAb ID", sequences: { IGHeavy: "VH", IGLight: "VL2" } }),
+    );
     const collisions = found?.values ?? [];
 
     // The differing pair is reported, so the scientist is told which value to fix.
diff --git a/ui/src/app.ts b/ui/src/app.ts
index 4e034f2..ada4bd7 100644
--- a/ui/src/app.ts
+++ b/ui/src/app.ts
@@ -34,9 +34,9 @@ function syncPrerunChecks(model: AppModel) {
   watchEffect(() => {
     const found = model.outputs.identityCollisions;
     if (found === undefined) return;
-    const next = { identity: found.identity, identityCollides: found.values.length > 0 };
+    const next = { columns: found.key, identityCollides: found.values.length > 0 };
     const current = model.data.prerunChecks;
-    if (current?.identity === next.identity && current.identityCollides === next.identityCollides) {
+    if (current?.columns === next.columns && current.identityCollides === next.identityCollides) {
       return;
     }
     model.data.prerunChecks = next;
diff --git a/ui/src/pages/components/BareSetForm.vue b/ui/src/pages/components/BareSetForm.vue
index 36e4596..3ee93b1 100644
--- a/ui/src/pages/components/BareSetForm.vue
+++ b/ui/src/pages/components/BareSetForm.vue
@@ -18,6 +18,7 @@ import type {
 import {
   bareSetValid,
   CHAIN_SLOT_LABELS,
+  collisionCheckKey,
   CHAIN_SLOTS,
   propertyCollisions,
   SCHEME_LABELS,
@@ -185,13 +186,14 @@ const sequenceOptions = computed(() => {
  * to be about the column now selected. The record key is the identity's hash, so a repeat merges
  * two different records into one.
  *
- * The output carries the column it was computed for; anything else is a verdict about a column the
- * scientist has already moved on from.
+ * The output carries the mapping it was computed under — the identity and the sequence columns,
+ * since a collision depends on both. Anything else is a verdict about a mapping the scientist has
+ * already moved on from.
  */
 const identityCollisions = computed<string[]>(() => {
   const found = app.model.outputs.identityCollisions;
   if (found === undefined) return [];
-  if (found.identity !== app.model.data.bareSet?.identity) return [];
+  if (found.key !== collisionCheckKey(app.model.data.bareSet)) return [];
   return found.values;
 });
 
@@ -205,7 +207,7 @@ const identityCollisions = computed<string[]>(() => {
 const columnChecksPending = computed(() => {
   const bare = app.model.data.bareSet;
   if (bare === undefined || !bareSetValid(bare)) return false;
-  return app.model.data.prerunChecks?.identity !== bare.identity;
+  return app.model.data.prerunChecks?.columns !== collisionCheckKey(bare);
 });
 
 // Enough values to recognise the problem in the file, not enough to bury the sentence that says
diff --git a/workflow/src/bare-set-specs.lib.tengo b/workflow/src/bare-set-specs.lib.tengo
index a71d468..2a2e9ec 100644
--- a/workflow/src/bare-set-specs.lib.tengo
+++ b/workflow/src/bare-set-specs.lib.tengo
@@ -744,8 +744,20 @@ columnsBySource := func(chains, scheme, properties) {
 	}
 }
 
+// The mapped sequence columns, keyed by slot — the other half of what the collision check reads.
+// Emitted alongside a verdict so the panel and the run gate can tell a verdict about the current
+// mapping from one reached before a chain was remapped.
+mappedSequences := func(bare, mappedChains) {
+	mapped := {}
+	for chain in mappedChains {
+		mapped[chain] = bare.sequences[chain]
+	}
+	return mapped
+}
+
 export {
 	CHAINS: CHAINS,
+	mappedSequences: mappedSequences,
 	CHAIN_LABELS: CHAIN_LABELS,
 	REGIONS: REGIONS,
 	SCHEMES: SCHEMES,
diff --git a/workflow/src/prerun.tpl.tengo b/workflow/src/prerun.tpl.tengo
index 0447845..2358c9b 100644
--- a/workflow/src/prerun.tpl.tengo
+++ b/workflow/src/prerun.tpl.tengo
@@ -63,9 +63,13 @@ wf.body(func(args) {
 			}
 
 			if bare.identity != "" && len(mappedChains) > 0 {
-				// Which column the collisions below are about, so the panel cannot pair them with a
-				// different one the scientist has since picked.
-				outputs.collisionsFor = smart.createJsonResource(bare.identity)
+				// What the collisions below are about: the identity AND the sequence columns, because a
+				// collision is a repeated identity whose other mapped cells differ. Naming only the
+				// identity let a verdict outlive the mapping it was reached for.
+				outputs.collisionsFor = smart.createJsonResource({
+					identity: bare.identity,
+					sequences: specs.mappedSequences(bare, mappedChains)
+				})
 				outputs.identityCollisions = render.create(collisionsTpl, {
 					dataset: {
 						spec: {
@@ -121,7 +125,10 @@ wf.body(func(args) {
 			return {
 				outputs: {
 					identityCollisions: collisions,
-					collisionsFor: smart.createJsonResource(bare.identity)
+					collisionsFor: smart.createJsonResource({
+						identity: bare.identity,
+						sequences: specs.mappedSequences(bare, mappedChains)
+					})
 				},
 				exports: {}
 			}

From f3512f615843360274e05ae077467012016a6b84 Mon Sep 17 00:00:00 2001
From: Elena Erokhina <erohinaelena1@yandex.ru>
Date: Wed, 26 Aug 2026 14:01:40 +0200
Subject: [PATCH 09/13] MILAB-6720: announce the column inference on the
 dataset door too

The dataset door had the same blind window as the file door: prerun infers the
selected dataset's columns and nothing said so, while datasetColumns and
validationResult are retentive and went on answering with the previous dataset --
so the panel could offer the last dataset's headers, and show its verdict, as
though they were this one's.

Prerun now states which dataset and format an inference was run for, paired with
the headers the same way the file door pairs its profile. The panel announces the
wait, withholds the custom mapping until the headers belong to the current
selection, and no longer shows a format verdict reached for a different dataset.

Not raised on the bare-set path, where prerun answers with collisions and never
produces columns at all.
---
 .changeset/prerun-feedback-and-run-gate.md | 11 +++++----
 model/src/index.ts                         | 22 ++++++++++++++++-
 ui/src/pages/MainPage.vue                  | 28 ++++++++++++++++++++--
 workflow/src/prerun.tpl.tengo              |  9 ++++++-
 4 files changed, 61 insertions(+), 9 deletions(-)

diff --git a/.changeset/prerun-feedback-and-run-gate.md b/.changeset/prerun-feedback-and-run-gate.md
index 8e5828d..c6c4c9e 100644
--- a/.changeset/prerun-feedback-and-run-gate.md
+++ b/.changeset/prerun-feedback-and-run-gate.md
@@ -13,11 +13,12 @@ answering with the *previous* file's headers as though nothing had happened. A m
 passed every check against that previous file also still counted as valid, so Run stayed live over
 a file nobody had read yet, against headers it might not even contain.
 
-- **The wait is announced.** Prerun now states which file a profile was taken from, and the model
-  pairs the two so the reported file cannot get ahead of the profile. The panel announces the scan
-  and withholds the mapping until the columns on offer are really this file's. Keyed to the file
-  rather than to "prerun is busy", because prerun also re-runs on every mapping edit to re-check
-  the id column. The import itself now shows the block's loader, which it never did.
+- **The wait is announced, on both doors.** Prerun now states which file a profile was taken from,
+  and which dataset and format an inference was run for; the model pairs each with its result so the
+  two cannot get out of step. The panel announces the wait and withholds the mapping until the
+  columns on offer really belong to what is selected. Keyed to the input rather than to "prerun is
+  busy", because prerun also re-runs on every mapping edit to re-check the id column. The import
+  itself now shows the block's loader, which it never did.
 - **Loading a second file disables Run.** Picking a different file drops the parts of the mapping
   that name columns, keeping the receptor declaration and the numbering scheme, which describe the
   data rather than one file. Re-picking the same file is not a swap and keeps the mapping.
diff --git a/model/src/index.ts b/model/src/index.ts
index 3f9c454..15f0835 100644
--- a/model/src/index.ts
+++ b/model/src/index.ts
@@ -1,4 +1,4 @@
-import type { InferOutputsType, PColumnKey, PColumnValue } from "@platforma-sdk/model";
+import type { InferOutputsType, PColumnKey, PColumnValue, PlRef } from "@platforma-sdk/model";
 import {
   BlockModelV3,
   DataColumn,
@@ -12,6 +12,7 @@ import type {
   BlockData,
   ColumnDescription,
   ColumnProfile,
+  ImportFormat,
 } from "./types";
 import { bareSetValid, collisionCheckKey } from "./types";
 
@@ -334,6 +335,25 @@ export const platforma = BlockModelV3.create(blockDataModel)
    */
   .output("isRunning", (ctx) => ctx.outputs?.getIsReadyOrError() === false)
 
+  /**
+   * Which dataset and format the column inference on screen was run for.
+   *
+   * The dataset door's twin of {@link profiledSampleId}, and paired the same way: the read goes
+   * unstable while the new inference is running, so `retentive` keeps reporting the previous
+   * dataset until the new headers land. The panel compares it with the current selection to tell
+   * "these are this dataset's columns" from "these are the last one's".
+   *
+   * Absent on the bare-set path, where prerun answers with collisions instead of columns.
+   */
+  .retentiveOutput("inferredFor", (ctx) => {
+    const headers = ctx.prerun?.resolve({ field: "headerColumns", allowPermanentAbsence: true });
+    if (headers === undefined) return undefined;
+    if (!headers.getIsReadyOrError()) return undefined;
+    return ctx.prerun
+      ?.resolve({ field: "inferredFor", allowPermanentAbsence: true })
+      ?.getDataAsJsonOrUndefined<{ datasetRef?: PlRef; format?: ImportFormat }>();
+  })
+
   /** Headers of the dataset selected from the pool. Absent on the file door. */
   .retentiveOutput("datasetColumns", (ctx) => {
     const headers = ctx.prerun
diff --git a/ui/src/pages/MainPage.vue b/ui/src/pages/MainPage.vue
index 2e881a4..b0b755c 100644
--- a/ui/src/pages/MainPage.vue
+++ b/ui/src/pages/MainPage.vue
@@ -229,6 +229,26 @@ const fileScanning = computed(() => {
   return app.model.outputs.profiledSampleId !== file.sampleId;
 });
 
+/**
+ * The selected dataset's columns are still being inferred — the same blind window as
+ * {@link fileScanning}, on the other door, and with the same hazard: `datasetColumns` and
+ * `validationResult` are retentive, so until the new inference lands the panel offers the previous
+ * dataset's headers and can still be showing its verdict.
+ *
+ * Waits for a format, because that is what the inference is asked about and until one is chosen
+ * there is nothing to say. Not raised on the bare-set path, where prerun answers with collisions
+ * and never produces columns at all.
+ */
+const datasetScanning = computed(() => {
+  if (loadFromFile.value) return false;
+  const ref = app.model.data.datasetRef;
+  if (ref === undefined || app.model.data.format === undefined) return false;
+  if (app.model.data.bareSet !== undefined) return false;
+  const inferred = app.model.outputs.inferredFor;
+  if (inferred?.datasetRef === undefined) return true;
+  return !plRefsEqual(inferred.datasetRef, ref) || inferred.format !== app.model.data.format;
+});
+
 async function setFile(handle: ImportFileHandle | undefined) {
   fileSourceError.value = "";
   const a = app.model.data;
@@ -519,8 +539,12 @@ watch(
           required
         />
 
+        <PlAlert v-if="datasetScanning" type="info" :style="{ width: '100%' }">
+          Validating the selected columns. This can take a moment, please wait...
+        </PlAlert>
+
         <PlAlert
-          v-if="validationMessage"
+          v-if="!datasetScanning && validationMessage"
           type="warn"
           :label="`Invalid ${formatLabel(validationResult?.format)} dataset`"
           :style="{ width: '100%' }"
@@ -543,7 +567,7 @@ watch(
           required
         />
 
-        <template v-if="app.model.data.format === 'custom'">
+        <template v-if="app.model.data.format === 'custom' && !datasetScanning">
           <PlSectionSeparator>Required columns</PlSectionSeparator>
           <div class="field-col">
             <PlDropdown
diff --git a/workflow/src/prerun.tpl.tengo b/workflow/src/prerun.tpl.tengo
index 2358c9b..24435eb 100644
--- a/workflow/src/prerun.tpl.tengo
+++ b/workflow/src/prerun.tpl.tengo
@@ -150,7 +150,14 @@ wf.body(func(args) {
 		outputs: {
 			columnsInfo: columnsInfo,
 			columnDescriptions: columnDescriptions,
-			headerColumns: headerColumns
+			headerColumns: headerColumns,
+			// What the inference above was about. Same reason as the file door's profiledSampleId:
+			// the model cannot ask which args a staging context was built with, so the panel cannot
+			// otherwise tell this dataset's columns from the last one's, still on screen.
+			inferredFor: smart.createJsonResource({
+				datasetRef: args.datasetRef,
+				format: args.format
+			})
 		},
 		exports: {}
 	}

From 9216165d66cd3bb145487aa9d467411f188cbb95 Mon Sep 17 00:00:00 2001
From: Elena Erokhina <erohinaelena1@yandex.ru>
Date: Wed, 26 Aug 2026 15:46:37 +0200
Subject: [PATCH 10/13] MILAB-6720: show the column list only once it has
 columns

"The following columns will be imported:" appeared as soon as a dataset was
picked, with nothing under it: the section was gated on the output existing, and
an empty array exists. Before a format is chosen the inference has nothing to
report, so the heading claimed the import would emit no columns. The list is also
retentive, so it outlived a dataset switch and listed the previous dataset's
columns; it now waits for the door, the format and the current inference.

Also moves the two verdicts about the selected columns below the chain control.
Sitting between the format and the chains, they pushed apart two controls that
belong together and read as something to fill in rather than as a verdict on what
was already filled.
---
 .changeset/prerun-feedback-and-run-gate.md |  7 +++-
 ui/src/pages/MainPage.vue                  | 43 ++++++++++++++--------
 2 files changed, 34 insertions(+), 16 deletions(-)

diff --git a/.changeset/prerun-feedback-and-run-gate.md b/.changeset/prerun-feedback-and-run-gate.md
index c6c4c9e..e847fcf 100644
--- a/.changeset/prerun-feedback-and-run-gate.md
+++ b/.changeset/prerun-feedback-and-run-gate.md
@@ -18,7 +18,12 @@ a file nobody had read yet, against headers it might not even contain.
   two cannot get out of step. The panel announces the wait and withholds the mapping until the
   columns on offer really belong to what is selected. Keyed to the input rather than to "prerun is
   busy", because prerun also re-runs on every mapping edit to re-check the id column. The import
-  itself now shows the block's loader, which it never did.
+  itself now shows the block's loader, which it never did. The verdict about the selected columns
+  now sits below the controls it is about, rather than between them.
+- **The column list waits until it has something to list.** "The following columns will be
+  imported:" appeared with nothing under it as soon as a dataset was picked, before any format was,
+  which read as an import that would emit nothing. It also outlived a dataset switch, listing the
+  previous dataset's columns.
 - **Loading a second file disables Run.** Picking a different file drops the parts of the mapping
   that name columns, keeping the receptor declaration and the numbering scheme, which describe the
   data rather than one file. Re-picking the same file is not a swap and keeps the mapping.
diff --git a/ui/src/pages/MainPage.vue b/ui/src/pages/MainPage.vue
index b0b755c..82bebcc 100644
--- a/ui/src/pages/MainPage.vue
+++ b/ui/src/pages/MainPage.vue
@@ -249,6 +249,19 @@ const datasetScanning = computed(() => {
   return !plRefsEqual(inferred.datasetRef, ref) || inferred.format !== app.model.data.format;
 });
 
+/**
+ * The columns the import will emit, once they are known for what is selected now.
+ *
+ * Only the dataset door produces them, and only under a chosen format, and the output is retentive
+ * — so without these guards the list showed the previous dataset's columns after a switch, and its
+ * heading with nothing under it before a format was picked, which read as "this import emits
+ * nothing".
+ */
+const columnDescriptions = computed(() => {
+  if (loadFromFile.value || app.model.data.format === undefined || datasetScanning.value) return [];
+  return app.model.outputs.columnDescriptions ?? [];
+});
+
 async function setFile(handle: ImportFileHandle | undefined) {
   fileSourceError.value = "";
   const a = app.model.data;
@@ -539,19 +552,6 @@ watch(
           required
         />
 
-        <PlAlert v-if="datasetScanning" type="info" :style="{ width: '100%' }">
-          Validating the selected columns. This can take a moment, please wait...
-        </PlAlert>
-
-        <PlAlert
-          v-if="!datasetScanning && validationMessage"
-          type="warn"
-          :label="`Invalid ${formatLabel(validationResult?.format)} dataset`"
-          :style="{ width: '100%' }"
-        >
-          {{ validationMessage }}
-        </PlAlert>
-
         <PlDropdownMulti
           v-if="!isSingleCell"
           v-model="app.model.data.chains"
@@ -567,6 +567,19 @@ watch(
           required
         />
 
+        <PlAlert v-if="datasetScanning" type="info" :style="{ width: '100%' }">
+          Validating the selected columns. This can take a moment, please wait...
+        </PlAlert>
+
+        <PlAlert
+          v-if="!datasetScanning && validationMessage"
+          type="warn"
+          :label="`Invalid ${formatLabel(validationResult?.format)} dataset`"
+          :style="{ width: '100%' }"
+        >
+          {{ validationMessage }}
+        </PlAlert>
+
         <template v-if="app.model.data.format === 'custom' && !datasetScanning">
           <PlSectionSeparator>Required columns</PlSectionSeparator>
           <div class="field-col">
@@ -689,11 +702,11 @@ watch(
         </template>
       </template>
 
-      <template v-if="app.model.outputs.columnDescriptions">
+      <template v-if="columnDescriptions.length > 0">
         <PlSectionSeparator>Columns</PlSectionSeparator>
         The following columns will be imported:
         <PlElementList
-          v-model:items="app.model.outputs.columnDescriptions"
+          :items="columnDescriptions"
           disable-removing
           disable-dragging
           disable-pinning

From 9435b3cf5116ae4a5070166a65473de0648ba5fd Mon Sep 17 00:00:00 2001
From: Elena Erokhina <erohinaelena1@yandex.ru>
Date: Wed, 26 Aug 2026 15:56:02 +0200
Subject: [PATCH 11/13] MILAB-6720: cut the comments in the model and the UI
 back

The doc blocks this branch added were arguing their case at length where naming
the fact was enough. Kept: what the code cannot say -- that getIsReadyOrError
marks a read unstable and so pairs a retentive value with its subject, that a
signal is keyed to the input rather than to prerun being busy, what makes the
mirror in prerunChecks safe, and why the collision values are printed whole.
Dropped: the restatements of what the code does, and the histories of what it
used to do.

Also removes a stale doc block stranded above the fileImports output by an
earlier reorder: it documented identityCollisions, which carries its own doc
further down, and its claim that the verdict is never mirrored into state from a
UI watcher is now the opposite of what this branch deliberately does.
---
 model/src/index.ts                      | 39 +++++-------------------
 model/src/types.ts                      | 40 ++++++-------------------
 ui/src/app.ts                           | 23 ++++++--------
 ui/src/pages/MainPage.vue               | 26 +++++++---------
 ui/src/pages/components/BareSetForm.vue | 35 +++++++---------------
 5 files changed, 46 insertions(+), 117 deletions(-)

diff --git a/model/src/index.ts b/model/src/index.ts
index 15f0835..0795a34 100644
--- a/model/src/index.ts
+++ b/model/src/index.ts
@@ -46,15 +46,9 @@ function withoutDatasetDoorMapping(args: BlockArgs): BlockArgs {
 }
 
 /**
- * Refuse a bare set whose mapped columns prerun has not cleared.
- *
- * The checks themselves cannot live here — they read the whole file — so this reads the verdicts
- * the UI mirrored into `data.prerunChecks`, and refuses both a verdict that reports a defect and
- * the absence of one for the columns currently selected. Refusing the absence is the point: the
- * record key is the identity's hash, so starting a run before the answer is in is exactly how two
+ * Refuse a bare set whose mapped columns prerun has not cleared — including when there is no
+ * verdict yet. The record key is the identity's hash, so running before the answer is in is how two
  * different records silently become one.
- *
- * Phrased for the checks rather than for the id column, because it is about to cover more of them.
  */
 function requireCheckedColumns(data: BlockData): void {
   const columns = collisionCheckKey(data.bareSet);
@@ -173,15 +167,6 @@ export const platforma = BlockModelV3.create(blockDataModel)
     bareSet: data.bareSet,
   }))
 
-  /**
-   * Identity values that appear on rows which are not identical to each other.
-   *
-   * Not `retentive`: this gates the run, so a stale value is worse than a briefly absent one.
-   *
-   * Read straight from prerun here, and *not* mirrored into `uiState` from a UI watcher. That
-   * mirror is what the format-validity flags do, and it is a hairpin — an output written back
-   * into state that a derivation then reads. It survives on one client and races on two.
-   */
   /**
    * Drives the upload for a directly-loaded file.
    *
@@ -208,13 +193,8 @@ export const platforma = BlockModelV3.create(blockDataModel)
   )
 
   /**
-   * Identity values the file repeats on rows that are not identical, and the mapping they were
-   * found under.
-   *
-   * Reported as one value because the two must never be read from different runs: the panel used
-   * to compare against `data.bareSet`, which updates the instant a column is picked, while the
-   * collisions were still the previous mapping's — so changing an offending column flashed the old
-   * verdict under the new selection.
+   * Identity values repeated on rows that are not identical, with the mapping they were found
+   * under. One value, so the two can never be read from different runs.
    *
    * Not `retentive`: this reports a defect, so a briefly absent verdict beats a stale one.
    */
@@ -336,14 +316,9 @@ export const platforma = BlockModelV3.create(blockDataModel)
   .output("isRunning", (ctx) => ctx.outputs?.getIsReadyOrError() === false)
 
   /**
-   * Which dataset and format the column inference on screen was run for.
-   *
-   * The dataset door's twin of {@link profiledSampleId}, and paired the same way: the read goes
-   * unstable while the new inference is running, so `retentive` keeps reporting the previous
-   * dataset until the new headers land. The panel compares it with the current selection to tell
-   * "these are this dataset's columns" from "these are the last one's".
-   *
-   * Absent on the bare-set path, where prerun answers with collisions instead of columns.
+   * Which dataset and format the inference on screen was run for — the dataset door's twin of
+   * {@link profiledSampleId}, paired with the headers the same way. Absent on the bare-set path,
+   * where prerun answers with collisions instead of columns.
    */
   .retentiveOutput("inferredFor", (ctx) => {
     const headers = ctx.prerun?.resolve({ field: "headerColumns", allowPermanentAbsence: true });
diff --git a/model/src/types.ts b/model/src/types.ts
index 8f08c99..86b8b99 100644
--- a/model/src/types.ts
+++ b/model/src/types.ts
@@ -230,22 +230,11 @@ export type BlockData = {
   bareSet?: BareSetMapping;
 
   /**
-   * Verdicts prerun reached, mirrored here so `args` can refuse a run on them.
+   * What prerun found, kept here so the args projection — which sees only `data` — can gate the run
+   * on it. Written by the UI (`ui/src/app.ts`).
    *
-   * `args` is a pure function of this data and cannot read prerun, and unlike the column mapping
-   * there is no gesture at which a verdict could be snapshotted: the scientist picks a column, and
-   * only then does the check discover whether it is sound. So the UI mirrors it in
-   * (`ui/src/app.ts`) — the hairpin the harness warns about, made safe by two rules every entry
-   * here must follow:
-   *
-   * - it carries what it is *about*, so a verdict for something nobody has selected any more is
-   *   ignored rather than applied;
-   * - it is cleared when the source changes, so a verdict cannot survive into a different file.
-   *
-   * Together those make the write idempotent — every client derives the same value from the same
-   * output, so concurrent writes agree instead of racing. Add further checks as sibling fields
-   * following the same two rules. The whole field goes away once args can read prerun directly
-   * (SDK request "Simplify prerun checks").
+   * Every entry carries what it is *about* and is cleared when the source changes, so a verdict for
+   * something no longer selected is ignored rather than applied. Add further checks the same way.
    */
   prerunChecks?: {
     /** The mapping the verdicts below were reached for — see {@link collisionCheckKey}. */
@@ -311,17 +300,9 @@ export function propertyCollisions(properties: ImportedProperty[]): Record<strin
 }
 
 /**
- * What a collision verdict is about: the identity column *and* the sequence columns.
- *
- * The sequence columns are load-bearing, not incidental. A collision is not "the identity
- * repeats" — it is an identity repeated on rows whose other mapped cells differ, so remapping a
- * chain can turn a clean set into a colliding one and back (`bare-set-collisions.tpl.tengo`).
- * Keying a verdict on the identity alone let a clean verdict outlive the mapping it was reached
- * for, and the run gate would accept it: records merged.
- *
- * Sorted by slot so the key does not depend on the order the columns were picked in, and shared
- * between the panel, the run gate and the mirror so all three agree on what "the same mapping"
- * means.
+ * What a collision verdict is about. A collision is an identity repeated on rows whose *other
+ * mapped cells* differ, so the sequence columns are part of the question and remapping a chain
+ * invalidates the answer. Sorted, so the key does not depend on the order columns were picked in.
  */
 export function collisionCheckKey(
   mapping: Pick<BareSetMapping, "identity" | "sequences"> | undefined,
@@ -335,11 +316,8 @@ export function collisionCheckKey(
 }
 
 /**
- * The mapping with everything that names a column dropped.
- *
- * The receptor declaration and the numbering scheme describe the biology and outlive any one file;
- * the identity column, the sequence columns and the accepted properties name headers, and mean
- * nothing once the headers change.
+ * The mapping with everything that names a column dropped. The receptor declaration and the
+ * numbering scheme describe the biology and outlive any one file; the column names do not.
  */
 export function forgetMappedColumns(bare: BareSetMapping | undefined): BareSetMapping | undefined {
   if (bare === undefined) return undefined;
diff --git a/ui/src/app.ts b/ui/src/app.ts
index ada4bd7..683c7dc 100644
--- a/ui/src/app.ts
+++ b/ui/src/app.ts
@@ -7,8 +7,8 @@ export const sdkPlugin = defineAppV3(platforma, (app) => {
   syncPrerunChecks(app.model);
 
   return {
-    // Main run only: this loader covers the whole block, and prerun re-runs while the settings
-    // panel is being edited. The file scan is announced inside the panel instead.
+    // Main run only: the loader covers the whole block, and prerun re-runs while the settings
+    // panel is being edited. Prerun waits are announced inside the panel instead.
     progress: () => app.model.outputs.isRunning,
     routes: {
       "/": () => MainPage,
@@ -21,16 +21,13 @@ export const useApp = sdkPlugin.useApp;
 type AppModel = ReturnType<typeof useApp>["model"];
 
 /**
- * Carry prerun's verdicts into `data` so the args projection can refuse the run on them.
- *
- * This is the hairpin — an output written back into the state a derivation reads — and it is here
- * because nothing else can be: args sees only `data`, and no user gesture can establish whether a
- * column the scientist just picked repeats. The contract that keeps it safe is stated on
- * `BlockData.prerunChecks`; both halves below are that contract.
+ * Carry prerun's verdicts into `data` so the args projection can refuse the run on them. An output
+ * written back into state a derivation reads — the hairpin — kept safe by the contract on
+ * `BlockData.prerunChecks`, which the two halves below are.
  */
 function syncPrerunChecks(model: AppModel) {
-  // Idempotent by construction: every client derives the same verdict from the same output, and
-  // the equality guard means agreeing clients do not write at all.
+  // Idempotent: every client derives the same verdict from the same output, and the guard means
+  // agreeing clients do not write at all.
   watchEffect(() => {
     const found = model.outputs.identityCollisions;
     if (found === undefined) return;
@@ -42,10 +39,8 @@ function syncPrerunChecks(model: AppModel) {
     model.data.prerunChecks = next;
   });
 
-  // A verdict cannot outlive the file or dataset it was reached for — the same column name in a
-  // different file is a different column, and one that repeated there may be sound here. Watching
-  // the primitives rather than the refs so a server patch swapping the data object does not clear
-  // it spuriously.
+  // A verdict cannot outlive the file or dataset it was reached for. Watching primitives, not the
+  // refs, so a server patch swapping the data object does not clear it spuriously.
   watch(
     () => [
       model.data.fileSource?.sampleId,
diff --git a/ui/src/pages/MainPage.vue b/ui/src/pages/MainPage.vue
index 82bebcc..ccaef08 100644
--- a/ui/src/pages/MainPage.vue
+++ b/ui/src/pages/MainPage.vue
@@ -230,14 +230,12 @@ const fileScanning = computed(() => {
 });
 
 /**
- * The selected dataset's columns are still being inferred — the same blind window as
- * {@link fileScanning}, on the other door, and with the same hazard: `datasetColumns` and
- * `validationResult` are retentive, so until the new inference lands the panel offers the previous
- * dataset's headers and can still be showing its verdict.
+ * The selected dataset's columns are still being inferred — {@link fileScanning} for the other
+ * door. `datasetColumns` and `validationResult` are retentive, so until then the panel would offer
+ * the previous dataset's headers and verdict.
  *
- * Waits for a format, because that is what the inference is asked about and until one is chosen
- * there is nothing to say. Not raised on the bare-set path, where prerun answers with collisions
- * and never produces columns at all.
+ * Needs a format, which is what the inference is asked about. Not raised on the bare-set path,
+ * where prerun answers with collisions and never produces columns.
  */
 const datasetScanning = computed(() => {
   if (loadFromFile.value) return false;
@@ -250,12 +248,9 @@ const datasetScanning = computed(() => {
 });
 
 /**
- * The columns the import will emit, once they are known for what is selected now.
- *
- * Only the dataset door produces them, and only under a chosen format, and the output is retentive
- * — so without these guards the list showed the previous dataset's columns after a switch, and its
- * heading with nothing under it before a format was picked, which read as "this import emits
- * nothing".
+ * The columns the import will emit, once known for what is selected now. Only the dataset door
+ * produces them, only under a chosen format, and the output is retentive — drop any guard and the
+ * list shows the previous dataset's columns, or a heading with nothing under it.
  */
 const columnDescriptions = computed(() => {
   if (loadFromFile.value || app.model.data.format === undefined || datasetScanning.value) return [];
@@ -293,9 +288,8 @@ async function setFile(handle: ImportFileHandle | undefined) {
   a.datasetRef = undefined;
 
   // This is what disables Run: a mapping that passed against the last file still satisfies
-  // `bareSetValid`, so otherwise the block stays runnable over a file nothing has read yet.
-  // Cleared on the gesture because `args` sees only `data` and cannot consult prerun.
-  // Re-picking the same file is not a swap — the dialog is also how a file gets re-read.
+  // `bareSetValid`. Re-picking the same file is not a swap — the dialog is also how a file gets
+  // re-read.
   if (previous?.handle !== handle) a.bareSet = forgetMappedColumns(a.bareSet);
 }
 
diff --git a/ui/src/pages/components/BareSetForm.vue b/ui/src/pages/components/BareSetForm.vue
index 3ee93b1..857dc3a 100644
--- a/ui/src/pages/components/BareSetForm.vue
+++ b/ui/src/pages/components/BareSetForm.vue
@@ -1,11 +1,9 @@
 <script setup lang="ts">
 /**
- * Mapping a file of bare sequences onto records: which column identifies a record, which chains
- * are being imported, which column carries each one, what else to keep, and how to number it.
+ * Mapping a file of bare sequences onto records: the id column, the chains, the column carrying
+ * each one, what else to keep, and how to number it — with the checks that gate them.
  *
- * A form for one shape of input, kept whole — its dropdowns, the checks that gate them and the
- * numbering that follows from them are one subject, and they were the larger half of MainPage.
- * The parent decides *whether* this shape is being mapped at all (a file is loaded and its columns
+ * The parent decides whether this shape is being mapped at all (a file is loaded and its columns
  * are known); everything from there down is here.
  */
 import type {
@@ -155,10 +153,7 @@ function setBareScheme(value: string | undefined) {
   a.bareSet = { ...a.bareSet, scheme: value as BareSetScheme };
 }
 
-/**
- * A column has been assigned. Not `bareSet !== undefined`: picking a new file keeps the receptor
- * declaration and the scheme (see forgetMappedColumns), so the object outlives the mapping.
- */
+/** A column has been assigned. Not `bareSet !== undefined` — that outlives the mapping it held. */
 const isBareSet = computed(() => {
   const bare = app.model.data.bareSet;
   if (bare === undefined) return false;
@@ -182,13 +177,9 @@ const sequenceOptions = computed(() => {
 });
 
 /**
- * Identity values the file repeats on rows that are not identical — but only once they are known
- * to be about the column now selected. The record key is the identity's hash, so a repeat merges
- * two different records into one.
- *
- * The output carries the mapping it was computed under — the identity and the sequence columns,
- * since a collision depends on both. Anything else is a verdict about a mapping the scientist has
- * already moved on from.
+ * Identity values repeated on rows that are not identical — the record key is the identity's hash,
+ * so a repeat merges two records into one. Empty unless the verdict is about the mapping now
+ * selected; anything else is about one the scientist has moved on from.
  */
 const identityCollisions = computed<string[]>(() => {
   const found = app.model.outputs.identityCollisions;
@@ -198,11 +189,8 @@ const identityCollisions = computed<string[]>(() => {
 });
 
 /**
- * The mapping is finished but prerun has not yet cleared the columns it names.
- *
- * Run is disabled meanwhile (the args projection refuses unchecked columns), and this block's
- * layout does not surface the args error, so the reason has to be said here. Named and worded for
- * the checks in general — the id column's uniqueness is the only one today.
+ * The mapping is finished but prerun has not yet cleared the columns it names. Run is disabled
+ * meanwhile and this layout does not surface the args error, so the reason is said here.
  */
 const columnChecksPending = computed(() => {
   const bare = app.model.data.bareSet;
@@ -210,9 +198,8 @@ const columnChecksPending = computed(() => {
   return app.model.data.prerunChecks?.columns !== collisionCheckKey(bare);
 });
 
-// Enough values to recognise the problem in the file, not enough to bury the sentence that says
-// what to do about it. Printed whole and left to scroll: the id column can hold sequences, and
-// trimming those removes the very part that tells two of them apart.
+// Enough to recognise the problem, not enough to bury the advice. Printed whole and left to
+// scroll: the id column can hold sequences, and trimming those hides what tells them apart.
 const COLLISIONS_SHOWN = 3;
 
 const identityCollisionMessage = computed(() => {

From e6c5084af9aa137339302746133b22d0f842bd69 Mon Sep 17 00:00:00 2001
From: Elena Erokhina <erohinaelena1@yandex.ru>
Date: Wed, 26 Aug 2026 15:58:14 +0200
Subject: [PATCH 12/13] MILAB-6720: drop the doc block above projectArgs

What an args projection is needs no explaining -- every block has one.

Keeps the one fact it carried that the code cannot state: `chains` is passed
through in the order the user picked, not sorted. Moved to the field it is about.
---
 model/src/index.ts | 11 ++---------
 1 file changed, 2 insertions(+), 9 deletions(-)

diff --git a/model/src/index.ts b/model/src/index.ts
index 0795a34..84c6565 100644
--- a/model/src/index.ts
+++ b/model/src/index.ts
@@ -60,15 +60,6 @@ function requireCheckedColumns(data: BlockData): void {
   }
 }
 
-/**
- * The workflow's view of the block, and the only place validation lives.
- *
- * Three jobs, in order: refuse what cannot run (by throwing), drop the door that is not in
- * use, and drop the fields the chosen path never reads. What it deliberately does NOT do is
- * reorder `chains`: canonicalising a set the user picked in their own order would change the
- * args of every project already on disk, and buys only the rare case of someone re-picking the
- * same chains in a different order.
- */
 function projectArgs(data: BlockData): BlockArgs {
   const { datasetRef, format, chains, customMapping, primaryCountType, fileSource } = data;
 
@@ -82,6 +73,8 @@ function projectArgs(data: BlockData): BlockArgs {
     datasetRef,
     fileSource,
     format,
+    // Not sorted: canonicalising an order the user chose would change the args of every project
+    // already on disk, to buy the rare re-pick of the same chains in a different order.
     chains,
     customMapping,
     primaryCountType,

From 252466ebec1c82c36e3a77a740f1f7d8f3f5a605 Mon Sep 17 00:00:00 2001
From: Elena Erokhina <erohinaelena1@yandex.ru>
Date: Wed, 26 Aug 2026 16:01:24 +0200
Subject: [PATCH 13/13] MILAB-6720: drop the upgradeLegacyData doc block

Nothing is reshaped, so there is nothing to explain -- the signature says which
two buckets go in and what comes out. The one non-obvious fact about the upgrade,
that V1's uiState fields are all optional on disk and so need explicit defaults,
is already stated on viewStateDefaults.

Its claim about V1's `loadFromFile` was also false. The file door, that flag, its
removal and the V3 migration were all in PR #47 and released together (7023012),
so no released V1 version ever had the flag and no project on disk can carry it.
---
 model/src/data-model.ts | 13 -------------
 1 file changed, 13 deletions(-)

diff --git a/model/src/data-model.ts b/model/src/data-model.ts
index ab96a0e..61446a3 100644
--- a/model/src/data-model.ts
+++ b/model/src/data-model.ts
@@ -22,19 +22,6 @@ const viewStateDefaults = () => ({
   airrColumnsPresent: false,
 });
 
-/**
- * V1 kept the scientist's edits in two buckets — `args` and `uiState`. V3 keeps them in one,
- * and derives what the workflow sees. This upgrade runs once per project, the first time a
- * project saved under V1 is opened.
- *
- * The mapping is field-for-field: nothing is reshaped, because nothing in V1's shape was bent
- * to dodge the stale gate. What changes is where the fields *go afterwards* — the labels and
- * the secondary count type stop being projected into args, which is the whole point of the
- * migration for this block. See `index.ts`.
- *
- * V1's `loadFromFile` is dropped rather than carried: the panel now derives which door it is
- * showing from whether a file is loaded, so a stored flag could only disagree with the data.
- */
 export function upgradeLegacyData({
   args,
   uiState,