@platforma-open/milaboratories.sequence-properties.workflow 1.1.1

package/.turbo/turbo-build.log

@@ -0,0 +1,17 @@
+ WARN  Issue while reading "/home/runner/work/sequence-properties/sequence-properties/.npmrc". Failed to replace env in config: ${NPMJS_TOKEN}
+
+> @platforma-open/milaboratories.sequence-properties.workflow@1.1.1 build /home/runner/work/sequence-properties/sequence-properties/workflow
+> shx rm -rf dist && pl-tengo check && pl-tengo build
+
+  info: Skipping unknown file type: wf.test.ts
+Processing "src/main.tpl.tengo"...
+Processing "src/messages.lib.tengo"...
+Processing "src/process.tpl.tengo"...
+No syntax errors found.
+  info: Skipping unknown file type: wf.test.ts
+  info: Compiling 'dist'...
+  info:   - writing /home/runner/work/sequence-properties/sequence-properties/workflow/dist/tengo/lib/messages.lib.tengo
+  info:   - writing /home/runner/work/sequence-properties/sequence-properties/workflow/dist/tengo/tpl/process.plj.gz
+  info:   - writing /home/runner/work/sequence-properties/sequence-properties/workflow/dist/tengo/tpl/main.plj.gz
+  info: Template Pack build done.
+  info: Template Pack build done.

package/CHANGELOG.md

@@ -0,0 +1,40 @@
+# @platforma-open/MiLaboratories.sequence-properties.workflow
+
+## 1.1.1
+
+### Patch Changes
+
+- bb07f98: Rename all package scopes from `MiLaboratories.sequence-properties` to `milaboratories.sequence-properties`. npm registry rejects new package names with uppercase letters, which blocked the first publish. Lowercase form aligns with the existing `@platforma-open/milaboratories.*` convention used by sibling blocks. Also corrects the GitHub URL in the block manifest to point at the actual repo (`platforma-open/sequence-properties`).
+
+## 1.1.0
+
+### Minor Changes
+
+- 1059d80: Initial release of the Sequence Properties block.
+
+  Computes physico-chemical properties (charge, pI, GRAVY, MW, extinction
+  coefficients, instability and aliphatic indices, aromaticity, AA composition)
+  for peptide and antibody/TCR sequence inputs. The block auto-detects modality
+  from the input axes and degrades gracefully on partial coverage: CDR3
+  properties when CDR3 is present, full-chain VH/VL when all seven IMGT regions
+  are exported, and Fv-level properties when both chains reconstruct. An R11c
+  heuristic flags likely VHH/single-domain inputs.
+
+  Property math uses BioPython ProtParam + IsoelectricPoint with IPC 2.0 pKa
+  overrides — peptide set for peptide and CDR3 inputs, protein set for full
+  VH/VL. Charge and pI round to 3 decimals at the output boundary; combined
+  with sorted Tengo iteration, canonical-JSON resources, and sorted TSV writes,
+  output bytes hash identically across runs so the block joins the dedup path.
+
+  M3 validation is locked down by `tests/unit/test_m3_validation.py` (38 cases:
+  ≥5 VH pI, ≥2 VL pI, Fv on ≥2 paired chains, ≥10 CDR-H3 charge, ≥3 CDR-L3
+  charge, ≥3 VH aliphatic) against pinned IPC 2.0 webserver values and an
+  independent Henderson-Hasselbalch reference.
+
+  Block title is the static "Sequence Properties"; the selected input dataset
+  appears as the subtitle.
+
+### Patch Changes
+
+- Updated dependencies [1059d80]
+  - @platforma-open/MiLaboratories.sequence-properties.software@1.1.0

package/dist/index.cjs

@@ -0,0 +1,4 @@
+module.exports = { Templates: {
+  'process': { type: 'from-file', path: require.resolve('./tengo/tpl/process.plj.gz') },
+  'main': { type: 'from-file', path: require.resolve('./tengo/tpl/main.plj.gz') }
+}};

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+declare type TemplateFromFile = { readonly type: "from-file"; readonly path: string; };
+declare type TplName = "process" | "main";
+declare const Templates: Record<TplName, TemplateFromFile>;
+export { Templates };

package/dist/index.js

@@ -0,0 +1,5 @@
+import { resolve } from 'node:path';
+export const Templates = {
+  'process': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/process.plj.gz') },
+  'main': { type: 'from-file', path: resolve(import.meta.dirname, './tengo/tpl/main.plj.gz') }
+};

package/dist/tengo/lib/messages.lib.tengo

@@ -0,0 +1,58 @@
+
+
+
+
+
+
+
+ll := import("@platforma-sdk/workflow-tengo:ll")
+
+partialChainMissingFullChain := func(present, chainLabel) {
+	return "Partial-region input: " + string(present) + " of 7 required regions found for " +
+		chainLabel + " chain — full-chain properties not computed. " +
+		"All seven regions (FR1, CDR1, FR2, CDR2, FR3, CDR3, FR4) are required."
+}
+
+partialChainNoCdr3 := func(present, chainLabel) {
+	return "Partial-region input: " + string(present) + " of 7 required regions found for " +
+		chainLabel + " chain (CDR3 absent) — no per-chain properties computed. " +
+		"CDR3 is required for per-chain charge / hydrophobicity; " +
+		"all seven regions are required for full-chain properties."
+}
+
+noRecognizedColumns := func() {
+	return "No recognized VDJ region columns found in the input dataset."
+}
+
+cdr3OnlyInput := func() {
+	return "CDR3-only input detected — full-chain properties not computed. " +
+		"To enable them, use a MiXCR preset that exports all VDJ regions."
+}
+
+gammaDeltaTcr := func() {
+	return "γδ TCR input detected — displaying with γδ-specific labels; " +
+		"Fv columns are not computed for TCR inputs."
+}
+
+receptorNotDetected := func() {
+	return "Receptor type not detected on the input dataset; defaulting to antibody labels. " +
+		"Use a MiXCR preset that emits the receptor annotation if this is a TCR dataset."
+}
+
+
+vhh := func() {
+	return "Possible VHH/single-domain antibody input detected (heavy chain only; " +
+		"CDR-H3 length distribution consistent with VHH). IgG-calibrated CDR-H3 length " +
+		"thresholds (>15 aa elevated risk, >20 aa high risk) do not apply to VHH — " +
+		"disregard these thresholds for nanobody libraries."
+}
+
+export ll.toStrict({
+	partialChainMissingFullChain: partialChainMissingFullChain,
+	partialChainNoCdr3: partialChainNoCdr3,
+	noRecognizedColumns: noRecognizedColumns,
+	cdr3OnlyInput: cdr3OnlyInput,
+	gammaDeltaTcr: gammaDeltaTcr,
+	receptorNotDetected: receptorNotDetected,
+	vhh: vhh
+})

