@datagrok/proteomics 1.2.0 → 1.3.0

package/src/tests/abundance-correlation.ts

@@ -0,0 +1,135 @@
+import * as grok from 'datagrok-api/grok';
+import * as DG from 'datagrok-api/dg';
+import {category, test, expect} from '@datagrok-libraries/test/src/test';
+import {createAbundanceCorrelation, correlationDescription, pearson, spearman} from '../viewers/abundance-correlation';
+import {setGroups} from '../analysis/experiment-setup';
+import {SEMTYPE} from '../utils/proteomics-types';
+
+/** Candidates-shaped mock: the pre-computed AVG Group Quantity columns + a
+ * `significant` column. createAbundanceCorrelation resolves abundance from the
+ * quantity columns (no per-sample data needed). */
+function makeCandidatesDf(num: number[], den: number[]): DG.DataFrame {
+  const df = DG.DataFrame.fromColumns([
+    DG.Column.fromStrings('ProteinGroups', num.map((_, i) => `P${i + 1}`)),
+    DG.Column.fromFloat32Array('AVG Group Quantity Numerator', new Float32Array(num)),
+    DG.Column.fromFloat32Array('AVG Group Quantity Denominator', new Float32Array(den)),
+  ]);
+  df.col('ProteinGroups')!.semType = SEMTYPE.PROTEIN_ID;
+  setGroups(df, {group1: {name: 'DMD', columns: []}, group2: {name: 'WT', columns: []}});
+  return df;
+}
+
+/** Report-shaped mock: per-sample intensity columns assigned to two groups, plus
+ * a `direction` column so the color binding has a target. Values are log2-scale
+ * (all < 45), so the geometric-mean path rebases them as logs. */
+function makeReportDf(): DG.DataFrame {
+  const cols: DG.Column[] = [
+    DG.Column.fromStrings('Primary Protein ID', ['P1', 'P2', 'P3', 'P4', 'P5']),
+    DG.Column.fromList('double' as DG.ColumnType, 'S1', [1, 2, 3, 4, 5]),
+    DG.Column.fromList('double' as DG.ColumnType, 'S2', [3, 4, 5, 6, 7]),
+    DG.Column.fromList('double' as DG.ColumnType, 'S3', [5, 6, 7, 8, 9]),
+    DG.Column.fromList('double' as DG.ColumnType, 'S4', [7, 8, 9, 10, 11]),
+    DG.Column.fromStrings('direction',
+      ['Enriched in Control', 'Enriched in Treatment', 'Not significant',
+        'Enriched in Control', 'Enriched in Treatment']),
+  ];
+  cols[0].semType = SEMTYPE.PROTEIN_ID;
+  const df = DG.DataFrame.fromColumns(cols);
+  setGroups(df, {
+    group1: {name: 'Control', columns: ['S1', 'S2']},
+    group2: {name: 'Treatment', columns: ['S3', 'S4']},
+  });
+  return df;
+}
+
+category('Abundance-Correlation', () => {
+  test('pearson is 1 for a perfectly correlated series', async () => {
+    const {r, n} = pearson([1, 2, 3, 4, 5], [2, 4, 6, 8, 10]);
+    expect(n, 5);
+    expect(Math.abs(r - 1) < 1e-6, true);
+  });
+
+  test('pearson is -1 for a perfectly anti-correlated series', async () => {
+    const {r} = pearson([1, 2, 3, 4], [4, 3, 2, 1]);
+    expect(Math.abs(r + 1) < 1e-6, true);
+  });
+
+  test('pearson ignores rows with a null in either series', async () => {
+    const {n} = pearson([1, null, 3, 4], [2, 2, null, 8]);
+    expect(n, 2); // only rows 0 and 3 are pairwise-complete
+  });
+
+  test('spearman is 1 with rank ties', async () => {
+    const rho = spearman([1, 2, 2, 3, 4], [1, 2, 2, 3, 4]);
+    expect(Math.abs(rho - 1) < 1e-9, true);
+  });
+
+  test('builds a scatter on the log10 abundance columns (Candidates)', async () => {
+    const df = makeCandidatesDf([100, 1000, 10, 50], [50, 500, 5, 25]);
+    df.name = 'Abundance correlation candidates test';
+    const tv = grok.shell.addTableView(df);
+    try {
+      const sp = createAbundanceCorrelation(df);
+      expect(sp !== null, true);
+      // hidden log10 columns added for both conditions
+      expect(df.col('log10 abundance: DMD') !== null, true);
+      expect(df.col('log10 abundance: WT') !== null, true);
+      // axes: x = WT (denominator / group2), y = DMD (numerator / group1)
+      expect(sp!.props.xColumnName, 'log10 abundance: WT');
+      expect(sp!.props.yColumnName, 'log10 abundance: DMD');
+      // Pearson/Spearman annotation goes in the on-canvas description overlay
+      // (the title is not painted in a docked viewer).
+      const desc = correlationDescription('DMD', 'WT', df, 'log10 abundance: WT', 'log10 abundance: DMD');
+      expect(desc.includes('Pearson'), true);
+      expect(desc.includes('Spearman'), true);
+      expect(desc.includes('DMD vs WT'), true);
+    } finally {
+      tv.close();
+    }
+  });
+
+  test('Report path uses the geometric mean and colors by direction', async () => {
+    const df = makeReportDf();
+    df.name = 'Abundance correlation report test';
+    const tv = grok.shell.addTableView(df);
+    try {
+      const sp = createAbundanceCorrelation(df);
+      expect(sp !== null, true);
+      expect(sp!.props.colorColumnName, 'direction');
+      // Geometric mean of a log2-scale group = log10(2) * mean(log2 values).
+      // Row 0 Control {S1=1, S2=3} → mean=2 → 2*log10(2) ≈ 0.60206.
+      const yCol = df.col('log10 abundance: Control')!;
+      expect(Math.abs((yCol.get(0) as number) - 2 * Math.log10(2)) < 1e-5, true);
+      // Row 0 Treatment {S3=5, S4=7} → mean=6 → 6*log10(2) ≈ 1.80618.
+      const xCol = df.col('log10 abundance: Treatment')!;
+      expect(Math.abs((xCol.get(0) as number) - 6 * Math.log10(2)) < 1e-5, true);
+    } finally {
+      tv.close();
+    }
+  });
+
+  test('draws a y=x diagonal reference line', async () => {
+    const df = makeReportDf();
+    const tv = grok.shell.addTableView(df);
+    try {
+      createAbundanceCorrelation(df);
+      const lines = df.meta.formulaLines.items;
+      const diagonal = lines.find((l: any) => {
+        const f = (l.formula ?? '') as string;
+        return typeof f === 'string' &&
+          f.includes('log10 abundance: Control') && f.includes('log10 abundance: Treatment');
+      });
+      expect(diagonal !== undefined, true);
+    } finally {
+      tv.close();
+    }
+  });
+
+  test('returns null when no abundance is present', async () => {
+    const df = DG.DataFrame.fromColumns([
+      DG.Column.fromStrings('ProteinGroups', ['P1', 'P2']),
+      DG.Column.fromFloat32Array('log2FC', new Float32Array([1, -1])),
+    ]);
+    expect(createAbundanceCorrelation(df), null);
+  });
+});

