@platforma-open/milaboratories.3d-structure-prediction.workflow 1.0.4 → 1.0.6

package/.turbo/turbo-build.log

@@ -1,17 +1,21 @@
  WARN  Issue while reading "/home/runner/work/3d-structure-prediction/3d-structure-prediction/.npmrc". Failed to replace env in config: ${NPMJS_TOKEN}
 
-> @platforma-open/milaboratories.3d-structure-prediction.workflow@1.0.4 build /home/runner/work/3d-structure-prediction/3d-structure-prediction/workflow
+> @platforma-open/milaboratories.3d-structure-prediction.workflow@1.0.6 build /home/runner/work/3d-structure-prediction/3d-structure-prediction/workflow
 > shx rm -rf dist && pl-tengo check && pl-tengo build
 
   info: Skipping unknown file type: wf.test.ts
 Processing "src/build-pdbs-map.tpl.tengo"...
 Processing "src/main.tpl.tengo"...
 Processing "src/predict-batch.tpl.tengo"...
+Processing "src/prerun.tpl.tengo"...
+Processing "src/structure-cols-conv.lib.tengo"...
 No syntax errors found.
   info: Skipping unknown file type: wf.test.ts
   info: Compiling 'dist'...
+  info:   - writing /home/runner/work/3d-structure-prediction/3d-structure-prediction/workflow/dist/tengo/lib/structure-cols-conv.lib.tengo
   info:   - writing /home/runner/work/3d-structure-prediction/3d-structure-prediction/workflow/dist/tengo/tpl/build-pdbs-map.plj.gz
   info:   - writing /home/runner/work/3d-structure-prediction/3d-structure-prediction/workflow/dist/tengo/tpl/predict-batch.plj.gz
+  info:   - writing /home/runner/work/3d-structure-prediction/3d-structure-prediction/workflow/dist/tengo/tpl/prerun.plj.gz
   info:   - writing /home/runner/work/3d-structure-prediction/3d-structure-prediction/workflow/dist/tengo/tpl/main.plj.gz
   info: Template Pack build done.
   info: Template Pack build done.

package/CHANGELOG.md

@@ -1,5 +1,30 @@
 # @platforma-open/milaboratories.3d-structure-prediction.workflow
 
+## 1.0.6
+
+### Patch Changes
+
+- 0aae4c9: Add a pre-flight clonotype-count check. The prerun counts distinct clonotypes in the selected dataset (after the optional filter) and disables Run with an explanatory alert when the count exceeds 10 000.
+
+## 1.0.5
+
+### Patch Changes
+
+- 4438d9d: Clarify NanoBodyBuilder2 usage in the settings panel: relabel the light chain dropdown as optional with a tooltip, and expand the mode-info alert to note that NanoBodyBuilder2 is camelid-VHH-trained, so for conventional heavy-only inputs (e.g. human bulk IGH-only) the produced structure has VHH-biased framework geometry.
+
+  Drop the user-facing CPU and memory inputs (per-batch resources are fixed). Each prediction batch now requests 4 CPU cores and 4 GiB of memory.
+
+  Stop writing a wall-clock `prediction-date` REMARK into emitted PDBs. The timestamp made every PDB byte-different on every run, breaking the platforma backend's content-addressed caching — downstream nodes that consumed merged PDB ResourceMaps hit `CIDConflictError`. The other provenance REMARKs (immunebuilder version, torch seed, block version, numbering scheme) plus the seeded ensemble fully determine the prediction.
+
+  Make the saved Python wrapper log byte-stable for identical inputs: drop the per-line UTC timestamp prefix and remove every wall-clock duration printed by `_log` (`predictor ready in Xs`, `predicted in Xs`, `elapsed=Xs`). The exec template saves stdout via `saveStdoutStream()` into the regular file output set, so its content hash flows into the resource CID; timestamped logs would re-introduce the same `CIDConflictError` failure mode as the PDB date.
+
+  Set `stepCache: 30 * times.minute` on the `processColumn` call so per-batch outputs stay reachable for the dedup/recovery path across project re-renders, matching the convention used by mixcr-clonotyping and miltenyi-tcr-bcr-clonotyping.
+
+  Add the species selector (spec R44): `human | mouse | camelid | rat | rabbit | other`, default `human`. Species is included in the block subtitle (R56) alongside the engine. The mode-info banner now splits into two cases: when the species is `camelid` and the light chain is unset we treat it as a true VHH input (informational); for any other species combined with heavy-only input we surface a warning that NanoBodyBuilder2's framework geometry is biased away from conventional VH. A separate warning fires for ABodyBuilder2 runs on species outside the training distribution (anything other than human or mouse). Species is held in `BlockData` only — the workflow does not consume it yet, so switching species does not invalidate cached predictions. Upstream clonotyping blocks do not propagate species through PColumn specs today, so the selector is user-supplied; once upstream wires `pl7.app/species` onto the clonotype-axis domain, this block can pre-fill the default.
+
+- Updated dependencies [4438d9d]
+  - @platforma-open/milaboratories.3d-structure-prediction.software@1.0.5
+
 ## 1.0.4
 
 ### Patch Changes

