@platforma-open/milaboratories.top-antibodies.workflow 1.7.0 → 1.8.1

package/.turbo/turbo-build.log

@@ -1,17 +1,21 @@
  WARN  Issue while reading "/home/runner/work/antibody-tcr-lead-selection/antibody-tcr-lead-selection/.npmrc". Failed to replace env in config: ${NPMJS_TOKEN}
 
-> @platforma-open/milaboratories.top-antibodies.workflow@1.7.0 build /home/runner/work/antibody-tcr-lead-selection/antibody-tcr-lead-selection/workflow
+> @platforma-open/milaboratories.top-antibodies.workflow@1.8.1 build /home/runner/work/antibody-tcr-lead-selection/antibody-tcr-lead-selection/workflow
 > rm -rf dist && pl-tengo check && pl-tengo build
 
+Processing "src/filter-and-sample.tpl.tengo"...
 Processing "src/main.tpl.tengo"...
 Processing "src/pf-spectratype-conv.lib.tengo"...
 Processing "src/pf-vj-usage-conv.lib.tengo"...
+Processing "src/prerun.tpl.tengo"...
 Processing "src/sampled-cols-conv.lib.tengo"...
 No syntax errors found.
   info: Compiling 'dist'...
   info:   - writing /home/runner/work/antibody-tcr-lead-selection/antibody-tcr-lead-selection/workflow/dist/tengo/lib/pf-spectratype-conv.lib.tengo
   info:   - writing /home/runner/work/antibody-tcr-lead-selection/antibody-tcr-lead-selection/workflow/dist/tengo/lib/pf-vj-usage-conv.lib.tengo
   info:   - writing /home/runner/work/antibody-tcr-lead-selection/antibody-tcr-lead-selection/workflow/dist/tengo/lib/sampled-cols-conv.lib.tengo
+  info:   - writing /home/runner/work/antibody-tcr-lead-selection/antibody-tcr-lead-selection/workflow/dist/tengo/tpl/filter-and-sample.plj.gz
+  info:   - writing /home/runner/work/antibody-tcr-lead-selection/antibody-tcr-lead-selection/workflow/dist/tengo/tpl/prerun.plj.gz
   info:   - writing /home/runner/work/antibody-tcr-lead-selection/antibody-tcr-lead-selection/workflow/dist/tengo/tpl/main.plj.gz
   info: Template Pack build done.
   info: Template Pack build done.

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @platforma-open/milaboratories.top-antibodies.workflow
 
+## 1.8.1
+
+### Patch Changes
+
+- 7397001: Remove typo
+
+## 1.8.0
+
+### Minor Changes
+
+- a435169: Move filters to settings and add prerun
+
+### Patch Changes
+
+- Updated dependencies [a435169]
+  - @platforma-open/milaboratories.top-antibodies.sample-clonotypes@1.1.0
+  - @platforma-open/milaboratories.top-antibodies.spectratype@1.4.0
+
 ## 1.7.0
 
 ### Minor Changes

package/dist/index.cjs