package/format.el

@@ -0,0 +1,43 @@
+;; This program formats all files inside src directory. Usage: emacs --script ./format.el
+
+(defun install-go-mode ()
+  "Installs go-mode"
+  (require 'package)
+  (add-to-list 'package-archives
+               '("melpa-stable" . "https://stable.melpa.org/packages/"))
+  (package-initialize)
+  (unless package-archive-contents
+    (package-refresh-contents))
+
+  (package-install 'go-mode t)
+  (require 'go-mode))
+
+;; spaces -> tabs only at the beginning of lines
+(setq tabify-regexp "^\t* [ \t]+")
+
+(defun format-file (file)
+  "Formats a file according to slightly changed Go rules"
+  (message "Format %s" file)
+  (save-excursion
+    (find-file file)
+    (delete-trailing-whitespace)            ;; deletes whitespaces
+    (go-mode)                               ;; sets golang rules for indentation
+    (tabify (point-min) (point-max))        ;; spaces -> tabs in the whole file
+    (indent-region (point-min) (point-max)) ;; indentation in the whole file
+    (save-buffer)))                         ;; save file
+
+(install-go-mode)
+
+;; change syntax of a standard go-mode a bit
+(advice-add
+ 'go--in-composite-literal-p
+ :filter-return
+ (lambda (&rest r) t))
+
+;; find all files in src
+(setq files (directory-files-recursively "src" "\\.tengo\\'"))
+
+;; call format on every file.
+(dolist (file files)
+  (format-file file))
+

package/index.d.ts

@@ -0,0 +1,4 @@
+declare type TemplateFromFile = { readonly type: "from-file"; readonly path: string; };
+declare type TplName = "main";
+declare const Templates: Record<TplName, TemplateFromFile>;
+export { Templates };

package/index.js

@@ -0,0 +1,3 @@
+module.exports = { Templates: {
+  'main': { type: 'from-file', path: require.resolve('./dist/tengo/tpl/main.plj.gz') }
+}}

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@platforma-open/milaboratories.sequence-properties.workflow",
+  "version": "1.1.1",
+  "description": "Block Workflow",
+  "type": "module",
+  "dependencies": {
+    "@platforma-sdk/workflow-tengo": "5.16.0",
+    "@platforma-open/milaboratories.sequence-properties.software": "1.1.0"
+  },
+  "devDependencies": {
+    "@platforma-sdk/tengo-builder": "2.5.17",
+    "@platforma-sdk/test": "1.69.0"
+  },
+  "peerDependencies": {
+    "vitest": "*"
+  },
+  "scripts": {
+    "build": "shx rm -rf dist && pl-tengo check && pl-tengo build",
+    "test": "vitest",
+    "format": "/usr/bin/env emacs --script ./format.el"
+  }
+}

package/src/main.tpl.tengo

@@ -0,0 +1,365 @@
+// Sequence Properties — workflow root.
+//
+// Detects modality (peptide vs antibody/TCR), collects amino-acid sequence columns,
+// builds a per-entity TSV, runs the Python computation step, and hands off to
+// process.tpl.tengo for output PColumn construction.
+
+wf := import("@platforma-sdk/workflow-tengo:workflow")
+exec := import("@platforma-sdk/workflow-tengo:exec")
+assets := import("@platforma-sdk/workflow-tengo:assets")
+render := import("@platforma-sdk/workflow-tengo:render")
+smart := import("@platforma-sdk/workflow-tengo:smart")
+ll := import("@platforma-sdk/workflow-tengo:ll")
+pframes := import("@platforma-sdk/workflow-tengo:pframes")
+canonical := import("@platforma-sdk/workflow-tengo:canonical")
+maps := import("@platforma-sdk/workflow-tengo:maps")
+constants := import("@platforma-sdk/workflow-tengo:constants")
+messages := import(":messages")
+
+processTpl := assets.importTemplate(":process")
+
+// JSON resource with sorted-key canonical bytes. smart.createJsonResource uses
+// Tengo's stdlib json.encode, which preserves Go's randomized map iteration —
+// resource bytes vary across runs and the CID becomes non-deterministic,
+// defeating dedup. canonical.encode sorts keys at every level so identical
+// values always produce identical bytes.
+canonicalJsonResource := func(value) {
+	return smart.createValueResource(constants.RTYPE_JSON, canonical.encode(value))
+}
+
+REQUIRED_FEATURES := ["FR1", "CDR1", "FR2", "CDR2", "FR3", "CDR3", "FR4"]
+
+detectMode := func(axisSpec) {
+	dom := axisSpec.domain
+	if axisSpec.name == "pl7.app/variantKey" {
+		if dom != undefined && dom["pl7.app/peptide/extractionRunId"] != undefined {
+			return "peptide"
+		}
+		if dom != undefined && dom["pl7.app/vdj/clonotypingRunId"] != undefined {
+			return "antibody_tcr_universal"
+		}
+	}
+	if axisSpec.name == "pl7.app/vdj/cloneId" {
+		return "antibody_tcr_legacy_bulk"
+	}
+	if axisSpec.name == "pl7.app/vdj/clonotypeKey" {
+		return "antibody_tcr_legacy_bulk"
+	}
+	if axisSpec.name == "pl7.app/vdj/scClonotypeKey" {
+		return "antibody_tcr_legacy_sc"
+	}
+	return ""
+}
+
+contains := func(arr, x) {
+	for v in arr {
+		if v == x { return true }
+	}
+	return false
+}
+
+wf.prepare(func(args) {
+	bb := wf.createPBundleBuilder()
+	bb.ignoreMissingDomains()
+	bb.addAnchor("main", args.inputAnchor)
+
+	// Peptide sequence column (universal naming, post-peptide-extraction).
+	bb.addMulti({
+		axes: [{ anchor: "main", idx: 1 }],
+		name: "pl7.app/sequence",
+		domain: {
+			"pl7.app/feature": "peptide",
+			"pl7.app/alphabet": "aminoacid"
+		}
+	}, "peptideSequences")
+
+	// VDJ region columns (legacy MiXCR path).
+	// Filter on alphabet only — NOT on pl7.app/vdj/isAssemblingFeature, per spec R4.
+	bb.addMulti({
+		axes: [{ anchor: "main", idx: 1 }],
+		name: "pl7.app/vdj/sequence",
+		domain: {
+			"pl7.app/alphabet": "aminoacid"
+		}
+	}, "vdjSequences")
+
+	// Universal-naming VDJ region columns (forward compatibility, post-MiXCR migration).
+	bb.addMulti({
+		axes: [{ anchor: "main", idx: 1 }],
+		name: "pl7.app/sequence",
+		domain: {
+			"pl7.app/alphabet": "aminoacid"
+		}
+	}, "universalSequences")
+
+	return { columns: bb.build() }
+})
+
+wf.body(func(args) {
+	blockId := wf.blockId().getDataAsJson()
+	bundle := args.columns
+	datasetSpec := bundle.getSpec(args.inputAnchor)
+
+	axes := datasetSpec.axesSpec
+	if len(axes) == 0 {
+		ll.panic("input anchor has no axes")
+	}
+
+	// R1a: first axis matching a recognized name + domain. Equivalent to
+	// `axes[len-1]` on every observed `[sampleId, key]` input.
+	keyAxisIdx := -1
+	keyAxisSpec := undefined
+	mode := ""
+	for i, axisSpec in axes {
+		m := detectMode(axisSpec)
+		if m != "" {
+			keyAxisIdx = i
+			keyAxisSpec = axisSpec
+			mode = m
+			break
+		}
+	}
+	if mode == "" {
+		ll.panic("no recognized sequence key axis found; connect a peptide extraction or MiXCR clonotyping dataset")
+	}
+
+	infoMessages := []
+	receptor := "IG" // R13b: default when receptor key absent
+	receptorSeen := false
+
+	// Spec deviation SD-003 — see docs/spec-deviations.md.
+	// MiXCR places the receptor key on the clonotypeKey AXIS domain (the input
+	// anchor's secondary axis), not on per-region sequence column domains. Read
+	// from the axis first; the per-column check inside the loop stays as a
+	// fallback for non-MiXCR producers.
+	if keyAxisSpec.domain != undefined {
+		axisR := keyAxisSpec.domain["pl7.app/vdj/receptor"]
+		if axisR == "IG" || axisR == "TCRAB" || axisR == "TCRGD" {
+			receptor = axisR
+			receptorSeen = true
+		}
+	}
+
+	chainsFound := {} // chain -> { feature -> 1 }
+
+	seqTb := pframes.tsvFileBuilder()
+	seqTb.setAxisHeader(keyAxisSpec, "entity_key")
+
+	if mode == "peptide" {
+		peptideCols := bundle.getColumns("peptideSequences")
+		if len(peptideCols) == 0 {
+			ll.panic("peptide mode detected but no peptide amino-acid sequence column was found in the input dataset")
+		}
+		seqTb.add(bundle.getColumn(peptideCols[0].key), { header: "sequence" })
+
+	} else {
+		// Legacy MiXCR sequences first; fall back to universal naming for forward
+		// compatibility with the post-MiXCR-migration column shape.
+		vdjCols := bundle.getColumns("vdjSequences")
+		if len(vdjCols) == 0 {
+			vdjCols = bundle.getColumns("universalSequences")
+		}
+		if len(vdjCols) == 0 {
+			ll.panic("antibody/TCR mode detected but no amino-acid VDJ sequence columns found")
+		}
+
+		for s in vdjCols {
+			d := s.spec.domain
+			if d == undefined { continue }
+
+			feat := d["pl7.app/vdj/feature"]
+			if d["pl7.app/feature"] != undefined { feat = d["pl7.app/feature"] }
+
+			// Spec deviation SD-002 — see docs/spec-deviations.md.
+			// MiXCR emits FR4 only as "FR4InFrame" (in-frame-filtered translation).
+			// Normalise to "FR4" so the REQUIRED_FEATURES check and downstream
+			// header naming treat it as the canonical FR4 region.
+			if feat == "FR4InFrame" { feat = "FR4" }
+
+			if !contains(REQUIRED_FEATURES, feat) { continue }
+
+			// Spec deviation SD-001 — see docs/spec-deviations.md.
+			// MiXCR single-cell emits primary + secondary alleles per chain. Spec assumes
+			// one allele per chain slot; secondary alleles would collide on the TSV header.
+			// Keep primary only.
+			idx := d["pl7.app/vdj/scClonotypeChain/index"]
+			if idx != undefined && idx != "primary" { continue }
+
+			chain := d["pl7.app/vdj/scClonotypeChain"]
+			if chain == undefined || chain == "" {
+				// Bulk MiXCR data without chain annotation — assume primary chain "A".
+				chain = "A"
+			}
+
+			// Same receptor value is expected on every input column; last seen wins.
+			r := d["pl7.app/vdj/receptor"]
+			if r == "IG" || r == "TCRAB" || r == "TCRGD" {
+				receptor = r
+				receptorSeen = true
+			}
+
+			header := chain + "_" + feat
+			seqTb.add(bundle.getColumn(s.key), { header: header })
+
+			if chainsFound[chain] == undefined { chainsFound[chain] = {} }
+			chainsFound[chain][feat] = 1
+		}
+	}
+
+	// Receptor-aware chain label for user-facing messages (R11b).
+	chainLabel := func(ch) {
+		if receptor == "TCRAB" {
+			if ch == "A" { return "alpha" }
+			if ch == "B" { return "beta" }
+		}
+		if receptor == "TCRGD" {
+			if ch == "A" { return "gamma" }
+			if ch == "B" { return "delta" }
+		}
+		// IG / unknown — antibody convention.
+		if ch == "A" { return "heavy" }
+		if ch == "B" { return "light" }
+		return ch
+	}
+
+	fullChain := {}
+	cdr3Only := {}
+	chainsWithCdr3 := []
+	if mode != "peptide" {
+		// Sorted iteration so partial-region messages append in a stable order.
+		chainKeys := maps.getKeys(chainsFound)
+		for _, chain in chainKeys {
+			feats := chainsFound[chain]
+			present := 0
+			for rf in REQUIRED_FEATURES {
+				if feats[rf] { present += 1 }
+			}
+			if feats["CDR3"] {
+				chainsWithCdr3 += [chain]
+			}
+			if present == len(REQUIRED_FEATURES) {
+				fullChain[chain] = true
+			} else if feats["CDR3"] && present == 1 {
+				cdr3Only[chain] = true
+			} else if feats["CDR3"] {
+				infoMessages += [messages.partialChainMissingFullChain(present, chainLabel(chain))]
+			} else {
+				// Chain has 1-6 of 7 regions but lacks CDR3 — neither CDR3-mode nor
+				// full-chain mode applies. Without R11b's surfaced silent fallthrough
+				// the user would see neither full-chain nor CDR3 columns and no
+				// explanation why.
+				infoMessages += [messages.partialChainNoCdr3(present, chainLabel(chain))]
+			}
+		}
+		anyChain := len(chainKeys) > 0
+		if !anyChain {
+			infoMessages += [messages.noRecognizedColumns()]
+		}
+
+		if len(cdr3Only) > 0 && len(fullChain) == 0 {
+			infoMessages += [messages.cdr3OnlyInput()]
+		}
+		if receptor == "TCRGD" {
+			infoMessages += [messages.gammaDeltaTcr()]
+		}
+		// R13b: warn when no recognised receptor was seen — defaults to IG.
+		if !receptorSeen && anyChain {
+			infoMessages += [messages.receptorNotDetected()]
+		}
+	}
+
+	seqTb.mem("4GiB")
+	seqTb.cpu(1)
+	seqTable := seqTb.build()
+
+	// Sorted lists feed both plan.json (Python step input) and the params
+	// resource (process template input) — they must hash deterministically so
+	// the CIDs land on the dedup path across runs of identical input.
+	hasFv := mode != "peptide" && receptor == "IG" && fullChain["A"] && fullChain["B"]
+	chainList := maps.getKeys(chainsFound)
+	fullChainList := maps.getKeys(fullChain)
+
+	plan := {
+		mode: mode,
+		receptor: receptor,
+		chains: chainList,
+		fullChains: fullChainList,
+		hasFv: hasFv
+	}
+
+	// Python step contract: reads input.tsv + plan.json; writes properties.tsv,
+	// plus aa_fraction.tsv in peptide mode (empty body in antibody/TCR mode), plus
+	// stats.json (dataset-level scalars consumed by the info layer — e.g. R11c
+	// median CDR-H3 length per chain).
+	soft := assets.importSoftware("@platforma-open/milaboratories.sequence-properties.software:compute-properties")
+	pyRun := exec.builder().
+		software(soft).
+		mem("4GiB").
+		cpu(1).
+		addFile("input.tsv", seqTable).
+		writeFile("plan.json", canonical.encode(plan)).
+		arg("--input").arg("input.tsv").
+		arg("--plan").arg("plan.json").
+		arg("--output").arg("properties.tsv").
+		arg("--aa-fraction").arg("aa_fraction.tsv").
+		arg("--stats").arg("stats.json").
+		saveFile("properties.tsv").
+		saveFile("aa_fraction.tsv").
+		saveFileContent("stats.json").
+		saveStderrStream().
+		run()
+
+	propertiesTsv := pyRun.getFile("properties.tsv")
+	aaFractionTsv := pyRun.getFile("aa_fraction.tsv")
+	statsResource := pyRun.getFileContent("stats.json")
+	processingLog := pyRun.getStderrStream()
+
+	coverageTier := "peptide"
+	if mode != "peptide" {
+		if len(fullChainList) > 0 {
+			coverageTier = "full_chain"
+		} else if len(infoMessages) > 0 {
+			coverageTier = "cdr3_only"
+		} else {
+			coverageTier = "partial"
+		}
+	}
+
+	// Hand off to process template for column specs, pFrame export, and
+	// info-blob assembly. The info blob depends on Python's stats output, so
+	// it builds inside the render template rather than at workflow body time.
+	processResult := render.create(processTpl, {
+		blockId: blockId,
+		propertiesTsv: propertiesTsv,
+		aaFractionTsv: aaFractionTsv,
+		stats: statsResource,
+		params: canonicalJsonResource({
+			datasetSpec: datasetSpec,
+			keyAxisIdx: keyAxisIdx,
+			mode: mode,
+			receptor: receptor,
+			chains: chainList,
+			chainsWithCdr3: chainsWithCdr3,
+			fullChains: fullChainList,
+			hasFv: hasFv,
+			coverageTier: coverageTier,
+			infoMessages: infoMessages
+		})
+	})
+
+	// Cache outputs for 24 hours (ms) to skip re-running identical work.
+	propertiesPf := processResult.output("propertiesPf", 24 * 60 * 60 * 1000)
+	exportPframe := processResult.output("exportPframe", 24 * 60 * 60 * 1000)
+	infoBlob := processResult.output("info", 24 * 60 * 60 * 1000)
+
+	return {
+		outputs: {
+			propertiesPf: propertiesPf,
+			info: infoBlob,
+			processingLog: processingLog
+		},
+		exports: {
+			properties: exportPframe
+		}
+	}
+})

package/src/messages.lib.tengo

@@ -0,0 +1,58 @@
+// User-facing info messages emitted by the workflow.
+//
+// Centralised so the inventory of UX strings is scannable in one place.
+// Each helper returns a single message string; callers append it to the
+// running info-message list. Receptor/chain rendering is the caller's job —
+// helpers accept already-rendered chain labels.
+
+ll := import("@platforma-sdk/workflow-tengo:ll")
+
+partialChainMissingFullChain := func(present, chainLabel) {
+	return "Partial-region input: " + string(present) + " of 7 required regions found for " +
+		chainLabel + " chain — full-chain properties not computed. " +
+		"All seven regions (FR1, CDR1, FR2, CDR2, FR3, CDR3, FR4) are required."
+}
+
+partialChainNoCdr3 := func(present, chainLabel) {
+	return "Partial-region input: " + string(present) + " of 7 required regions found for " +
+		chainLabel + " chain (CDR3 absent) — no per-chain properties computed. " +
+		"CDR3 is required for per-chain charge / hydrophobicity; " +
+		"all seven regions are required for full-chain properties."
+}
+
+noRecognizedColumns := func() {
+	return "No recognized VDJ region columns found in the input dataset."
+}
+
+cdr3OnlyInput := func() {
+	return "CDR3-only input detected — full-chain properties not computed. " +
+		"To enable them, use a MiXCR preset that exports all VDJ regions."
+}
+
+gammaDeltaTcr := func() {
+	return "γδ TCR input detected — displaying with γδ-specific labels; " +
+		"Fv columns are not computed for TCR inputs."
+}
+
+receptorNotDetected := func() {
+	return "Receptor type not detected on the input dataset; defaulting to antibody labels. " +
+		"Use a MiXCR preset that emits the receptor annotation if this is a TCR dataset."
+}
+
+// R11c — single-domain antibody (VHH / nanobody) heuristic.
+vhh := func() {
+	return "Possible VHH/single-domain antibody input detected (heavy chain only; " +
+		"CDR-H3 length distribution consistent with VHH). IgG-calibrated CDR-H3 length " +
+		"thresholds (>15 aa elevated risk, >20 aa high risk) do not apply to VHH — " +
+		"disregard these thresholds for nanobody libraries."
+}
+
+export ll.toStrict({
+	partialChainMissingFullChain: partialChainMissingFullChain,
+	partialChainNoCdr3: partialChainNoCdr3,
+	noRecognizedColumns: noRecognizedColumns,
+	cdr3OnlyInput: cdr3OnlyInput,
+	gammaDeltaTcr: gammaDeltaTcr,
+	receptorNotDetected: receptorNotDetected,
+	vhh: vhh
+})

package/src/process.tpl.tengo

@@ -0,0 +1,474 @@
+// Process — receives the property TSV(s) from the Python step and the column-emission
+// plan from main.tpl.tengo, builds output PColumn specs per the project's pcolumn-spec.md,
+// imports the file as a pFrame, and returns the result and a sliced export pFrame.
+
+self := import("@platforma-sdk/workflow-tengo:tpl")
+xsv := import("@platforma-sdk/workflow-tengo:pframes.xsv")
+pframes := import("@platforma-sdk/workflow-tengo:pframes")
+pSpec := import("@platforma-sdk/workflow-tengo:pframes.spec")
+maps := import("@platforma-sdk/workflow-tengo:maps")
+smart := import("@platforma-sdk/workflow-tengo:smart")
+canonical := import("@platforma-sdk/workflow-tengo:canonical")
+constants := import("@platforma-sdk/workflow-tengo:constants")
+messages := import(":messages")
+
+self.defineOutputs("propertiesPf", "exportPframe", "info")
+
+// Receptor + chain → human label fragments (CDR3 / full-chain).
+// Spec R13a: PColumn name and chain domain are unchanged; only the label varies.
+labelFragments := func(receptor, chain) {
+	if receptor == "TCRAB" {
+		if chain == "A" { return { cdr3: "CDR-α3", fullChain: "Vα" } }
+		if chain == "B" { return { cdr3: "CDR-β3", fullChain: "Vβ" } }
+	}
+	if receptor == "TCRGD" {
+		if chain == "A" { return { cdr3: "CDR-γ3", fullChain: "Vγ" } }
+		if chain == "B" { return { cdr3: "CDR-δ3", fullChain: "Vδ" } }
+	}
+	// IG / unknown — antibody convention.
+	if chain == "A" { return { cdr3: "CDR-H3", fullChain: "VH" } }
+	return { cdr3: "CDR-L3", fullChain: "VL" }
+}
+
+// Build a single output column descriptor consumed by xsv.importFile.
+// `tsvCol` is the TSV column header emitted by Python (e.g. "charge_peptide", "charge_A_CDR3").
+// Clones the caller's `annotations` dict — mutating it in place would stamp
+// the label into shared references if any caller ever reused the literal,
+// the same aliasing footgun that the export-domain clone below already guards.
+makeCol := func(tsvCol, valName, valueType, label, domain, annotations) {
+	newAnnotations := {}
+	if annotations {
+		for k, v in annotations {
+			newAnnotations[k] = v
+		}
+	}
+	newAnnotations["pl7.app/label"] = label
+	spec := {
+		name: valName,
+		valueType: valueType,
+		domain: domain,
+		annotations: newAnnotations
+	}
+	return { column: tsvCol, id: tsvCol, naRegex: "", allowNA: true, spec: spec }
+}
+
+self.body(func(args) {
+	blockId := args.blockId
+	propertiesTsv := args.propertiesTsv
+	params := args.params
+
+	datasetSpec := params.datasetSpec
+	keyAxisIdx := params.keyAxisIdx
+	mode := params.mode
+	receptor := params.receptor
+	chains := params.chains
+	chainsWithCdr3 := params.chainsWithCdr3
+	fullChains := params.fullChains
+	hasFv := params.hasFv
+	coverageTier := params.coverageTier
+	infoMessages := params.infoMessages
+
+	stats := args.stats.getDataAsJson()
+	medians := stats.medianCdr3Length
+
+	// R11c — single-domain antibodies (nanobodies / VHH) miss the IgG-calibrated
+	// CDR-H3 length risk thresholds. Surface an info message when the dataset
+	// looks like VHH (heavy chain only, long median CDR-H3 ≥ 16 aa).
+	if receptor == "IG" && len(chainsWithCdr3) == 1 && chainsWithCdr3[0] == "A" {
+		medA := medians["A"]
+		if medA != undefined && medA >= 16 {
+			infoMessages += [messages.vhh()]
+		}
+	}
+
+	infoBlob := smart.createValueResource(constants.RTYPE_JSON, canonical.encode({
+		mode: mode,
+		receptor: receptor,
+		coverageTier: coverageTier,
+		messages: infoMessages
+	}))
+
+	keyAxisSpec := datasetSpec.axesSpec[keyAxisIdx]
+
+	axes := [{ column: "entity_key", spec: keyAxisSpec }]
+	columns := []
+
+	if mode == "peptide" {
+		// Peptide mode — 9 scalar properties on `pl7.app/feature: "peptide"`.
+		dom := { "pl7.app/feature": "peptide" }
+
+		columns += [makeCol("charge_peptide", "pl7.app/charge", "Double",
+			"Net Charge (pH 7)", dom, {
+				"pl7.app/format": ".2f",
+				"pl7.app/isScore": "true",
+				"pl7.app/description": "Net charge at pH 7 (Henderson-Hasselbalch, IPC 2.0 peptide pKa set). Positive = net basic (Arg, Lys, His dominate); negative = net acidic (Asp, Glu dominate). No universal preferred direction.",
+				"pl7.app/table/visibility": "default",
+				"pl7.app/table/orderPriority": "70000"
+			})]
+
+		columns += [makeCol("gravy_peptide", "pl7.app/hydrophobicity", "Double",
+			"Hydrophobicity (GRAVY)", dom, {
+				"pl7.app/format": ".3f",
+				"pl7.app/isScore": "true",
+				"pl7.app/score/rankingOrder": "increasing",
+				"pl7.app/description": "rankingOrder: increasing reflects preference for lower hydrophobicity. Invert direction in Lead Selection for hydrophobic-target applications.",
+				"pl7.app/table/visibility": "default",
+				"pl7.app/table/orderPriority": "69900"
+			})]
+
+		columns += [makeCol("mw_peptide", "pl7.app/molecularWeight", "Double",
+			"Molecular Weight (Da, average masses)", dom, {
+				"pl7.app/format": ".1f",
+				"pl7.app/min": "0",
+				"pl7.app/table/visibility": "default",
+				"pl7.app/table/orderPriority": "69800"
+			})]
+
+		columns += [makeCol("pi_peptide", "pl7.app/isoelectricPoint", "Double",
+			"Isoelectric Point (pI)", dom, {
+				"pl7.app/format": ".2f",
+				"pl7.app/min": "0",
+				"pl7.app/max": "14",
+				"pl7.app/table/visibility": "default",
+				"pl7.app/table/orderPriority": "69700"
+			})]
+
+		columns += [makeCol("eox_peptide", "pl7.app/extinctionCoefficientOx", "Double",
+			"Extinction Coeff., Oxidized (M⁻¹cm⁻¹)", dom, {
+				"pl7.app/format": ".0f",
+				"pl7.app/min": "0",
+				"pl7.app/description": "Assumes all Cys are in disulfide bonds. For unprotected linear peptides use the reduced form.",
+				"pl7.app/table/visibility": "optional",
+				"pl7.app/table/orderPriority": "69600"
+			})]
+
+		columns += [makeCol("ered_peptide", "pl7.app/extinctionCoefficientRed", "Double",
+			"Extinction Coeff., Reduced (M⁻¹cm⁻¹)", dom, {
+				"pl7.app/format": ".0f",
+				"pl7.app/min": "0",
+				"pl7.app/description": "Extinction coefficient at 280 nm, disulfide bonds reduced (Cys contribution omitted). A value of 0 means no Tyr or Trp — A280-based quantification is not possible.",
+				"pl7.app/table/visibility": "optional",
+				"pl7.app/table/orderPriority": "69500"
+			})]
+
+		columns += [makeCol("instability_peptide", "pl7.app/instabilityIndex", "Double",
+			"Instability Index", dom, {
+				"pl7.app/format": ".2f",
+				"pl7.app/description": "Guruprasad index — derived from globular proteins. The II > 40 threshold does not apply to short linear peptides; use as a relative composition ranking aid only.",
+				"pl7.app/table/visibility": "default",
+				"pl7.app/table/orderPriority": "69400"
+			})]
+
+		columns += [makeCol("aliphatic_peptide", "pl7.app/aliphaticIndex", "Double",
+			"Aliphatic Index", dom, {
+				"pl7.app/format": ".1f",
+				"pl7.app/min": "0",
+				"pl7.app/description": "Measures fraction of nonpolar aliphatic residues (Ala, Val, Ile, Leu). For short linear peptides, thermostability interpretation does not apply — the Ikai index was derived for globular mesophilic enzymes, and thermostability is not a meaningful concept for unstructured peptides. Useful as a composition indicator and a proxy for hydrophobic character alongside GRAVY — both metrics increase with Ala/Val/Ile/Leu content, but neither has a universal preferred direction for therapeutic peptides.",
+				"pl7.app/table/visibility": "optional",
+				"pl7.app/table/orderPriority": "69300"
+			})]
+
+		columns += [makeCol("aromaticity_peptide", "pl7.app/aromaticity", "Double",
+			"Aromaticity", dom, {
+				"pl7.app/format": ".3f",
+				"pl7.app/min": "0",
+				"pl7.app/max": "1",
+				"pl7.app/description": "Fraction of aromatic residues (Phe, Trp, Tyr).",
+				"pl7.app/table/visibility": "optional",
+				"pl7.app/table/orderPriority": "69200"
+			})]
+
+	} else {
+		// Antibody/TCR mode — CDR3 columns per chain, full-chain when present, Fv when paired.
+		// CDR-H3 (chain A) and CDR-L3 (chain B) carry different descriptions per
+		// pcolumn-spec.md — different developability signals.
+		cdr3ChargeDesc := {
+			A: "Strongly positive CDR3 charge correlates with polyreactivity via electrostatic interactions. No universal preferred direction in Lead Selection. IPC 2.0 peptide pKa set.",
+			B: "Strongly positive CDR-L3 charge contributes to paratope polyreactivity. Strongly negative charge is primarily a PK concern. No universal preferred direction. IPC 2.0 peptide pKa set."
+		}
+		cdr3GravyDesc := {
+			A: "Lower hydrophobicity preferred for developability. CDR3 GRAVY > 0 is an informal aggregation/polyreactivity heuristic.",
+			B: "Same aggregation and polyreactivity signal as CDR-H3 hydrophobicity; lower independent predictive weight. The TAP score uses combined 6-CDR GRAVY — CDR-L3 alone has limited independent validation."
+		}
+		cdr3OrderA := 68000
+		cdr3OrderB := 67700
+		for chain in chains {
+			frag := labelFragments(receptor, chain)
+			cdr3Dom := { "pl7.app/feature": "CDR3", "pl7.app/vdj/scClonotypeChain": chain }
+			chargeOrder := (chain == "A" ? cdr3OrderA : cdr3OrderB)
+			gravyOrder := chargeOrder - 100
+
+			columns += [makeCol("charge_" + chain + "_CDR3", "pl7.app/charge", "Double",
+				frag.cdr3 + " Net Charge (pH 7)", cdr3Dom, {
+					"pl7.app/format": ".2f",
+					"pl7.app/isScore": "true",
+					"pl7.app/description": cdr3ChargeDesc[chain],
+					"pl7.app/table/visibility": "default",
+					"pl7.app/table/orderPriority": string(chargeOrder)
+				})]
+			columns += [makeCol("gravy_" + chain + "_CDR3", "pl7.app/hydrophobicity", "Double",
+				frag.cdr3 + " Hydrophobicity (GRAVY)", cdr3Dom, {
+					"pl7.app/format": ".3f",
+					"pl7.app/isScore": "true",
+					"pl7.app/score/rankingOrder": "increasing",
+					"pl7.app/description": cdr3GravyDesc[chain],
+					"pl7.app/table/visibility": "default",
+					"pl7.app/table/orderPriority": string(gravyOrder)
+				})]
+		}
+
+		// Full-chain columns (9 per chain when reconstructed).
+		fcOrderBaseA := 67000
+		fcOrderBaseB := 66000
+		for chain in fullChains {
+			frag := labelFragments(receptor, chain)
+			fcDom := { "pl7.app/feature": "VDJRegion", "pl7.app/vdj/scClonotypeChain": chain }
+			base := (chain == "A" ? fcOrderBaseA : fcOrderBaseB)
+			fcLabel := frag.fullChain
+
+			columns += [makeCol("charge_" + chain + "_VDJRegion", "pl7.app/charge", "Double",
+				fcLabel + " Net Charge (pH 7)", fcDom, {
+					"pl7.app/format": ".2f",
+					"pl7.app/isScore": "true",
+					"pl7.app/description": "Non-monotonic vs developability: strongly positive correlates with polyreactivity; strongly negative with rapid clearance.",
+					"pl7.app/table/visibility": "default",
+					"pl7.app/table/orderPriority": string(base)
+				})]
+			columns += [makeCol("pi_" + chain + "_VDJRegion", "pl7.app/isoelectricPoint", "Double",
+				fcLabel + " Isoelectric Point (pI)", fcDom, {
+					"pl7.app/format": ".2f",
+					"pl7.app/isScore": "true",
+					"pl7.app/min": "0",
+					"pl7.app/max": "14",
+					"pl7.app/table/visibility": "default",
+					"pl7.app/table/orderPriority": string(base - 100)
+				})]
+			columns += [makeCol("gravy_" + chain + "_VDJRegion", "pl7.app/hydrophobicity", "Double",
+				fcLabel + " Hydrophobicity (GRAVY)", fcDom, {
+					"pl7.app/format": ".3f",
+					"pl7.app/description": "Framework regions dominate; weak developability signal at chain level — CDR3 hydrophobicity is more discriminating.",
+					"pl7.app/table/visibility": "default",
+					"pl7.app/table/orderPriority": string(base - 200)
+				})]
+			columns += [makeCol("mw_" + chain + "_VDJRegion", "pl7.app/molecularWeight", "Double",
+				fcLabel + " Molecular Weight (Da, average masses)", fcDom, {
+					"pl7.app/format": ".1f",
+					"pl7.app/min": "0",
+					"pl7.app/description": "Unglycosylated sequence mass — does not include N-glycan contributions from any NXS/NXT sequons in the variable region.",
+					"pl7.app/table/visibility": "optional",
+					"pl7.app/table/orderPriority": string(base - 300)
+				})]
+			columns += [makeCol("eox_" + chain + "_VDJRegion", "pl7.app/extinctionCoefficientOx", "Double",
+				fcLabel + " Extinction Coeff., Oxidized (M⁻¹cm⁻¹)", fcDom, {
+					"pl7.app/format": ".0f",
+					"pl7.app/min": "0",
+					"pl7.app/table/visibility": "optional",
+					"pl7.app/table/orderPriority": string(base - 400)
+				})]
+			columns += [makeCol("ered_" + chain + "_VDJRegion", "pl7.app/extinctionCoefficientRed", "Double",
+				fcLabel + " Extinction Coeff., Reduced (M⁻¹cm⁻¹)", fcDom, {
+					"pl7.app/format": ".0f",
+					"pl7.app/min": "0",
+					"pl7.app/table/visibility": "optional",
+					"pl7.app/table/orderPriority": string(base - 500)
+				})]
+			columns += [makeCol("instability_" + chain + "_VDJRegion", "pl7.app/instabilityIndex", "Double",
+				fcLabel + " Instability Index", fcDom, {
+					"pl7.app/format": ".2f",
+					"pl7.app/description": "Guruprasad index, calibrated for in-vitro stability of soluble globular proteins via dipeptide composition. Weak predictor of antibody Tm — use as supplementary ranking aid.",
+					"pl7.app/table/visibility": "optional",
+					"pl7.app/table/orderPriority": string(base - 600)
+				})]
+			columns += [makeCol("aliphatic_" + chain + "_VDJRegion", "pl7.app/aliphaticIndex", "Double",
+				fcLabel + " Aliphatic Index", fcDom, {
+					"pl7.app/format": ".1f",
+					"pl7.app/min": "0",
+					"pl7.app/description": "Ikai aliphatic index, derived from globular mesophilic enzymes. Weak correlation with antibody Tm. No rankingOrder — high values can correlate with aggregation propensity.",
+					"pl7.app/table/visibility": "optional",
+					"pl7.app/table/orderPriority": string(base - 700)
+				})]
+			columns += [makeCol("aromaticity_" + chain + "_VDJRegion", "pl7.app/aromaticity", "Double",
+				fcLabel + " Aromaticity", fcDom, {
+					"pl7.app/format": ".3f",
+					"pl7.app/min": "0",
+					"pl7.app/max": "1",
+					"pl7.app/description": "Fraction of aromatic residues (Phe, Trp, Tyr) over the full chain. Framework dominates; CDR-specific aromaticity is a stronger predictor (Phase 2).",
+					"pl7.app/table/visibility": "optional",
+					"pl7.app/table/orderPriority": string(base - 800)
+				})]
+		}
+
+		// Fv columns — only when both VH and VL full chains reconstructed (antibody only).
+		if hasFv {
+			fvDom := { "pl7.app/feature": "Fv" }
+			columns += [makeCol("charge_Fv", "pl7.app/charge", "Double",
+				"Fv Net Charge (pH 7)", fvDom, {
+					"pl7.app/format": ".2f",
+					"pl7.app/isScore": "true",
+					"pl7.app/table/visibility": "default",
+					"pl7.app/table/orderPriority": "65100"
+				})]
+			columns += [makeCol("pi_Fv", "pl7.app/isoelectricPoint", "Double",
+				"Fv Isoelectric Point (pI)", fvDom, {
+					"pl7.app/format": ".2f",
+					"pl7.app/isScore": "true",
+					"pl7.app/min": "0",
+					"pl7.app/max": "14",
+					"pl7.app/description": "Variable region (VH+VL) only. Fv pI is typically 2–4 pH units higher than whole-IgG cIEF measurements, which include constant regions (IgG1 Fc pI ≈ 5–6).",
+					"pl7.app/table/visibility": "default",
+					"pl7.app/table/orderPriority": "65000"
+				})]
+			columns += [makeCol("eox_Fv", "pl7.app/extinctionCoefficientOx", "Double",
+				"Fv Extinction Coeff., Oxidized (M⁻¹cm⁻¹)", fvDom, {
+					"pl7.app/format": ".0f",
+					"pl7.app/min": "0",
+					"pl7.app/description": "Variable region (VH+VL) only — does not include constant regions. For whole-IgG A280 quantification, use the full-antibody ε.",
+					"pl7.app/table/visibility": "optional",
+					"pl7.app/table/orderPriority": "64900"
+				})]
+			columns += [makeCol("ered_Fv", "pl7.app/extinctionCoefficientRed", "Double",
+				"Fv Extinction Coeff., Reduced (M⁻¹cm⁻¹)", fvDom, {
+					"pl7.app/format": ".0f",
+					"pl7.app/min": "0",
+					"pl7.app/description": "Variable region (VH+VL) only, disulfide bonds reduced (Cys contribution omitted). A value of 0 means no Tyr or Trp — A280-based quantification is not possible.",
+					"pl7.app/table/visibility": "optional",
+					"pl7.app/table/orderPriority": "64800"
+				})]
+			columns += [makeCol("mw_Fv", "pl7.app/molecularWeight", "Double",
+				"Fv Molecular Weight (Da, average masses)", fvDom, {
+					"pl7.app/format": ".1f",
+					"pl7.app/min": "0",
+					"pl7.app/description": "Unglycosylated sequence mass (VH + VL).",
+					"pl7.app/table/visibility": "optional",
+					"pl7.app/table/orderPriority": "64700"
+				})]
+		}
+	}
+
+	outputSpecs := {
+		axes: axes,
+		columns: columns,
+		storageFormat: "Parquet",
+		partitionKeyLength: 0
+	}
+
+	// Stamp blockId on the export-only columns (lets downstream blocks distinguish runs).
+	// Build a fresh column with a cloned domain dict — mutating col.spec.domain
+	// in place would also stamp blockId on outputSpecs.columns since both lists
+	// share the same column references.
+	exportColumns := []
+	for col in columns {
+		if col.spec.annotations && col.spec.annotations["pl7.app/isScore"] == "true" {
+			newDomain := {}
+			if col.spec.domain {
+				for k, v in col.spec.domain {
+					newDomain[k] = v
+				}
+			}
+			newDomain["pl7.app/blockId"] = blockId
+			exportColumns += [{
+				column: col.column,
+				id: col.id,
+				naRegex: col.naRegex,
+				allowNA: col.allowNA,
+				spec: {
+					name: col.spec.name,
+					valueType: col.spec.valueType,
+					domain: newDomain,
+					annotations: col.spec.annotations
+				}
+			}]
+		}
+	}
+
+	exportSpecs := {
+		axes: axes,
+		columns: exportColumns,
+		storageFormat: "Parquet",
+		partitionKeyLength: 0
+	}
+
+	scalarOut := xsv.importFile(propertiesTsv, "tsv", outputSpecs, { splitDataAndSpec: true, cpu: 1, mem: "4GiB" })
+	exportOut := xsv.importFile(propertiesTsv, "tsv", exportSpecs, { splitDataAndSpec: true, cpu: 1, mem: "4GiB" })
+
+	trace := pSpec.makeTrace(datasetSpec, {
+		type: "milaboratories.sequence-properties",
+		importance: 30,
+		label: "Sequence Properties",
+		id: blockId
+	})
+
+	// AA fraction — peptide mode only (R7). 2-axis: [variantKey, aminoAcid].
+	// The TSV is long format: entity_key, aminoAcid, value. The aminoAcid axis
+	// values are the 20 standard single-letter codes (R7).
+	aaOut := undefined
+	if mode == "peptide" {
+		aaAxes := [
+			{ column: "entity_key", spec: keyAxisSpec },
+			{
+				column: "aminoAcid",
+				spec: {
+					name: "pl7.app/aminoAcid",
+					type: "String",
+					annotations: { "pl7.app/label": "Amino Acid" }
+				}
+			}
+		]
+		aaCols := [
+			{
+				column: "value",
+				id: "aaFraction",
+				naRegex: "",
+				allowNA: true,
+				spec: {
+					name: "pl7.app/aaFraction",
+					valueType: "Double",
+					domain: { "pl7.app/feature": "peptide" },
+					annotations: {
+						"pl7.app/label": "AA Fraction",
+						"pl7.app/format": ".3f",
+						"pl7.app/min": "0",
+						"pl7.app/max": "1",
+						"pl7.app/table/visibility": "optional",
+						"pl7.app/table/orderPriority": "69000"
+					}
+				}
+			}
+		]
+		aaSpecs := {
+			axes: aaAxes,
+			columns: aaCols,
+			storageFormat: "Parquet",
+			partitionKeyLength: 0
+		}
+		aaOut = xsv.importFile(args.aaFractionTsv, "tsv", aaSpecs, { splitDataAndSpec: true, cpu: 1, mem: "4GiB" })
+	}
+
+	// Combined output pFrame — scalar properties + (peptide mode only) AA fraction.
+	// Sorted .add() order keeps the pframe resource bytes stable across runs (dedup).
+	resultPframe := pframes.pFrameBuilder()
+	for _, k in maps.getKeys(scalarOut) {
+		v := scalarOut[k]
+		resultPframe.add(k, trace.inject(v.spec), v.data)
+	}
+	if aaOut != undefined {
+		for _, k in maps.getKeys(aaOut) {
+			v := aaOut[k]
+			resultPframe.add(k, trace.inject(v.spec), v.data)
+		}
+	}
+	resultPframe = resultPframe.build()
+
+	exportPframe := pframes.pFrameBuilder()
+	for _, k in maps.getKeys(exportOut) {
+		v := exportOut[k]
+		exportPframe.add(k, trace.inject(v.spec), v.data)
+	}
+	exportPframe = exportPframe.build()
+
+	return {
+		propertiesPf: pframes.exportFrame(resultPframe),
+		exportPframe: exportPframe,
+		info: infoBlob
+	}
+})

package/src/wf.test.ts

@@ -0,0 +1,9 @@
+// Workflow integration tests will be added once Python property computation lands.
+// Placeholder kept so vitest discovers the suite without failures.
+import { describe, it } from "vitest";
+
+describe("sequence-properties workflow", () => {
+  it.skip("computes peptide properties end-to-end", () => {
+    // TODO: implement once compute_properties.py is real.
+  });
+});

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "es2022",
+    "module": "commonjs",
+    "moduleResolution": "node",
+    "esModuleInterop": true,
+    "strict": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "sourceMap": true,
+    "declaration": true
+  },
+  "types": [],
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/vitest.config.mts

@@ -0,0 +1,9 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    watch: false,
+    maxConcurrency: 3,
+    testTimeout: 5000
+  }
+});