package/dist/index.cjs

@@ -1,5 +1,6 @@
 module.exports = { Templates: {
   'build-pdbs-map': { type: 'from-file', path: require.resolve('./tengo/tpl/build-pdbs-map.plj.gz') },
   'predict-batch': { type: 'from-file', path: require.resolve('./tengo/tpl/predict-batch.plj.gz') },
+  'prerun': { type: 'from-file', path: require.resolve('./tengo/tpl/prerun.plj.gz') },
   'main': { type: 'from-file', path: require.resolve('./tengo/tpl/main.plj.gz') }
 }};

package/dist/index.d.ts

@@ -1,4 +1,4 @@
 declare type TemplateFromFile = { readonly type: "from-file"; readonly path: string; };
-declare type TplName = "build-pdbs-map" | "predict-batch" | "main";
+declare type TplName = "build-pdbs-map" | "predict-batch" | "prerun" | "main";
 declare const Templates: Record<TplName, TemplateFromFile>;
 export { Templates };

package/dist/index.js

@@ -2,5 +2,6 @@ import { resolve } from 'node:path';
 export const Templates = {
   'build-pdbs-map': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/build-pdbs-map.plj.gz') },
   'predict-batch': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/predict-batch.plj.gz') },
+  'prerun': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/prerun.plj.gz') },
   'main': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/main.plj.gz') }
 };

package/dist/tengo/lib/structure-cols-conv.lib.tengo