@@ -1,3 +1,5 @@
 module.exports = { Templates: {
+  'filter-and-sample': { type: 'from-file', path: require.resolve('./tengo/tpl/filter-and-sample.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 = "main";
+declare type TplName = "filter-and-sample" | "prerun" | "main";
 declare const Templates: Record<TplName, TemplateFromFile>;
 export { Templates };

package/dist/index.js

@@ -1,4 +1,6 @@
 import { resolve } from 'node:path';
 export const Templates = {
+  'filter-and-sample': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/filter-and-sample.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/package.json

@@ -1,17 +1,17 @@
 {
   "name": "@platforma-open/milaboratories.top-antibodies.workflow",
-  "version": "1.7.0",
+  "version": "1.8.1",
   "type": "module",
   "description": "Block Workflow",
   "dependencies": {
-    "@platforma-sdk/workflow-tengo": "^4.8.0",
-    "@platforma-open/milaboratories.top-antibodies.sample-clonotypes": "1.0.3",
-    "@platforma-open/milaboratories.top-antibodies.spectratype": "1.3.2",
+    "@platforma-sdk/workflow-tengo": "^4.9.2",
+    "@platforma-open/milaboratories.top-antibodies.sample-clonotypes": "1.1.0",
+    "@platforma-open/milaboratories.top-antibodies.spectratype": "1.4.0",
     "@platforma-open/milaboratories.top-antibodies.umap": "1.0.3"
   },
   "devDependencies": {
-    "@platforma-sdk/tengo-builder": "^2.1.10",
-    "@platforma-sdk/test": "1.34.8",
+    "@platforma-sdk/tengo-builder": "^2.1.12",
+    "@platforma-sdk/test": "^1.38.0",
     "vitest": "^2.1.8"
   },
   "scripts": {

package/src/filter-and-sample.tpl.tengo

@@ -0,0 +1,80 @@
+// Template for clonotype filtering
+self := import("@platforma-sdk/workflow-tengo:tpl")
+exec := import("@platforma-sdk/workflow-tengo:exec")
+assets := import("@platforma-sdk/workflow-tengo:assets")
+pframes := import("@platforma-sdk/workflow-tengo:pframes")
+xsv := import("@platforma-sdk/workflow-tengo:pframes.xsv")
+render := import("@platforma-sdk/workflow-tengo:render")
+sampledColsConv := import(":sampled-cols-conv")
+json := import("json")
+
+self.defineOutputs("sampledRows", "finalClonotypesCsv")
+
+self.body(func(inputs) {
+
+    cloneTable := inputs.cloneTable
+    datasetSpec := inputs.datasetSpec
+    filterMap := inputs.filterMap
+    topClonotypes := inputs.topClonotypes
+
+    outputs := {}
+    finalClonotypesCsv := undefined
+    
+    // Run filtering script
+    filterResult := exec.builder().
+        software(assets.importSoftware("@platforma-open/milaboratories.top-antibodies.sample-clonotypes:filter")).
+        mem("16GiB").
+        cpu(1).
+        addFile("clonotypes.csv", cloneTable).
+        arg("--csv").arg("clonotypes.csv").
+        arg("--out").arg("filteredClonotypes.csv").
+        arg("--filter-map").arg(string(json.encode(filterMap))).
+        saveFile("filteredClonotypes.csv").
+        printErrStreamToStdout().
+        saveStdoutContent().
+        cache(24 * 60 * 60 * 1000).
+        run()
+
+    // Save filtered CSV file
+    filteredClonotypesCsv := filterResult.getFile("filteredClonotypes.csv")
+
+    // Store outputs 
+    sampledColsParams := sampledColsConv.getColumns(datasetSpec)
+    filteredClonotypesPf := xsv.importFile(filteredClonotypesCsv, "csv", sampledColsParams,
+                                        {cpu: 1, mem: "16GiB"})
+
+    // Prepare outputs in case there is no top ranking
+    outputs["sampledRows"] = pframes.exportFrame(filteredClonotypesPf)
+    finalClonotypesCsv = filteredClonotypesCsv
+
+	if topClonotypes != undefined {
+
+		////////// Top Clonotypes Sampling //////////
+		// Run sampling script on filtered data
+		sampleClones := exec.builder().
+			software(assets.importSoftware("@platforma-open/milaboratories.top-antibodies.sample-clonotypes:main")).
+			mem("16GiB").
+			cpu(1).
+			addFile("filteredClonotypes.csv", filteredClonotypesCsv).
+			arg("--csv").arg("filteredClonotypes.csv").
+			arg("--n").arg(string(topClonotypes)).
+			arg("--out").arg("sampledClonotypes_top.csv").
+			saveFile("sampledClonotypes_top.csv").
+			printErrStreamToStdout().
+			saveStdoutContent().
+			cache(24 * 60 * 60 * 1000).
+			run()
+
+		// Save top clonotypes CSV file
+		finalClonotypesCsv = sampleClones.getFile("sampledClonotypes_top.csv")
+		
+		// Store outputs 
+		sampledColumnsPf := xsv.importFile(finalClonotypesCsv, "csv", sampledColsParams,
+											{cpu: 1, mem: "16GiB"})
+		outputs["sampledRows"] = pframes.exportFrame(sampledColumnsPf)
+	} 
+
+    outputs["finalClonotypesCsv"] = finalClonotypesCsv
+
+    return outputs
+}) 

package/src/main.tpl.tengo

@@ -8,46 +8,49 @@ sampledColsConv := import(":sampled-cols-conv")
 spectratypeConv := import(":pf-spectratype-conv")
 vjUsageConv := import(":pf-vj-usage-conv")
 slices := import("@platforma-sdk/workflow-tengo:slices")
+render := import("@platforma-sdk/workflow-tengo:render")
 
-wf.prepare(func(args){
-	// We need a table with cluster ID (optional) | clonotype id | selected ranking columns
-
-	bundleBuilder := wf.createPBundleBuilder()
-	bundleBuilder.ignoreMissingDomains() // to make query work for both bulk and single cell data
-	bundleBuilder.addAnchor("main", args.inputAnchor) 
-	
-	if len(args.rankingOrder) > 0 {
-		for col in args.rankingOrder {
-			bundleBuilder.addAnchor(col.value.anchorName, col.value.anchorRef)
-			bundleBuilder.addSingle(col.value.column)
-		}
-	} else {
-		bundleBuilder.addAnchor(args.rankingOrderDefault.value.anchorName, 
-								args.rankingOrderDefault.value.anchorRef)
-		bundleBuilder.addSingle(args.rankingOrderDefault.value.column)
-	}
-	
+filterAndSampleTpl := assets.importTemplate(":filter-and-sample")
 
-	// Add linker column
-	bundleBuilder.addMulti({
-		axes: [{ anchor: "main", idx: 1 }], // this will do partial axes match (unlike in the model)
-		annotations: { "pl7.app/isLinkerColumn": "true" },
-		partialAxesMatch: true
-	}, "linkers")
-
-	// Add full aa sequence column
-	bundleBuilder.addMulti({
-		axes: [{ anchor: "main", idx: 1 }],
-		annotations: {
-			"pl7.app/vdj/isAssemblingFeature": "true",
-			"pl7.app/vdj/isMainSequence": "true"
-		},
-		domain: {
-			"pl7.app/alphabet": "aminoacid"
-		}
-	}, "aaSequence")
+// Set prerun template for clonotype filtering
+wf.setPreRun(assets.importTemplate(":prerun"))
 
-	// Add CDR3 sequences
+wf.prepare(func(args){
+	// We need a table with cluster ID (optional) | clonotype id | selected ranking columns
+    bundleBuilder := wf.createPBundleBuilder()
+    bundleBuilder.ignoreMissingDomains() // to make query work for both bulk and single cell data
+    bundleBuilder.addAnchor("main", args.inputAnchor) 
+    
+    if len(args.rankingOrder) > 0 {
+        for col in args.rankingOrder {
+            bundleBuilder.addAnchor(col.value.anchorName, col.value.anchorRef)
+            bundleBuilder.addSingle(col.value.column)
+        }
+    } else {
+        bundleBuilder.addAnchor(args.rankingOrderDefault.value.anchorName, 
+                                args.rankingOrderDefault.value.anchorRef)
+        bundleBuilder.addSingle(args.rankingOrderDefault.value.column)
+    }
+
+    // Load filter columns
+    if len(args.filters) > 0 {
+        for filter in args.filters {
+            if filter.value != undefined {
+                bundleBuilder.addAnchor(filter.value.anchorName, filter.value.anchorRef)
+                bundleBuilder.addSingle(filter.value.column)
+            }
+        }
+    }
+    
+
+    // Add linker column
+    bundleBuilder.addMulti({
+        axes: [{ anchor: "main", idx: 1 }], // this will do partial axes match (unlike in the model)
+        annotations: { "pl7.app/isLinkerColumn": "true" },
+        partialAxesMatch: true
+    }, "linkers")
+
+    // Add CDR3 sequences
 	bundleBuilder.addMulti({
 		axes: [{ anchor: "main", idx: 1 }], // Clonotype axis
 		name: "pl7.app/vdj/sequence",
@@ -74,10 +77,10 @@ wf.prepare(func(args){
 			"pl7.app/vdj/reference": "JGene"
 		}
 	}, "JGenes")
-
-	return {
-		columns: bundleBuilder.build()
-	}
+    
+    return {
+        columns: bundleBuilder.build()
+    }
 })
 
 wf.body(func(args) {
@@ -94,90 +97,105 @@ wf.body(func(args) {
 	// output containers 
 	outputs := {}
 
-	////////// Clonotype Filtering //////////
-	
-	topClonotypesCsv := undefined
-
-	if topClonotypes != undefined {
-		// Build clonotype table
-		cloneTable := pframes.csvFileBuilder() 
-		cloneTable.setAxisHeader(datasetSpec.axesSpec[1].name, "clonotypeKey")
-		
-		if len(args.rankingOrder) > 0 {
-			for i, col in args.rankingOrder {
-				cloneTable.add(columns.getColumn(col.value.column), {header: "Col" + string(i)})
+	// Get filtered clonotypes from prerun
+	// Build clonotype table
+	cloneTable := pframes.csvFileBuilder() 
+	cloneTable.setAxisHeader(datasetSpec.axesSpec[1].name, "clonotypeKey")
+
+	// Add Filters to table
+	addedAxes := []
+	filterMap := {}
+	if len(args.filters) > 0 {
+		for i, filter in args.filters {
+			if filter.value != undefined {
+				// Columns added here might also be in ranking list, so we add default IDs
+				cloneTable.add(columns.getColumn(filter.value.column), 
+								{header: "Filter_" + string(i), id: "filter_" + string(i)})
+				// Store reference value and filter type associated to this column
+				filterMap["Filter_" + string(i)] = filter.filter
 			
 				// If column does not have main anchor axis we have to include theirs
-				colsSpec := columns.getSpec(col.value.column)
+				colsSpec := columns.getSpec(filter.value.column)
 				axesNames := slices.map(colsSpec.axesSpec, func (a) { return a.name})
 				if !slices.hasElement(axesNames, datasetSpec.axesSpec[1].name) {
 					for na, ax in colsSpec.axesSpec {
 						if ax.name != datasetSpec.axesSpec[1].name {
 							cloneTable.setAxisHeader(ax.name, "cluster_" + string(i) + string(na))
+							addedAxes = slices.append(addedAxes, ax.name)
 						}
 					}
 				}	
 			}
-		} else {
-			i := 0
-			cloneTable.add(columns.getColumn(args.rankingOrderDefault.value.column), {header: "Col" + string(i)})
+		}
+	}
+
+	// Add ranking columns to table
+	if len(args.rankingOrder) > 0 {
+		for i, col in args.rankingOrder {
+			cloneTable.add(columns.getColumn(col.value.column), {header: "Col" + string(i)})
 		
 			// If column does not have main anchor axis we have to include theirs
-			colsSpec := columns.getSpec(args.rankingOrderDefault.value.column)
+			colsSpec := columns.getSpec(col.value.column)
 			axesNames := slices.map(colsSpec.axesSpec, func (a) { return a.name})
 			if !slices.hasElement(axesNames, datasetSpec.axesSpec[1].name) {
 				for na, ax in colsSpec.axesSpec {
-					if ax.name != datasetSpec.axesSpec[1].name {
+					if ax.name != datasetSpec.axesSpec[1].name && !slices.hasElement(addedAxes, ax.name) {
 						cloneTable.setAxisHeader(ax.name, "cluster_" + string(i) + string(na))
 					}
 				}
 			}	
 		}
-
-		// Columns gotten by query require .key
-		linkerAxisSpec := {}
-		if len(columns.getColumns("linkers")) > 0 {
-			for i, col in columns.getColumns("linkers") {
-				if datasetSpec.axesSpec[1].name == col.spec.axesSpec[1].name {
-					cloneTable.add(col, {header: "linker." + string(i)})
-					cloneTable.setAxisHeader(col.spec.axesSpec[0].name, "cluster_" + string(i))
-					linkerAxisSpec["cluster_" + string(i)] = col.spec.axesSpec[0]
-				} else if datasetSpec.axesSpec[1].name == col.spec.axesSpec[0].name {
-					cloneTable.add(col, {header: "linker." + string(i)})
-					cloneTable.setAxisHeader(col.spec.axesSpec[1].name, "cluster_" + string(i))
-					linkerAxisSpec["cluster_" + string(i)] = col.spec.axesSpec[1]
+	} else {
+		i := 0
+		cloneTable.add(columns.getColumn(args.rankingOrderDefault.value.column), {header: "Col" + string(i)})
+	
+		// If column does not have main anchor axis we have to include theirs
+		colsSpec := columns.getSpec(args.rankingOrderDefault.value.column)
+		axesNames := slices.map(colsSpec.axesSpec, func (a) { return a.name})
+		if !slices.hasElement(axesNames, datasetSpec.axesSpec[1].name) {
+			for na, ax in colsSpec.axesSpec {
+				if ax.name != datasetSpec.axesSpec[1].name {
+					cloneTable.setAxisHeader(ax.name, "cluster_" + string(i) + string(na))
 				}
 			}
-		}
-		cloneTable.mem("16GiB")
-		cloneTable.cpu(1)
-		cloneTable = cloneTable.build()
-
-		// Run sampling script
-		sampleClones := exec.builder().
-			software(assets.importSoftware("@platforma-open/milaboratories.top-antibodies.sample-clonotypes:main")).
-			mem("16GiB").
-			cpu(1).
-			addFile("filteredClonotypes.csv", cloneTable).
-			arg("--csv").arg("filteredClonotypes.csv").
-			arg("--n").arg(string(topClonotypes)).
-			arg("--out").arg("sampledClonotypes.csv").
-			saveFile("sampledClonotypes_top.csv").
-			printErrStreamToStdout().
-			saveStdoutContent().
-			cache(24 * 60 * 60 * 1000).
-			run()
-
-		// Save top clonotypes CSV file
-		topClonotypesCsv = sampleClones.getFile("sampledClonotypes_top.csv")
-
-		// Store outputs
-		sampledColsParams := sampledColsConv.getColumns(datasetSpec)
-		sampledColumnsPf := xsv.importFile(topClonotypesCsv, "csv", sampledColsParams,
-											{cpu: 1, mem: "16GiB"})
-		outputs["sampledRows"] = pframes.exportFrame(sampledColumnsPf)
+		}	
 	}
 
+	// Get linker columns if needed
+	linkerAxisSpec := {}
+	if len(columns.getColumns("linkers")) > 0 {
+		for i, col in columns.getColumns("linkers") {
+			if datasetSpec.axesSpec[1].name == col.spec.axesSpec[1].name {
+				cloneTable.add(col, {header: "linker." + string(i)})
+				cloneTable.setAxisHeader(col.spec.axesSpec[0].name, "cluster_" + string(i))
+				linkerAxisSpec["cluster_" + string(i)] = col.spec.axesSpec[0]
+			} else if datasetSpec.axesSpec[1].name == col.spec.axesSpec[0].name {
+				cloneTable.add(col, {header: "linker." + string(i)})
+				cloneTable.setAxisHeader(col.spec.axesSpec[1].name, "cluster_" + string(i))
+				linkerAxisSpec["cluster_" + string(i)] = col.spec.axesSpec[1]
+			}
+		}
+	}
+	cloneTable.mem("16GiB")
+	cloneTable.cpu(1)
+	cloneTable = cloneTable.build()
+
+	// Use ender.create to call the filter-clonotypes template
+	filterResult := render.create(filterAndSampleTpl, {
+		inputAnchor: args.inputAnchor,
+		cloneTable: cloneTable,
+		rankingOrder: args.rankingOrder,
+		rankingOrderDefault: args.rankingOrderDefault,
+		filters: args.filters,
+		filterMap: filterMap,
+		datasetSpec: datasetSpec,
+		topClonotypes: args.topClonotypes
+	})
+	
+	// Get the filtered clonotypes P-frame and CSV from the template result
+	finalClonotypesCsv := filterResult.output("finalClonotypesCsv", 24 * 60 * 60 * 1000)
+	// outputs["sampledRows"] = filterResult.output("sampledRows", 24 * 60 * 60 * 1000)
+	
 	////////// CDR3 Length Calculation //////////
 	
 	cdr3SeqTable := pframes.tsvFileBuilder()
@@ -247,10 +265,10 @@ wf.body(func(args) {
 		arg("--vj_usage_tsv").arg("vj_usage.tsv") // no dot here
 
 	// Add top clonotypes argument and file to the builder if provided
-	if topClonotypes != undefined {
+	if finalClonotypesCsv != undefined {
 		cdr3VspectratypeCmd = cdr3VspectratypeCmd.
-			arg("--top_clonotypes_csv").arg("topClonotypes.csv").
-			addFile("topClonotypes.csv", topClonotypesCsv)
+			arg("--final_clonotypes_csv").arg("finalClonotypes.csv").
+			addFile("finalClonotypes.csv", finalClonotypesCsv)
 	}
 
 	cdr3VspectratypeCmd = cdr3VspectratypeCmd. // continue building the command

package/src/prerun.tpl.tengo

@@ -0,0 +1,204 @@
+// Prerun template for clonotype filtering
+wf := import("@platforma-sdk/workflow-tengo:workflow")
+render := import("@platforma-sdk/workflow-tengo:render")
+ll := import("@platforma-sdk/workflow-tengo:ll")
+assets := import("@platforma-sdk/workflow-tengo:assets")
+pframes := import("@platforma-sdk/workflow-tengo:pframes")
+slices := import("@platforma-sdk/workflow-tengo:slices")
+
+filterAndSampleTpl := assets.importTemplate(":filter-and-sample")
+
+wf.prepare(func(args){
+	// We need a table with cluster ID (optional) | clonotype id | selected ranking columns
+    bundleBuilder := wf.createPBundleBuilder()
+    bundleBuilder.ignoreMissingDomains() // to make query work for both bulk and single cell data
+    bundleBuilder.addAnchor("main", args.inputAnchor) 
+    
+    if len(args.rankingOrder) > 0 {
+        for col in args.rankingOrder {
+            // For cases where the user is selecting the table to filter
+            if col.value != undefined {
+                bundleBuilder.addAnchor(col.value.anchorName, col.value.anchorRef)
+                bundleBuilder.addSingle(col.value.column)
+            }
+        }
+    } else {
+        // @TODO: this is a temporal patch for issue where rankingOrderDefault 
+        // are not defined by the time prerun works
+        // prerun sometimes runs before this variable is ready
+        if args.rankingOrderDefault.value != undefined {
+            bundleBuilder.addAnchor(args.rankingOrderDefault.value.anchorName, 
+                                    args.rankingOrderDefault.value.anchorRef)
+            bundleBuilder.addSingle(args.rankingOrderDefault.value.column)
+        }
+    }
+
+    // Load filter columns
+    if len(args.filters) > 0 {
+        for filter in args.filters {
+            if filter.value != undefined {
+                bundleBuilder.addAnchor(filter.value.anchorName, filter.value.anchorRef)
+                bundleBuilder.addSingle(filter.value.column)
+            }
+        }
+    }
+    
+
+    // Add linker column
+    bundleBuilder.addMulti({
+        axes: [{ anchor: "main", idx: 1 }], // this will do partial axes match (unlike in the model)
+        annotations: { "pl7.app/isLinkerColumn": "true" },
+        partialAxesMatch: true
+    }, "linkers")
+
+    // Add CDR3 sequences
+	bundleBuilder.addMulti({
+		axes: [{ anchor: "main", idx: 1 }], // Clonotype axis
+		name: "pl7.app/vdj/sequence",
+		domain: {
+			"pl7.app/alphabet": "aminoacid",
+			"pl7.app/vdj/feature": "CDR3"    // Specify CDR3 feature
+		}
+	}, "cdr3Sequences") // New collection name for CDR3 sequences
+
+	// Add V gene
+	bundleBuilder.addMulti({
+		axes: [{ anchor: "main", idx: 1 }], // Clonotype axis
+		name: "pl7.app/vdj/geneHit",
+		domain: {
+			"pl7.app/vdj/reference": "VGene"
+		}
+	}, "VGenes")
+
+	// Add J gene
+	bundleBuilder.addMulti({
+		axes: [{ anchor: "main", idx: 1 }], // Clonotype axis
+		name: "pl7.app/vdj/geneHit",
+		domain: {
+			"pl7.app/vdj/reference": "JGene"
+		}
+	}, "JGenes")
+    
+    return {
+        columns: bundleBuilder.build()
+    }
+})
+
+wf.body(func(args) {
+	// output containers 
+	outputs := {}
+
+    if !is_undefined(args.inputAnchor) {
+        columns := args.columns
+        datasetSpec := columns.getSpec(args.inputAnchor)
+    
+        ////////// Clonotype Filtering //////////
+        // Build clonotype table
+        cloneTable := pframes.csvFileBuilder() 
+        cloneTable.setAxisHeader(datasetSpec.axesSpec[1].name, "clonotypeKey")
+
+        // Add Filters to table
+        addedAxes := []
+        filterMap := {}
+        if len(args.filters) > 0 {
+            for i, filter in args.filters {
+                if filter.value != undefined {
+                    // Columns added here might also be in ranking list, so we add default IDs
+                    cloneTable.add(columns.getColumn(filter.value.column), 
+                                    {header: "Filter_" + string(i), id: "filter_" + string(i)})
+                    // Store reference value and filter type associated to this column
+                    filterMap["Filter_" + string(i)] = filter.filter
+                
+                    // If column does not have main anchor axis we have to include theirs
+                    colsSpec := columns.getSpec(filter.value.column)
+                    axesNames := slices.map(colsSpec.axesSpec, func (a) { return a.name})
+                    if !slices.hasElement(axesNames, datasetSpec.axesSpec[1].name) {
+                        for na, ax in colsSpec.axesSpec {
+                            if ax.name != datasetSpec.axesSpec[1].name {
+                                cloneTable.setAxisHeader(ax.name, "cluster_" + string(i) + string(na))
+                                addedAxes = append(addedAxes, ax.name)
+                            }
+                        }
+                    }	
+                }
+            }
+        }
+
+        // Add ranking columns to table
+        if len(args.rankingOrder) > 0 {
+            for i, col in args.rankingOrder {
+                if col.value != undefined {
+                    cloneTable.add(columns.getColumn(col.value.column), {header: "Col" + string(i)})
+                
+                    // If column does not have main anchor axis we have to include theirs
+                    colsSpec := columns.getSpec(col.value.column)
+                    axesNames := slices.map(colsSpec.axesSpec, func (a) { return a.name})
+                    if !slices.hasElement(axesNames, datasetSpec.axesSpec[1].name) {
+                        for na, ax in colsSpec.axesSpec {
+                            if ax.name != datasetSpec.axesSpec[1].name && !slices.hasElement(addedAxes, ax.name) {
+                                cloneTable.setAxisHeader(ax.name, "cluster_" + string(i) + string(na))
+                            }
+                        }
+                    }	
+                }
+            }
+        } else {
+            // @TODO: this is a temporal patch for issue where rankingOrderDefault 
+            // are not defined by the time prerun works
+            if args.rankingOrderDefault.value != undefined {
+                i := 0
+                cloneTable.add(columns.getColumn(args.rankingOrderDefault.value.column), {header: "Col" + string(i)})
+            
+                // If column does not have main anchor axis we have to include theirs
+                colsSpec := columns.getSpec(args.rankingOrderDefault.value.column)
+                axesNames := slices.map(colsSpec.axesSpec, func (a) { return a.name})
+                if !slices.hasElement(axesNames, datasetSpec.axesSpec[1].name) {
+                    for na, ax in colsSpec.axesSpec {
+                        if ax.name != datasetSpec.axesSpec[1].name {
+                            cloneTable.setAxisHeader(ax.name, "cluster_" + string(i) + string(na))
+                        }
+                    }
+                }	
+            }
+        }
+
+        // Get linker columns if needed
+        linkerAxisSpec := {}
+        if len(columns.getColumns("linkers")) > 0 {
+            for i, col in columns.getColumns("linkers") {
+                if datasetSpec.axesSpec[1].name == col.spec.axesSpec[1].name {
+                    cloneTable.add(col, {header: "linker." + string(i)})
+                    cloneTable.setAxisHeader(col.spec.axesSpec[0].name, "cluster_" + string(i))
+                    linkerAxisSpec["cluster_" + string(i)] = col.spec.axesSpec[0]
+                } else if datasetSpec.axesSpec[1].name == col.spec.axesSpec[0].name {
+                    cloneTable.add(col, {header: "linker." + string(i)})
+                    cloneTable.setAxisHeader(col.spec.axesSpec[1].name, "cluster_" + string(i))
+                    linkerAxisSpec["cluster_" + string(i)] = col.spec.axesSpec[1]
+                }
+            }
+        }
+        cloneTable.mem("16GiB")
+        cloneTable.cpu(1)
+        cloneTable = cloneTable.build()
+
+        // Use ender.create to call the filter-clonotypes template
+        filterResult := render.create(filterAndSampleTpl, {
+            inputAnchor: args.inputAnchor,
+            cloneTable: cloneTable,
+            topClonotypes: args.topClonotypes,
+            rankingOrder: args.rankingOrder,
+            rankingOrderDefault: args.rankingOrderDefault,
+            filters: args.filters,
+            filterMap: filterMap,
+            datasetSpec: datasetSpec
+        })
+        
+        // Get the filtered clonotypes from the template result
+        outputs["sampledRows"] = filterResult.output("sampledRows", 24 * 60 * 60 * 1000)
+    }
+
+	return {
+		outputs: outputs,
+		exports: {}
+	}
+})