Namespace exported columns by content hash instead of blockId

Stamp pl7.app/contentHash (base32 of the source table's CanonicalID) on the
exported property columns instead of the per-block blockId, and drop the
blockId-keyed trace step id. Identical results across blocks/projects now
produce content-identical columns that dedupe downstream, while different
results stay distinct. Mirrors the humanization-score approach. The Python
step and Parquet import already deduped; this extends it to the export.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: AStaroverov

.changeset/content-hash-namespacing.md

@@ -0,0 +1,5 @@
+---
+"@platforma-open/milaboratories.sequence-properties.workflow": patch
+---
+
+Namespace exported property columns by a content hash of the source table (pl7.app/contentHash, derived from the backend CanonicalID) instead of the per-block blockId, and drop the blockId-keyed trace step id. Identical results across blocks/projects now produce content-identical columns that dedupe downstream instead of being made unique per block; different results stay distinct. The heavy Python step and Parquet import already deduped; this extends dedup to the exported pframe identity.

test/src/wf.test.ts

@@ -127,7 +127,7 @@ describe('edge cases', () => {
 describe('downstream consumption', () => {
   it.todo('score columns are discoverable by a downstream block via the result pool');
   it.todo('output PColumns carry pl7.app/trace stamped with this block\'s label');
-  it.todo('export PFrame stamps blockId on score column domains');
+  it.todo('export PFrame stamps pl7.app/contentHash on score column domains');
 });
 
 // ---------------------------------------------------------------------------
@@ -160,6 +160,6 @@ describe('dedup', () => {
 describe('cross-block composition', () => {
   it.todo('canary: real MiXCR fastq → sequence-properties detects sc IG and emits scores');
   it.todo('end-to-end: peptide-extraction → sequence-properties → lead-selection');
-  it.todo('two sequence-properties instances in one project disambiguate via blockId');
+  it.todo('two sequence-properties instances on identical input share columns via pl7.app/contentHash');
   it.todo('VDJ chain: full-coverage MiXCR → seq-properties → lead-selection');
 });

workflow/src/columns.lib.tengo

@@ -6,13 +6,13 @@
 //                                       Returns `[{column, id, naRegex,
 //                                       allowNA, spec}, ...]` with feature-
 //                                       specific domains and annotations.
-//                                       No blockId, no isOutput, no trace
+//                                       No content tag, no isOutput, no trace
 //                                       — those are stamped on by the caller
 //                                       at pframe-build time.
 //   - `aaFractionColumn()`           — 2-axis AA-fraction column descriptor
 //                                       (peptide mode only).
 //   - `cloneSpec(spec, dExtras, aExtras)` — spec-cloning helper used by the
-//                                       caller to layer blockId / isOutput /
+//                                       caller to layer contentHash / isOutput /
 //                                       any other per-consumer overrides.
 //
 // `args` shape:
@@ -70,7 +70,7 @@ makeCol := func(tsvCol, valName, valueType, label, domain, annotations) {
 }
 
 // ---------------------------------------------------------------------------
-// Canonical column lists per scope. No `toPlot`, no `blockId` — the public
+// Canonical column lists per scope. No `toPlot`, no content tag — the public
 // getters layer those on per consumer.
 // ---------------------------------------------------------------------------
 
@@ -386,7 +386,7 @@ buildColumns := func(args) {
 // ---------------------------------------------------------------------------
 // Spec-cloning helper. Builds a fresh spec dict with optional domain and
 // annotation extras. Callers use this to layer per-consumer overrides
-// (e.g. `pl7.app/blockId` in domain, `pl7.app/isOutput` in annotations).
+// (e.g. `pl7.app/contentHash` in domain, `pl7.app/isOutput` in annotations).
 // ---------------------------------------------------------------------------
 
 cloneSpec := func(spec, domainExtras, annotationExtras) {

workflow/src/main.tpl.tengo

@@ -31,6 +31,21 @@ canonicalJsonResource := func(value) {
 	return smart.createValueResource(constants.RTYPE_JSON, canonical.encode(value))
 }
 
+// Content tag for exported columns, replacing the per-block blockId. We use the
+// backend's own content key of the source table (info().CanonicalID, base32),
+// which is deterministic for identical content: identical results across blocks
+// share the same tag (columns dedupe instead of being made unique per block),
+// while different results get different tags (no collision).
+contentHash := func(table) {
+	i := table.info()
+	if !is_undefined(i.CanonicalID) {
+		return ll.base32Encode(i.CanonicalID)
+	}
+	// Field reference: dereference to its value resource.
+	ri := smart.resource(i.Value).info()
+	return ll.base32Encode(ri.CanonicalID)
+}
+
 REQUIRED_FEATURES := ["FR1", "CDR1", "FR2", "CDR2", "FR3", "CDR3", "FR4"]
 
 detectMode := func(axisSpec) {
@@ -138,7 +153,6 @@ wf.prepare(func(args) {
 })
 
 wf.body(func(args) {
-	blockId := wf.blockId().getDataAsJson()
 	bundle := args.columns
 	datasetSpec := bundle.getSpec(args.inputAnchor)
 
@@ -431,40 +445,41 @@ wf.body(func(args) {
 		}, { splitDataAndSpec: true, cpu: 1, mem: "4GiB" })
 	}
 
-	// Stamp every column's spec with `pl7.app/blockId` in domain (for run
-	// attribution) and the upstream trace (so downstream blocks see the full
-	// provenance). The same pFrame is published both as the block's UI output
-	// and as the result-pool export — one canonical resource, two consumers.
-	// The trace is also how the block's own UI distinguishes our property
-	// columns from upstream metadata columns mixed into propertiesPfHandle.
-	// Per-instance trace label. Resolution lives in the model
-	// (resolveTraceLabel in model/src/label.ts) — the model projects a single
-	// string into args so the workflow does not know about customBlockLabel
-	// vs defaultBlockLabel vs the static fallback. The fallback chain
-	// itself — customBlockLabel || defaultBlockLabel || "Sequence Properties"
-	// — matches clonotype-clustering and titeseq-analysis PR #13; only the
-	// location of the resolution differs (model here, inline-Tengo there).
+	// Stamp every column's spec with a content tag (pl7.app/contentHash, derived
+	// from the source table's CanonicalID instead of the per-block blockId) and
+	// the upstream trace. Identical results across blocks share the tag (columns
+	// dedupe) while different results stay distinct. The same pFrame is published
+	// both as the block's UI output and as the result-pool export. The trace also
+	// lets the block's UI distinguish our property columns from upstream metadata
+	// columns mixed into propertiesPfHandle.
+	//
+	// The trace step is no longer keyed on blockId (the block is no longer the
+	// identity of the result; its content is). `id` is optional in the trace
+	// schema; omitting it keeps the provenance step identical across
+	// content-identical runs. Per-instance trace label resolution lives in the
+	// model (resolveTraceLabel in model/src/label.ts).
 	trace := pSpec.makeTrace(datasetSpec, {
 		type: "milaboratories.sequence-properties",
 		importance: 30,
-		label: args.traceLabel,
-		id: blockId
+		label: args.traceLabel
 	})
-	stamp := func(spec) {
+	stamp := func(spec, cHash) {
 		return trace.inject(columnSpecs.cloneSpec(spec,
-			{ "pl7.app/blockId": blockId },
+			{ "pl7.app/contentHash": cHash },
 			undefined))
 	}
 
 	pf := pframes.pFrameBuilder()
+	scalarHash := contentHash(propertiesTsv)
 	for _, k in maps.getKeys(scalarOut) {
 		v := scalarOut[k]
-		pf.add(k, stamp(v.spec), v.data)
+		pf.add(k, stamp(v.spec, scalarHash), v.data)
 	}
 	if aaOut != undefined {
+		aaHash := contentHash(aaFractionTsv)
 		for _, k in maps.getKeys(aaOut) {
 			v := aaOut[k]
-			pf.add(k, stamp(v.spec), v.data)
+			pf.add(k, stamp(v.spec, aaHash), v.data)
 		}
 	}
 	pf = pf.build()