@@ -0,0 +1,204 @@
+ll := import("@platforma-sdk/workflow-tengo:ll")
+
+confidenceColumn := func(columnId, pName, label, extraAnnotations) {
+	annotations := {
+		"pl7.app/label": label,
+		"pl7.app/structure/confidenceMetric": "predictedErrorAngstroms"
+	}
+	for k, v in extraAnnotations { annotations[k] = v }
+	return {
+		column: columnId,
+		id: columnId,
+		spec: {
+			valueType: "Double",
+			name: pName,
+			annotations: annotations
+		}
+	}
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+getConfidenceColumns := func(isPaired) {
+	cols := [
+		{
+			column: "clonotypeLabel",
+			id: "clonotypeLabel",
+			spec: {
+				valueType: "String",
+				name: "pl7.app/label",
+				annotations: {
+					"pl7.app/label": "Clone",
+					"pl7.app/table/orderPriority": "100000"
+				}
+			}
+		},
+		confidenceColumn("meanError", "pl7.app/structure/confidence/mean",
+			"Mean error (Å)", { "pl7.app/isScore": "true", "pl7.app/table/orderPriority": "90000" }),
+		confidenceColumn("cdrh1Error", "pl7.app/structure/confidence/cdrh1", "CDRH1 error (Å)", {}),
+		confidenceColumn("cdrh2Error", "pl7.app/structure/confidence/cdrh2", "CDRH2 error (Å)", {}),
+		confidenceColumn("cdrh3Error", "pl7.app/structure/confidence/cdrh3", "CDRH3 error (Å)",
+			{
+				"pl7.app/isScore": "true",
+				"pl7.app/table/orderPriority": "89000",
+				"pl7.app/description": "ABodyBuilder2 accuracy degrades for CDRH3 ≥ ~20 aa (Abanades et al., 2023, Fig. 4); long-CDRH3 predictions should be treated as lower-confidence regardless of the error value."
+			})
+	]
+	if isPaired {
+		cols = append(cols,
+			confidenceColumn("cdrl1Error", "pl7.app/structure/confidence/cdrl1", "CDRL1 error (Å)", {}))
+		cols = append(cols,
+			confidenceColumn("cdrl2Error", "pl7.app/structure/confidence/cdrl2", "CDRL2 error (Å)", {}))
+		cols = append(cols,
+			confidenceColumn("cdrl3Error", "pl7.app/structure/confidence/cdrl3", "CDRL3 error (Å)", {}))
+	}
+	cols = append(cols, {
+		column: "perResidueError",
+		id: "perResidueError",
+		spec: {
+			valueType: "String",
+			name: "pl7.app/structure/confidence/perResidue",
+			annotations: {
+				"pl7.app/label": "Per-residue error (JSON)",
+				"pl7.app/structure/confidenceMetric": "predictedErrorAngstroms",
+				"pl7.app/structure/perResidueSchema": "json_pos_chain_err_v1",
+				"pl7.app/table/visibility": "hidden"
+			}
+		}
+	})
+	cols = append(cols, {
+		column: "cdrh3Length",
+		id: "cdrh3Length",
+		spec: {
+			valueType: "Long",
+			name: "pl7.app/structure/cdrh3Length",
+			annotations: { "pl7.app/label": "CDRH3 length (aa)" }
+		}
+	})
+	cols = append(cols, {
+		column: "failureReasonText",
+		id: "failureReasonText",
+		spec: {
+			valueType: "String",
+			name: "pl7.app/structure/failureReason/text",
+			annotations: {
+				"pl7.app/label": "Failure reason",
+				"pl7.app/table/visibility": "optional"
+			}
+		}
+	})
+	cols = append(cols, {
+		column: "failureReason",
+		id: "failureReason",
+		spec: {
+			valueType: "String",
+			name: "pl7.app/structure/failureReason",
+			annotations: {
+				"pl7.app/label": "Failure reason (code)",
+				"pl7.app/table/visibility": "hidden"
+			}
+		}
+	})
+	cols = append(cols, {
+		column: "warningText",
+		id: "warningText",
+		spec: {
+			valueType: "String",
+			name: "pl7.app/structure/warning/text",
+			annotations: {
+				"pl7.app/label": "Warnings",
+				"pl7.app/table/visibility": "optional"
+			}
+		}
+	})
+	cols = append(cols, {
+		column: "warning",
+		id: "warning",
+		spec: {
+			valueType: "String",
+			name: "pl7.app/structure/warning",
+			annotations: {
+				"pl7.app/label": "Warnings (codes)",
+				"pl7.app/table/visibility": "hidden"
+			}
+		}
+	})
+	return cols
+}
+
+
+
+getPdbsMapSpec := func() {
+	return {
+		kind: "PColumn",
+		name: "pl7.app/structure/pdb",
+		domain: { "pl7.app/structure/numbering": "imgt" },
+		valueType: "File",
+		axesSpec: [],
+		annotations: {
+			"pl7.app/label": "Predicted PDB structure",
+			"pl7.app/structure/numbering": "imgt"
+		}
+	}
+}
+
+
+
+getPredictionSuccessfulSettings := func(clonotypeAxisSpec, clonotypeAxisName) {
+	return {
+		axes: [{ column: clonotypeAxisName, spec: clonotypeAxisSpec }],
+		columns: [{
+			column: "predictionSuccessful",
+			spec: {
+				valueType: "Int",
+				name: "pl7.app/structure/predictionSuccessful",
+				annotations: {
+					"pl7.app/label": "All structures",
+					"pl7.app/isSubset": "true",
+					"pl7.app/table/visibility": "hidden"
+				}
+			}
+		}],
+		storageFormat: "Parquet"
+	}
+}
+
+
+
+getConfidentSettings := func(clonotypeAxisSpec, clonotypeAxisName) {
+	return {
+		axes: [{ column: clonotypeAxisName, spec: clonotypeAxisSpec }],
+		columns: [{
+			column: "confident",
+			spec: {
+				valueType: "Int",
+				name: "pl7.app/structure/confident",
+				annotations: {
+					"pl7.app/label": "Confident structures",
+					"pl7.app/isSubset": "true",
+					"pl7.app/table/visibility": "hidden"
+				}
+			}
+		}],
+		storageFormat: "Parquet"
+	}
+}
+
+export ll.toStrict({
+	getConfidenceColumns: getConfidenceColumns,
+	getPdbsMapSpec: getPdbsMapSpec,
+	getPredictionSuccessfulSettings: getPredictionSuccessfulSettings,
+	getConfidentSettings: getConfidentSettings
+})

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@platforma-open/milaboratories.3d-structure-prediction.workflow",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "Block Workflow",
   "type": "module",
   "dependencies": {
-    "@platforma-sdk/workflow-tengo": "5.21.0",
-    "@platforma-open/milaboratories.3d-structure-prediction.software": "1.0.4"
+    "@platforma-sdk/workflow-tengo": "5.25.0",
+    "@platforma-open/milaboratories.3d-structure-prediction.software": "1.0.5"
   },
   "devDependencies": {
-    "@platforma-sdk/tengo-builder": "2.5.21",
-    "@platforma-sdk/test": "1.73.0"
+    "@platforma-sdk/tengo-builder": "3.0.1",
+    "@platforma-sdk/test": "1.77.5"
   },
   "peerDependencies": {
     "vitest": "*"

package/src/main.tpl.tengo

@@ -7,28 +7,14 @@ pt := import("@platforma-sdk/workflow-tengo:pt")
 smart := import("@platforma-sdk/workflow-tengo:smart")
 exec := import("@platforma-sdk/workflow-tengo:exec")
 units := import("@platforma-sdk/workflow-tengo:units")
+times := import("times")
+
+structureColsConv := import(":structure-cols-conv")
 
 predictBatchTpl := assets.importTemplate(":predict-batch")
 immuneBuilderSw := assets.importSoftware("@platforma-open/milaboratories.3d-structure-prediction.software:immunebuilder-predict")
 
-CONFIDENCE_METRIC_ANNOTATION := { "pl7.app/structure/confidenceMetric": "predictedErrorAngstroms" }
-
-confidenceColumn := func(columnId, pName, label, extraAnnotations) {
-	annotations := {
-		"pl7.app/label": label,
-		"pl7.app/structure/confidenceMetric": "predictedErrorAngstroms"
-	}
-	for k, v in extraAnnotations { annotations[k] = v }
-	return {
-		column: columnId,
-		id: columnId,
-		spec: {
-			valueType: "Double",
-			name: pName,
-			annotations: annotations
-		}
-	}
-}
+wf.setPreRun(assets.importTemplate(":prerun"))
 
 wf.prepare(func(args) {
 	// args.dataset is a PrimaryRef { __isPrimaryRef: "v1", column: PlRef, filter?: PlRef }.
@@ -74,8 +60,8 @@ wf.body(func(args) {
 	labelEntry := len(labelColumns) > 0 ? labelColumns[0] : undefined
 
 	seed := is_undefined(args.torchSeed) ? 42 : args.torchSeed
-	cpu := is_undefined(args.cpu) ? 4 : args.cpu
-	memGiB := is_undefined(args.mem) ? 16 : args.mem
+	cpu := 4
+	memGiB := 4
 	confidenceMetric := is_undefined(args.confidenceMetric) ? "cdrh3Mean" : args.confidenceMetric
 	threshold := is_undefined(args.confidenceThresholdAngstroms) ? 2.5 : args.confidenceThresholdAngstroms
 	batchSize := is_undefined(args.batchSize) ? 50 : args.batchSize
@@ -110,120 +96,7 @@ wf.body(func(args) {
 		})
 	}
 
-	// Per-batch confidence.tsv → typed PColumns. The orchestrator adds the
-	// batch-key axis (clonotype) automatically; `batchKeyColumns` names it.
-	// `clonotypeLabel` is echoed by the python wrapper so the V3 structures
-	// table substitutes it into the row-axis cells (single-axis pl7.app/label
-	// PColumn → recognised by PlAgDataTable's `isLabelColumn`).
-	confidenceXsvColumns := [
-		{
-			column: "clonotypeLabel",
-			id: "clonotypeLabel",
-			spec: {
-				valueType: "String",
-				name: "pl7.app/label",
-				annotations: {
-					"pl7.app/label": "Clone",
-					"pl7.app/table/orderPriority": "100000"
-				}
-			}
-		},
-		confidenceColumn("meanError", "pl7.app/structure/confidence/mean",
-			"Mean error (Å)", { "pl7.app/isScore": "true", "pl7.app/table/orderPriority": "90000" }),
-		confidenceColumn("cdrh1Error", "pl7.app/structure/confidence/cdrh1", "CDRH1 error (Å)", {}),
-		confidenceColumn("cdrh2Error", "pl7.app/structure/confidence/cdrh2", "CDRH2 error (Å)", {}),
-		confidenceColumn("cdrh3Error", "pl7.app/structure/confidence/cdrh3", "CDRH3 error (Å)",
-			{
-				"pl7.app/isScore": "true",
-				"pl7.app/table/orderPriority": "89000",
-				"pl7.app/description": "ABodyBuilder2 accuracy degrades for CDRH3 ≥ ~20 aa (Abanades et al., 2023, Fig. 4); long-CDRH3 predictions should be treated as lower-confidence regardless of the error value."
-			})
-	]
-	if isPaired {
-		confidenceXsvColumns = append(confidenceXsvColumns,
-			confidenceColumn("cdrl1Error", "pl7.app/structure/confidence/cdrl1", "CDRL1 error (Å)", {}))
-		confidenceXsvColumns = append(confidenceXsvColumns,
-			confidenceColumn("cdrl2Error", "pl7.app/structure/confidence/cdrl2", "CDRL2 error (Å)", {}))
-		confidenceXsvColumns = append(confidenceXsvColumns,
-			confidenceColumn("cdrl3Error", "pl7.app/structure/confidence/cdrl3", "CDRL3 error (Å)", {}))
-	}
-	confidenceXsvColumns = append(confidenceXsvColumns, {
-		column: "perResidueError",
-		id: "perResidueError",
-		spec: {
-			valueType: "String",
-			name: "pl7.app/structure/confidence/perResidue",
-			annotations: {
-				"pl7.app/label": "Per-residue error (JSON)",
-				"pl7.app/structure/confidenceMetric": "predictedErrorAngstroms",
-				"pl7.app/structure/perResidueSchema": "json_pos_chain_err_v1",
-				"pl7.app/table/visibility": "hidden"
-			}
-		}
-	})
-	confidenceXsvColumns = append(confidenceXsvColumns, {
-		column: "cdrh3Length",
-		id: "cdrh3Length",
-		spec: {
-			valueType: "Long",
-			name: "pl7.app/structure/cdrh3Length",
-			annotations: { "pl7.app/label": "CDRH3 length (aa)" }
-		}
-	})
-	// failureReason / warning come in two flavours:
-	//   - the *Text columns carry human-readable strings (translated python-side)
-	//     and are surfaced in the table.
-	//   - the code columns retain the raw enum value, hidden by default; they
-	//     stay in the schema so downstream blocks / future failure-stats logic
-	//     can group on a stable identifier.
-	confidenceXsvColumns = append(confidenceXsvColumns, {
-		column: "failureReasonText",
-		id: "failureReasonText",
-		spec: {
-			valueType: "String",
-			name: "pl7.app/structure/failureReason/text",
-			annotations: {
-				"pl7.app/label": "Failure reason",
-				"pl7.app/table/visibility": "optional"
-			}
-		}
-	})
-	confidenceXsvColumns = append(confidenceXsvColumns, {
-		column: "failureReason",
-		id: "failureReason",
-		spec: {
-			valueType: "String",
-			name: "pl7.app/structure/failureReason",
-			annotations: {
-				"pl7.app/label": "Failure reason (code)",
-				"pl7.app/table/visibility": "hidden"
-			}
-		}
-	})
-	confidenceXsvColumns = append(confidenceXsvColumns, {
-		column: "warningText",
-		id: "warningText",
-		spec: {
-			valueType: "String",
-			name: "pl7.app/structure/warning/text",
-			annotations: {
-				"pl7.app/label": "Warnings",
-				"pl7.app/table/visibility": "optional"
-			}
-		}
-	})
-	confidenceXsvColumns = append(confidenceXsvColumns, {
-		column: "warning",
-		id: "warning",
-		spec: {
-			valueType: "String",
-			name: "pl7.app/structure/warning",
-			annotations: {
-				"pl7.app/label": "Warnings (codes)",
-				"pl7.app/table/visibility": "hidden"
-			}
-		}
-	})
+	confidenceXsvColumns := structureColsConv.getConfidenceColumns(isPaired)
 
 	// Pre-download model weights once, before the batch fan-out. ImmuneBuilder
 	// fetches weights on first predictor construction into a shared on-disk
@@ -278,17 +151,7 @@ wf.body(func(args) {
 			{
 				type: "ResourceMap",
 				name: "pdbsMap",
-				spec: {
-					kind: "PColumn",
-					name: "pl7.app/structure/pdb",
-					domain: { "pl7.app/structure/numbering": "imgt" },
-					valueType: "File",
-					axesSpec: [],
-					annotations: {
-						"pl7.app/label": "Predicted PDB structure",
-						"pl7.app/structure/numbering": "imgt"
-					}
-				}
+				spec: structureColsConv.getPdbsMapSpec()
 			}
 		],
 		{
@@ -296,14 +159,10 @@ wf.body(func(args) {
 				size: batchSize,
 				keyColumns: [clonotypeAxisName],
 				format: "tsv",
-				// passContent=false: orchestrator writes per-batch blob files
-				// (one per slice) and hands each as a file reference to the body.
-				// passContent=true would ship the entire per-scope joined TSV as
-				// a single value resource — that's capped at 3MiB and overflows
-				// at ~22MiB on real datasets.
 				passContent: false
 			},
-			extra: bodyExtra
+			extra: bodyExtra,
+			stepCache: 30 * times.minute
 		}
 	)
 
@@ -344,39 +203,15 @@ wf.body(func(args) {
 
 	subsetRun := subsetWf.run()
 
-	predictionSuccessfulPf := xsv.importFile(subsetRun.getFile("subsets.tsv"), "tsv", {
-		axes: [{ column: clonotypeAxisName, spec: clonotypeAxisSpec }],
-		columns: [{
-			column: "predictionSuccessful",
-			spec: {
-				valueType: "Int",
-				name: "pl7.app/structure/predictionSuccessful",
-				annotations: {
-					"pl7.app/label": "Structure predicted",
-					"pl7.app/isSubset": "true",
-					"pl7.app/table/visibility": "hidden"
-				}
-			}
-		}],
-		storageFormat: "Parquet"
-	}, { splitDataAndSpec: true })
+	predictionSuccessfulPf := xsv.importFile(
+		subsetRun.getFile("subsets.tsv"), "tsv",
+		structureColsConv.getPredictionSuccessfulSettings(clonotypeAxisSpec, clonotypeAxisName),
+		{ splitDataAndSpec: true })
 
-	confidentPf := xsv.importFile(subsetRun.getFile("confident.tsv"), "tsv", {
-		axes: [{ column: clonotypeAxisName, spec: clonotypeAxisSpec }],
-		columns: [{
-			column: "confident",
-			spec: {
-				valueType: "Int",
-				name: "pl7.app/structure/confident",
-				annotations: {
-					"pl7.app/label": "Confident structure (" + confidenceMetric + " ≤ " + string(threshold) + " Å)",
-					"pl7.app/isSubset": "true",
-					"pl7.app/table/visibility": "hidden"
-				}
-			}
-		}],
-		storageFormat: "Parquet"
-	}, { splitDataAndSpec: true })
+	confidentPf := xsv.importFile(
+		subsetRun.getFile("confident.tsv"), "tsv",
+		structureColsConv.getConfidentSettings(clonotypeAxisSpec, clonotypeAxisName),
+		{ splitDataAndSpec: true })
 
 	// Final structures pframe: confidence + subset columns. The label column
 	// (clonotypeLabel) is part of confidence.

package/src/predict-batch.tpl.tengo

@@ -70,4 +70,4 @@ self.body(func(inputs) {
 		confidence: predictRun.getFile("confidence.tsv"),
 		pdbsMap: predictRun.getProcessorResult("pdbsMap")
 	}
-})
+})

package/src/prerun.tpl.tengo

@@ -0,0 +1,54 @@
+// Pre-flight check for the 3D Structure Prediction workflow.
+//
+// Counts the number of distinct clonotype-axis values in the selected
+// heavy-chain column AFTER applying the optional dataset filter. The result
+// is surfaced to the model so the UI can warn / disable Run when the input
+// would generate too many batches to be feasible.
+//
+// Mirrors `main.tpl.tengo`'s primary-source plumbing: the optional filter is
+// applied via the ResolvedPrimaryRef shape, so the count reflects exactly
+// what the main `pframes.processColumn` would batch over.
+
+wf := import("@platforma-sdk/workflow-tengo:workflow")
+pt := import("@platforma-sdk/workflow-tengo:pt")
+
+wf.prepare(func(args) {
+	bb := wf.createPBundleBuilder()
+	bb.ignoreMissingDomains()
+	bb.addAnchor("main", args.dataset.column)
+	bb.addSingle(args.heavyChainRef)
+	if !is_undefined(args.dataset.filter) {
+		bb.addRef(args.dataset.filter)
+	}
+	return { columns: bb.build() }
+})
+
+wf.body(func(args) {
+	columns := args.columns
+	heavy := columns.getColumn(args.heavyChainRef)
+
+	// Counting workflow: load heavy chain, optionally inner-join the filter
+	// on the (shared) clonotype axis, then count rows. Heavy chain is keyed
+	// solely by the clonotype axis, so the row count equals the number of
+	// distinct clonotypes that the main batch run would fan out over.
+	countWf := pt.workflow().mem("1GiB").cpu(1)
+	heavyEntry := pt.p.column("heavy", { spec: heavy.spec, data: heavy.data })
+
+	pEntry := heavyEntry
+	if !is_undefined(args.dataset.filter) {
+		filterCol := columns.getColumn(args.dataset.filter)
+		filterEntry := pt.p.column("filterValue", { spec: filterCol.spec, data: filterCol.data })
+		pEntry = pt.p.inner(heavyEntry, filterEntry)
+	}
+
+	df := countWf.frame(pEntry)
+	df.select(pt.col("heavy").count().alias("count")).saveContent("count.tsv")
+	countRun := countWf.run()
+
+	return {
+		outputs: {
+			clonotypeCount: countRun.getFileContent("count.tsv")
+		},
+		exports: {}
+	}
+})

package/src/structure-cols-conv.lib.tengo

@@ -0,0 +1,204 @@
+ll := import("@platforma-sdk/workflow-tengo:ll")
+
+confidenceColumn := func(columnId, pName, label, extraAnnotations) {
+	annotations := {
+		"pl7.app/label": label,
+		"pl7.app/structure/confidenceMetric": "predictedErrorAngstroms"
+	}
+	for k, v in extraAnnotations { annotations[k] = v }
+	return {
+		column: columnId,
+		id: columnId,
+		spec: {
+			valueType: "Double",
+			name: pName,
+			annotations: annotations
+		}
+	}
+}
+
+// Per-batch confidence.tsv → typed PColumns. The processColumn orchestrator
+// adds the batch-key axis (clonotype) automatically; the caller passes
+// `batchKeyColumns: [clonotypeAxisName]` alongside this column list.
+//
+// `clonotypeLabel` is echoed by the python wrapper so the V3 structures
+// table substitutes it into the row-axis cells (single-axis pl7.app/label
+// PColumn → recognised by PlAgDataTable's `isLabelColumn`).
+//
+// failureReason / warning come in two flavours:
+//   - the *Text columns carry human-readable strings (translated python-side)
+//     and are surfaced in the table.
+//   - the code columns retain the raw enum value, hidden by default; they
+//     stay in the schema so downstream blocks / future failure-stats logic
+//     can group on a stable identifier.
+getConfidenceColumns := func(isPaired) {
+	cols := [
+		{
+			column: "clonotypeLabel",
+			id: "clonotypeLabel",
+			spec: {
+				valueType: "String",
+				name: "pl7.app/label",
+				annotations: {
+					"pl7.app/label": "Clone",
+					"pl7.app/table/orderPriority": "100000"
+				}
+			}
+		},
+		confidenceColumn("meanError", "pl7.app/structure/confidence/mean",
+			"Mean error (Å)", { "pl7.app/isScore": "true", "pl7.app/table/orderPriority": "90000" }),
+		confidenceColumn("cdrh1Error", "pl7.app/structure/confidence/cdrh1", "CDRH1 error (Å)", {}),
+		confidenceColumn("cdrh2Error", "pl7.app/structure/confidence/cdrh2", "CDRH2 error (Å)", {}),
+		confidenceColumn("cdrh3Error", "pl7.app/structure/confidence/cdrh3", "CDRH3 error (Å)",
+			{
+				"pl7.app/isScore": "true",
+				"pl7.app/table/orderPriority": "89000",
+				"pl7.app/description": "ABodyBuilder2 accuracy degrades for CDRH3 ≥ ~20 aa (Abanades et al., 2023, Fig. 4); long-CDRH3 predictions should be treated as lower-confidence regardless of the error value."
+			})
+	]
+	if isPaired {
+		cols = append(cols,
+			confidenceColumn("cdrl1Error", "pl7.app/structure/confidence/cdrl1", "CDRL1 error (Å)", {}))
+		cols = append(cols,
+			confidenceColumn("cdrl2Error", "pl7.app/structure/confidence/cdrl2", "CDRL2 error (Å)", {}))
+		cols = append(cols,
+			confidenceColumn("cdrl3Error", "pl7.app/structure/confidence/cdrl3", "CDRL3 error (Å)", {}))
+	}
+	cols = append(cols, {
+		column: "perResidueError",
+		id: "perResidueError",
+		spec: {
+			valueType: "String",
+			name: "pl7.app/structure/confidence/perResidue",
+			annotations: {
+				"pl7.app/label": "Per-residue error (JSON)",
+				"pl7.app/structure/confidenceMetric": "predictedErrorAngstroms",
+				"pl7.app/structure/perResidueSchema": "json_pos_chain_err_v1",
+				"pl7.app/table/visibility": "hidden"
+			}
+		}
+	})
+	cols = append(cols, {
+		column: "cdrh3Length",
+		id: "cdrh3Length",
+		spec: {
+			valueType: "Long",
+			name: "pl7.app/structure/cdrh3Length",
+			annotations: { "pl7.app/label": "CDRH3 length (aa)" }
+		}
+	})
+	cols = append(cols, {
+		column: "failureReasonText",
+		id: "failureReasonText",
+		spec: {
+			valueType: "String",
+			name: "pl7.app/structure/failureReason/text",
+			annotations: {
+				"pl7.app/label": "Failure reason",
+				"pl7.app/table/visibility": "optional"
+			}
+		}
+	})
+	cols = append(cols, {
+		column: "failureReason",
+		id: "failureReason",
+		spec: {
+			valueType: "String",
+			name: "pl7.app/structure/failureReason",
+			annotations: {
+				"pl7.app/label": "Failure reason (code)",
+				"pl7.app/table/visibility": "hidden"
+			}
+		}
+	})
+	cols = append(cols, {
+		column: "warningText",
+		id: "warningText",
+		spec: {
+			valueType: "String",
+			name: "pl7.app/structure/warning/text",
+			annotations: {
+				"pl7.app/label": "Warnings",
+				"pl7.app/table/visibility": "optional"
+			}
+		}
+	})
+	cols = append(cols, {
+		column: "warning",
+		id: "warning",
+		spec: {
+			valueType: "String",
+			name: "pl7.app/structure/warning",
+			annotations: {
+				"pl7.app/label": "Warnings (codes)",
+				"pl7.app/table/visibility": "hidden"
+			}
+		}
+	})
+	return cols
+}
+
+// PDB ResourceMap spec — produced by the batch orchestrator (merged across
+// batches via merge-resource-maps). Failed clonotypes have no entry.
+getPdbsMapSpec := func() {
+	return {
+		kind: "PColumn",
+		name: "pl7.app/structure/pdb",
+		domain: { "pl7.app/structure/numbering": "imgt" },
+		valueType: "File",
+		axesSpec: [],
+		annotations: {
+			"pl7.app/label": "Predicted PDB structure",
+			"pl7.app/structure/numbering": "imgt"
+		}
+	}
+}
+
+// xsv.importFile settings for the predictionSuccessful subset PColumn —
+// 1 = prediction succeeded (failureReason was null), 0 = failed.
+getPredictionSuccessfulSettings := func(clonotypeAxisSpec, clonotypeAxisName) {
+	return {
+		axes: [{ column: clonotypeAxisName, spec: clonotypeAxisSpec }],
+		columns: [{
+			column: "predictionSuccessful",
+			spec: {
+				valueType: "Int",
+				name: "pl7.app/structure/predictionSuccessful",
+				annotations: {
+					"pl7.app/label": "All structures",
+					"pl7.app/isSubset": "true",
+					"pl7.app/table/visibility": "hidden"
+				}
+			}
+		}],
+		storageFormat: "Parquet"
+	}
+}
+
+// xsv.importFile settings for the `confident` subset PColumn — 1 when the
+// user-selected confidence metric is ≤ threshold AND prediction succeeded.
+getConfidentSettings := func(clonotypeAxisSpec, clonotypeAxisName) {
+	return {
+		axes: [{ column: clonotypeAxisName, spec: clonotypeAxisSpec }],
+		columns: [{
+			column: "confident",
+			spec: {
+				valueType: "Int",
+				name: "pl7.app/structure/confident",
+				annotations: {
+					"pl7.app/label": "Confident structures",
+					"pl7.app/isSubset": "true",
+					"pl7.app/table/visibility": "hidden"
+				}
+			}
+		}],
+		storageFormat: "Parquet"
+	}
+}
+
+export ll.toStrict({
+	getConfidenceColumns: getConfidenceColumns,
+	getPdbsMapSpec: getPdbsMapSpec,
+	getPredictionSuccessfulSettings: getPredictionSuccessfulSettings,
+	getConfidentSettings: getConfidentSettings
+})