package/src/tests/analysis.ts

@@ -292,6 +292,46 @@ category('Normalization', () => {
     expect(Math.abs(df.col('s1')!.get(0) - 1) < 0.01, true);
   });
 
+  test('quantile normalization is NaN/Infinity-safe when the fullest column has < 2 values', async () => {
+    // maxValid < 2 → the rank interpolation would divide by (maxValid - 1) = 0.
+    // The guard must bail out, leaving the few observed values untouched (no NaN).
+    const c1 = DG.Column.fromFloat32Array('s1', new Float32Array([5, DG.FLOAT_NULL, DG.FLOAT_NULL]));
+    const c2 = DG.Column.fromFloat32Array('s2', new Float32Array([DG.FLOAT_NULL, 8, DG.FLOAT_NULL]));
+    c1.semType = SEMTYPE.INTENSITY;
+    c2.semType = SEMTYPE.INTENSITY;
+    const df = DG.DataFrame.fromColumns([
+      DG.Column.fromStrings('id', ['P0', 'P1', 'P2']),
+      c1, c2,
+    ]);
+    quantileNormalize(df, ['s1', 's2']);
+    // No NaN/Infinity; nulls preserved; the lone observed values survive.
+    expect(Number.isFinite(df.col('s1')!.get(0)), true);
+    expect(Number.isFinite(df.col('s2')!.get(1)), true);
+    expect(df.col('s1')!.isNone(1), true);
+    expect(df.col('s2')!.isNone(0), true);
+  });
+
+  test('quantile normalization tolerates a single-value column next to a full one', async () => {
+    // s2 has exactly one observed value: without the length < 2 guards, its
+    // per-column rank division (n - 1) = 0 would write NaN into that cell.
+    const c1 = DG.Column.fromFloat32Array('s1', new Float32Array([5, 3, 6, 2]));
+    const c2 = DG.Column.fromFloat32Array('s2',
+      new Float32Array([8, DG.FLOAT_NULL, DG.FLOAT_NULL, DG.FLOAT_NULL]));
+    c1.semType = SEMTYPE.INTENSITY;
+    c2.semType = SEMTYPE.INTENSITY;
+    const df = DG.DataFrame.fromColumns([
+      DG.Column.fromStrings('id', ['P0', 'P1', 'P2', 'P3']),
+      c1, c2,
+    ]);
+    quantileNormalize(df, ['s1', 's2']);
+    // s1 fully normalized without NaN; s2's single value preserved, nulls intact.
+    for (let i = 0; i < 4; i++)
+      expect(Number.isFinite(df.col('s1')!.get(i)), true);
+    expect(Number.isFinite(df.col('s2')!.get(0)), true);
+    expect(Math.abs(df.col('s2')!.get(0) - 8) < 0.01, true);
+    expect(df.col('s2')!.isNone(1), true);
+  });
+
   test('vsnNormalize falls back to quantile on R failure', async () => {
     const c1 = DG.Column.fromFloat32Array('log2(s1)', new Float32Array([5, 2, 3, 6]));
     const c2 = DG.Column.fromFloat32Array('log2(s2)', new Float32Array([4, 14, 8, 2]));
@@ -458,6 +498,29 @@ category('Imputation', () => {
     expect(Math.abs(df.col('s1')!.get(4) - 6) < 0.01, true);
     expect(df.getTag('proteomics.imputed'), 'true');
   });
+
+  test('MinProb imputation never yields NaN or Infinity', async () => {
+    // Box-Muller draws u1 in (0, 1]; were it ever 0, log(0) = -Infinity would
+    // poison an imputed cell. Impute a large column so randomNormal runs many
+    // hundreds of times, and assert every filled value is finite.
+    const n = 2000;
+    const values = new Float32Array(n);
+    for (let i = 0; i < n; i++)
+      values[i] = (i % 2 === 0) ? DG.FLOAT_NULL : (10 + (i % 7));
+    const col = DG.Column.fromFloat32Array('intensity', values);
+    col.semType = SEMTYPE.INTENSITY;
+    const df = DG.DataFrame.fromColumns([
+      DG.Column.fromStrings('id', Array.from({length: n}, (_, i) => `P${i}`)),
+      col,
+    ]);
+    const imputed = imputeMinProb(df, ['intensity']);
+    expect(imputed > 0, true);
+    const c = df.col('intensity')!;
+    for (let i = 0; i < n; i++) {
+      expect(c.isNone(i), false);
+      expect(Number.isFinite(c.get(i)), true);
+    }
+  });
 });
 
 // ── Differential Expression ─────────────────────────────────────────

package/src/tests/enrichment-visualization.ts

@@ -164,7 +164,7 @@ category('Enrichment Visualization', () => {
     expect(sub === rxjs.Subscription.EMPTY, true);
   });
 
-  test('wireEnrichmentToVolcano selects matching genes on protein DataFrame', async () => {
+  test('wireEnrichmentToVolcano selects a term\'s member genes on the volcano', async () => {
     const enrichDf = makeMockEnrichmentDf(3);
     // Set intersection to specific genes for first row
     enrichDf.col('Intersection')!.set(0, 'TP53, BRCA1');
@@ -173,8 +173,9 @@ category('Enrichment Visualization', () => {
     const sub = wireEnrichmentToVolcano(enrichDf, proteinDf);
     expect(sub !== rxjs.Subscription.EMPTY, true);
 
-    // Trigger row change
-    enrichDf.currentRowIdx = 0;
+    // Select the first enrichment term (selection channel, not current row).
+    enrichDf.selection.set(0, true, false);
+    enrichDf.selection.fireChanged();
 
     // Check that TP53 (row 0) and BRCA1 (row 1) are selected
     expect(proteinDf.selection.get(0), true);  // TP53
@@ -186,7 +187,29 @@ category('Enrichment Visualization', () => {
     sub.unsubscribe();
   });
 
-  test('wireEnrichmentToVolcano clears selection before new selection', async () => {
+  test('wireEnrichmentToVolcano unions member genes across multiple selected terms', async () => {
+    const enrichDf = makeMockEnrichmentDf(3);
+    enrichDf.col('Intersection')!.set(0, 'TP53');
+    enrichDf.col('Intersection')!.set(1, 'EGFR');
+    const proteinDf = makeMockProteinDf();
+
+    const sub = wireEnrichmentToVolcano(enrichDf, proteinDf);
+
+    // Select two terms at once (the multi-select gesture the volcano must reflect).
+    enrichDf.selection.set(0, true, false);
+    enrichDf.selection.set(1, true, false);
+    enrichDf.selection.fireChanged();
+
+    // Union: TP53 (row 0) from term 0, EGFR (row 2) from term 1; nothing else.
+    expect(proteinDf.selection.get(0), true);  // TP53
+    expect(proteinDf.selection.get(2), true);  // EGFR
+    expect(proteinDf.selection.get(1), false); // BRCA1 — in neither term
+    expect(proteinDf.selection.trueCount, 2);
+
+    sub.unsubscribe();
+  });
+
+  test('wireEnrichmentToVolcano clears prior volcano selection on a new term selection', async () => {
     const enrichDf = makeMockEnrichmentDf(3);
     enrichDf.col('Intersection')!.set(0, 'TP53');
     enrichDf.col('Intersection')!.set(1, 'EGFR');
@@ -198,8 +221,9 @@ category('Enrichment Visualization', () => {
 
     const sub = wireEnrichmentToVolcano(enrichDf, proteinDf);
 
-    // Select first enrichment row (TP53 only)
-    enrichDf.currentRowIdx = 0;
+    // Select first enrichment term (TP53 only)
+    enrichDf.selection.set(0, true, false);
+    enrichDf.selection.fireChanged();
 
     // AKT1 (row 4) should no longer be selected since selection was cleared
     expect(proteinDf.selection.get(4), false);
@@ -209,6 +233,67 @@ category('Enrichment Visualization', () => {
     sub.unsubscribe();
   });
 
+  test('wireEnrichmentToVolcano clears the volcano selection when no terms are selected', async () => {
+    const enrichDf = makeMockEnrichmentDf(3);
+    enrichDf.col('Intersection')!.set(0, 'TP53');
+    const proteinDf = makeMockProteinDf();
+
+    const sub = wireEnrichmentToVolcano(enrichDf, proteinDf);
+
+    enrichDf.selection.set(0, true, false);
+    enrichDf.selection.fireChanged();
+    expect(proteinDf.selection.trueCount, 1);
+
+    // Deselecting every term clears the volcano selection.
+    enrichDf.selection.setAll(false, false);
+    enrichDf.selection.fireChanged();
+    expect(proteinDf.selection.trueCount, 0);
+
+    sub.unsubscribe();
+  });
+
+  test('wireEnrichmentToVolcano current term selects its proteins when no terms are selected', async () => {
+    const enrichDf = makeMockEnrichmentDf(3);
+    enrichDf.col('Intersection')!.set(0, 'TP53, BRCA1');
+    const proteinDf = makeMockProteinDf();
+
+    const sub = wireEnrichmentToVolcano(enrichDf, proteinDf);
+
+    // No terms selected → making a term the current row selects its proteins
+    // (the visible single-click behavior).
+    enrichDf.currentRowIdx = 0;
+
+    expect(proteinDf.selection.get(0), true);  // TP53
+    expect(proteinDf.selection.get(1), true);  // BRCA1
+    expect(proteinDf.selection.trueCount, 2);
+
+    sub.unsubscribe();
+  });
+
+  test('wireEnrichmentToVolcano current term is ignored while a term selection is active', async () => {
+    const enrichDf = makeMockEnrichmentDf(3);
+    enrichDf.col('Intersection')!.set(0, 'TP53');       // term 0 → TP53 (row 0)
+    enrichDf.col('Intersection')!.set(1, 'EGFR, MYC');  // term 1 → EGFR (row 2), MYC (row 3)
+    const proteinDf = makeMockProteinDf();
+
+    const sub = wireEnrichmentToVolcano(enrichDf, proteinDf);
+
+    // Active selection on term 1 → EGFR + MYC selected.
+    enrichDf.selection.set(1, true, false);
+    enrichDf.selection.fireChanged();
+    expect(proteinDf.selection.trueCount, 2);
+    expect(proteinDf.selection.get(2), true); // EGFR
+    expect(proteinDf.selection.get(3), true); // MYC
+
+    // Changing the current row to term 0 must NOT clobber the active selection.
+    enrichDf.currentRowIdx = 0;
+    expect(proteinDf.selection.get(0), false); // TP53 not added
+    expect(proteinDf.selection.get(2), true);  // EGFR still selected
+    expect(proteinDf.selection.trueCount, 2);  // unchanged
+
+    sub.unsubscribe();
+  });
+
   // Test B (light-touch declutter, 2026-06): the directional-split Up/Down
   // dot+bar viewers now dock on the ENRICHMENT TableView, NOT the protein view —
   // the user's volcano tab stays clean. This reverses the 13-09 co-dock-on-
@@ -237,10 +322,11 @@ category('Enrichment Visualization', () => {
       expect(countViewersBoundTo(enrichTv, proteinDf), 0,
         'enrichment view must not carry a proteinDf-bound volcano');
 
-      // Data-layer cross-link still fires through the unchanged subscriptions.
-      enrichDf.currentRowIdx = 0;
+      // Data-layer cross-link still fires: selecting a term marks its proteins.
+      enrichDf.selection.set(0, true, false);
+      enrichDf.selection.fireChanged();
       expect(proteinDf.selection.trueCount >= 1, true,
-        'selecting an enrichment row should still highlight matching protein rows');
+        'selecting an enrichment term should mark matching protein rows');
     } finally {
       enrichTv.close();
       proteinTv.close();

package/src/tests/enrichment.ts

@@ -202,7 +202,8 @@ category('Enrichment', () => {
     const proteinDf = DG.DataFrame.fromColumns([geneCol]);
 
     const sub = wireEnrichmentToVolcano(enrichDf, proteinDf);
-    enrichDf.currentRowIdx = 0;
+    enrichDf.selection.set(0, true, false);
+    enrichDf.selection.fireChanged();
     // TP53 + EGFR selected (from Intersection); MYC not.
     expect(proteinDf.selection.trueCount, 2);
     expect(proteinDf.selection.get(2), false);

package/src/tests/project-vocabulary.ts

@@ -0,0 +1,39 @@
+import {category, expect, test} from '@datagrok-libraries/test/src/test';
+
+import {parseProjectVocabulary} from '../publishing/publish-settings';
+
+/**
+ * Pure-parser tests for the admin-maintained `projectVocabulary` package
+ * setting. The Share for Review dialog turns this list into its controlled
+ * Project dropdown, so parsing (comma / newline / array, trim, dedup, empty →
+ * gate) is the contract the dialog depends on.
+ */
+category('ProjectVocabulary', () => {
+  test('comma-separated string parses to trimmed list', async () => {
+    expect(JSON.stringify(parseProjectVocabulary('DMD-muscle-2026, SMA-cardiac-panel , ALS-cohort-2025')),
+      JSON.stringify(['DMD-muscle-2026', 'SMA-cardiac-panel', 'ALS-cohort-2025']));
+  });
+
+  test('newline-separated string parses (admin pasted a list)', async () => {
+    expect(JSON.stringify(parseProjectVocabulary('Project A\nProject B\r\nProject C')),
+      JSON.stringify(['Project A', 'Project B', 'Project C']));
+  });
+
+  test('array value parses (future string_list property)', async () => {
+    expect(JSON.stringify(parseProjectVocabulary(['P1', ' P2 ', 'P3'])),
+      JSON.stringify(['P1', 'P2', 'P3']));
+  });
+
+  test('duplicates removed, order preserved', async () => {
+    expect(JSON.stringify(parseProjectVocabulary('B, A, B, C, A')),
+      JSON.stringify(['B', 'A', 'C']));
+  });
+
+  test('empty / blank / nullish → [] (dialog treats as "ask an admin")', async () => {
+    expect(parseProjectVocabulary('').length, 0);
+    expect(parseProjectVocabulary('   ,  , \n ').length, 0);
+    expect(parseProjectVocabulary(undefined).length, 0);
+    expect(parseProjectVocabulary(null).length, 0);
+    expect(parseProjectVocabulary([]).length, 0);
+  });
+});

package/src/tests/publish-roundtrip.ts

@@ -5,7 +5,7 @@ import {awaitCheck, category, delay, expect, test} from '@datagrok-libraries/tes
 import {SEMTYPE} from '../utils/proteomics-types';
 import {
   META_COLUMNS, PUBLISHED_TAGS, PublishOptions, PublishedMetadata,
-  isPublished, slugifyTarget,
+  isPublished, slugifyProject,
 } from '../publishing/publish-state';
 import {publishAnalysis} from '../publishing/publish-project';
 import {
@@ -13,7 +13,7 @@ import {
 } from '../publishing/assert-published-shape';
 import {recoverPublishedProject} from '../publishing/post-open-recovery';
 
-const DEFAULT_TARGET_PREFIX = 'pub-roundtrip-';
+const DEFAULT_PROJECT_PREFIX = 'pub-roundtrip-';
 const DEFAULT_FC = 1.0;
 const DEFAULT_P = 0.05;
 
@@ -150,15 +150,15 @@ async function cleanupProject(project: DG.Project | null): Promise<void> {
 }
 
 /**
- * publishAnalysis creates a per-target child Space `Proteomics-Review-<slug>`
+ * publishAnalysis creates a per-project child Space `Proteomics-Review-<slug>`
  * under the `Proteomics-Reviews` umbrella (publish-project.ts step 5) but
  * returns only the leaf project. cleanupProject removes the leaf; this removes
  * the otherwise-orphaned child Space. Best-effort and idempotent — runs in
  * each test's finally after the leaf is deleted.
  */
-async function cleanupChildSpace(target: string): Promise<void> {
+async function cleanupChildSpace(projectName: string): Promise<void> {
   const dapiAny = grok.dapi as any;
-  const childName = `Proteomics-Review-${slugifyTarget(target)}`;
+  const childName = `Proteomics-Review-${slugifyProject(projectName)}`;
   try {
     const all: any[] = await dapiAny.spaces.list();
     const umbrella = (all ?? []).find((p) =>
@@ -196,7 +196,7 @@ function expectedAllowlistFromTrimmedView(): string[] {
 function expectedMetaForTest(
   project: DG.Project,
   sourceDf: DG.DataFrame,
-  target: string,
+  projectName: string,
   includesEnrichment: boolean,
 ): PublishedMetadata {
   // Build the expected contract from what was ACTUALLY published, not from
@@ -209,7 +209,7 @@ function expectedMetaForTest(
   const publishId = ((project as any).options?.[PUBLISHED_TAGS.PUBLISHED_ID] as string | undefined) ?? '';
   const deMethod = sourceDf.getTag('proteomics.de_method') ?? 't-test';
   return {
-    target,
+    project: projectName,
     publishedAt: new Date(),                                    // not asserted
     publishedBy: (grok.shell.user as any)?.friendlyName ?? '',
     publishedByEmail: (grok.shell.user as any)?.email ?? null,  // not asserted
@@ -233,21 +233,21 @@ category('Publishing', () => {
       try { (tv as any).scatterPlot?.({x: 'log2FC', y: 'adj.p-value'}); } catch { /* swallow */ }
       await delay(100);
 
-      const target = `${DEFAULT_TARGET_PREFIX}t1-${Date.now()}`;
+      const projectName = `${DEFAULT_PROJECT_PREFIX}t1-${Date.now()}`;
       const group = await pickAnyGroup();
-      const opts: PublishOptions = {target, reviewerGroup: group, note: 'Phase 15 roundtrip Test 1', priorVersion: null};
+      const opts: PublishOptions = {project: projectName, reviewerGroup: group, note: 'Phase 15 roundtrip Test 1', priorVersion: null};
 
       let project: DG.Project | null = null;
       try {
         project = await publishAnalysis(df, opts);
         expect(!!project, true);
 
-        const projectName = (project as any).name as string;
-        const meta = expectedMetaForTest(project!, df, target, false);
+        const publishedName = (project as any).name as string;
+        const meta = expectedMetaForTest(project!, df, projectName, false);
         const allowlist = expectedAllowlistFromTrimmedView();
         const contract = buildExpectedContract(
           `${df.name}_published_${new Date().toISOString().slice(0, 10)}`,
-          projectName,
+          publishedName,
           allowlist,
           meta,
           false,
@@ -282,7 +282,7 @@ category('Publishing', () => {
         expect(hasPLine, true);
       } finally {
         await cleanupProject(project);
-        await cleanupChildSpace(target);
+        await cleanupChildSpace(projectName);
       }
     });
 
@@ -297,21 +297,21 @@ category('Publishing', () => {
       try { (proteinTv as any).scatterPlot?.({x: 'log2FC', y: 'adj.p-value'}); } catch { /* swallow */ }
       await delay(100);
 
-      const target = `${DEFAULT_TARGET_PREFIX}t2-${Date.now()}`;
+      const projectName = `${DEFAULT_PROJECT_PREFIX}t2-${Date.now()}`;
       const group = await pickAnyGroup();
-      const opts: PublishOptions = {target, reviewerGroup: group, note: 'Phase 15 roundtrip Test 2', priorVersion: null};
+      const opts: PublishOptions = {project: projectName, reviewerGroup: group, note: 'Phase 15 roundtrip Test 2', priorVersion: null};
 
       let project: DG.Project | null = null;
       try {
         project = await publishAnalysis(protein, opts);
         expect(!!project, true);
 
-        const projectName = (project as any).name as string;
-        const meta = expectedMetaForTest(project!, protein, target, true);
+        const publishedName = (project as any).name as string;
+        const meta = expectedMetaForTest(project!, protein, projectName, true);
         const allowlist = expectedAllowlistFromTrimmedView();
         const contract = buildExpectedContract(
           `${protein.name}_published_${new Date().toISOString().slice(0, 10)}`,
-          projectName,
+          publishedName,
           allowlist,
           meta,
           true,
@@ -350,7 +350,7 @@ category('Publishing', () => {
         expect(afterCount > beforeCount, true);
       } finally {
         await cleanupProject(project);
-        await cleanupChildSpace(target);
+        await cleanupChildSpace(projectName);
       }
     });
 
@@ -369,12 +369,12 @@ category('Publishing', () => {
       try { grok.shell.v = proteinTv; } catch { /* swallow */ }
       await delay(50);
 
-      const target = `${DEFAULT_TARGET_PREFIX}restore-${Date.now()}`;
+      const projectName = `${DEFAULT_PROJECT_PREFIX}restore-${Date.now()}`;
       const group = await pickAnyGroup();
       // verify:false keeps the test fast — Step 10 restore runs regardless of the
       // round-trip verification toggle, and this test is specifically about restore.
       const opts: PublishOptions = {
-        target, reviewerGroup: group, note: 'restore test', priorVersion: null, verify: false,
+        project: projectName, reviewerGroup: group, note: 'restore test', priorVersion: null, verify: false,
       } as PublishOptions;
 
       let project: DG.Project | null = null;
@@ -401,7 +401,7 @@ category('Publishing', () => {
         expect((grok.shell.tv?.dataFrame as any)?.dart, proteinDart);
       } finally {
         await cleanupProject(project);
-        await cleanupChildSpace(target);
+        await cleanupChildSpace(projectName);
       }
     });
 
@@ -409,13 +409,13 @@ category('Publishing', () => {
     async () => {
       const df = createSyntheticDeFixture();
       const baselineL2FC = df.col('log2FC')!.get(0);
-      const baselineTarget = `${DEFAULT_TARGET_PREFIX}t3-${Date.now()}`;
+      const baselineProject = `${DEFAULT_PROJECT_PREFIX}t3-${Date.now()}`;
 
       grok.shell.addTableView(df);
       await delay(100);
 
       const group = await pickAnyGroup();
-      const opts: PublishOptions = {target: baselineTarget, reviewerGroup: group, note: '', priorVersion: null};
+      const opts: PublishOptions = {project: baselineProject, reviewerGroup: group, note: '', priorVersion: null};
 
       let project: DG.Project | null = null;
       try {
@@ -436,7 +436,7 @@ category('Publishing', () => {
         // Mutate the SOURCE DF (the one we still hold in memory)
         df.col('log2FC')!.set(0, 999.999);
         try { df.columns.remove('Gene Name'); } catch { /* may have been allowlist-only */ }
-        df.setTag(PUBLISHED_TAGS.PUBLISHED_TARGET, 'CHANGED-TARGET');
+        df.setTag(PUBLISHED_TAGS.PUBLISHED_PROJECT, 'CHANGED-PROJECT');
 
         // Reopen the project AGAIN — clone must be unchanged
         grok.shell.closeAll();
@@ -449,25 +449,25 @@ category('Publishing', () => {
         const reL2FC = reDf.col('log2FC')!.get(0);
         expect(reL2FC, baselineL2FC);
         expect(!!reDf.col('Gene Name'), true);
-        const reTarget = reDf.getTag(PUBLISHED_TAGS.PUBLISHED_TARGET);
-        expect(reTarget === 'CHANGED-TARGET', false);
-        expect(reTarget === baselineTarget, true);
+        const reProject = reDf.getTag(PUBLISHED_TAGS.PUBLISHED_PROJECT);
+        expect(reProject === 'CHANGED-PROJECT', false);
+        expect(reProject === baselineProject, true);
       } finally {
         await cleanupProject(project);
-        await cleanupChildSpace(baselineTarget);
+        await cleanupChildSpace(baselineProject);
       }
     });
 
   test('republish creates v2 with bidirectional superseded_by + supersedes pointers (W-8 dual-write)',
     async () => {
       const df = createSyntheticDeFixture();
-      const target = `${DEFAULT_TARGET_PREFIX}t4-${Date.now()}`;
+      const projectName = `${DEFAULT_PROJECT_PREFIX}t4-${Date.now()}`;
 
       grok.shell.addTableView(df);
       await delay(100);
 
       const group = await pickAnyGroup();
-      const optsV1: PublishOptions = {target, reviewerGroup: group, note: 'v1', priorVersion: null};
+      const optsV1: PublishOptions = {project: projectName, reviewerGroup: group, note: 'v1', priorVersion: null};
 
       let projectV1: DG.Project | null = null;
       let projectV2: DG.Project | null = null;
@@ -481,7 +481,7 @@ category('Publishing', () => {
         // Re-discover the source DF view (publishAnalysis opened the trimmed view)
         await delay(200);
 
-        const optsV2: PublishOptions = {target, reviewerGroup: group, note: 'v2', priorVersion: projectV1};
+        const optsV2: PublishOptions = {project: projectName, reviewerGroup: group, note: 'v2', priorVersion: projectV1};
         projectV2 = await publishAnalysis(df, optsV2);
         expect(!!projectV2, true);
         const v2Id = (projectV2 as any).id;
@@ -525,8 +525,8 @@ category('Publishing', () => {
       } finally {
         await cleanupProject(projectV2);
         await cleanupProject(projectV1);
-        // Both versions share one target → one child Space to remove.
-        await cleanupChildSpace(target);
+        // Both versions share one project → one child Space to remove.
+        await cleanupChildSpace(projectName);
       }
     });
 
@@ -546,9 +546,9 @@ category('Publishing', () => {
         grok.shell.addTableView(df);
         await delay(100);
 
-        const target = `${DEFAULT_TARGET_PREFIX}t5-${Date.now()}`;
+        const projectName = `${DEFAULT_PROJECT_PREFIX}t5-${Date.now()}`;
         const opts: PublishOptions = {
-          target,
+          project: projectName,
           reviewerGroup: userGroup,
           note: 'negative test',
           priorVersion: null,
@@ -566,13 +566,13 @@ category('Publishing', () => {
         const hitsD03 = caughtMessage.includes('Reviewer group already has elevated access via Space inheritance');
         expect(hitsD03, true);
 
-        // Verify NO Project was left behind under the target slug
+        // Verify NO Project was left behind under the project slug
         try {
           const slugSearch = `Proteomics-Review-%`;
           const lingering: any[] = await dapiAny.projects.filter(`name like "${slugSearch}"`).list();
-          const matchesThisTarget = (lingering ?? []).filter((p: any) =>
-            typeof p?.name === 'string' && p.name.includes(target));
-          expect(matchesThisTarget.length, 0);
+          const matchesThisProject = (lingering ?? []).filter((p: any) =>
+            typeof p?.name === 'string' && p.name.includes(projectName));
+          expect(matchesThisProject.length, 0);
         } catch { /* swallow — best-effort search */ }
 
         // If somehow a project was returned (gate failed to throw), clean up so we don't leak.