@datagrok/proteomics 1.2.0 → 1.3.0

package/src/publishing/package-settings-editor.ts

@@ -0,0 +1,125 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+import {parseProjectVocabulary} from './publish-settings';
+import {loadReviewerGroups, reviewerGroupName} from './reviewer-groups';
+
+/**
+ * Custom editor for the Proteomics package settings (Plugins → Proteomics →
+ * Settings). Replaces the auto-generated form so `projectVocabulary` gets a
+ * proper add / edit / remove list instead of a single comma-separated text box.
+ *
+ * Follows the platform contract used by HitTriage / SequenceTranslator: read the
+ * live value with `prop.get(null)` and stage edits with `prop.set(null, value)`;
+ * the Settings pane's SAVE button commits the staged values. (Direct
+ * `Package.setSettings()` is NOT the write path here — the property staging is.)
+ *
+ * Because a custom editor replaces the ENTIRE settings form, every Proteomics
+ * setting is rendered here, not just the vocabulary — otherwise the others would
+ * vanish from the pane.
+ */
+export async function proteomicsSettingsEditorWidget(propList: DG.Property[]): Promise<DG.Widget> {
+  const findProp = (name: string): DG.Property | undefined => propList.find((p) => p.name === name);
+
+  const inputs: DG.InputBase[] = [];
+
+  const addStringInput = (name: string, caption: string): void => {
+    const prop = findProp(name);
+    if (!prop) return;
+    const cur = (prop.get(null) as string | null) ?? '';
+    const input = ui.input.string(caption, {value: cur});
+    input.onChanged.subscribe(() => {
+      try { prop.set(null, input.value ?? ''); } catch (e) { console.error(e); }
+    });
+    inputs.push(input);
+  };
+
+  const addBoolInput = (name: string, caption: string): void => {
+    const prop = findProp(name);
+    if (!prop) return;
+    const cur = prop.get(null);
+    const input = ui.input.bool(caption, {value: cur === true || cur === 'true'});
+    input.onChanged.subscribe(() => {
+      try { prop.set(null, !!input.value); } catch (e) { console.error(e); }
+    });
+    inputs.push(input);
+  };
+
+  // Default reviewer team: a dropdown of the same teams the Share dialog offers,
+  // so admins pick from a controlled list rather than free-typing a name. Falls
+  // back to a free-text input if the group list can't be loaded (e.g. no ACL).
+  const addDefaultGroupInput = async (): Promise<void> => {
+    const prop = findProp('defaultReviewerGroup');
+    if (!prop) return;
+    const cur = (prop.get(null) as string | null) ?? '';
+    let groupNames: string[] = [];
+    try {
+      groupNames = [...new Set((await loadReviewerGroups()).map(reviewerGroupName).filter(Boolean))];
+    } catch (e) { console.error(e); }
+
+    if (groupNames.length > 0) {
+      const input = ui.input.choice('Default Reviewer Team', {
+        value: groupNames.includes(cur) ? cur : null,
+        items: groupNames,
+        nullable: true,
+      });
+      input.setTooltip('Team pre-selected in the Share for Review dialog. Leave blank to default to the first team.');
+      input.onChanged.subscribe(() => {
+        try { prop.set(null, input.value ?? ''); } catch (e) { console.error(e); }
+      });
+      inputs.push(input);
+    } else {
+      const input = ui.input.string('Default Reviewer Team', {value: cur});
+      input.setTooltip('Team name pre-selected in the Share for Review dialog. Leave blank to default to the first team.');
+      input.onChanged.subscribe(() => {
+        try { prop.set(null, input.value ?? ''); } catch (e) { console.error(e); }
+      });
+      inputs.push(input);
+    }
+  };
+
+  addStringInput('reviewSpaceName', 'Review Space Name');
+  addStringInput('reviewNamePrefix', 'Review Name Prefix');
+  await addDefaultGroupInput();
+  addBoolInput('verifyPublishedDashboard', 'Verify Published Dashboard');
+
+  const root = ui.divV([ui.form(inputs)]);
+
+  // ── Project vocabulary — add / edit / remove list ───────────────────────────
+  const vocabProp = findProp('projectVocabulary');
+  if (vocabProp) {
+    // Serialize on every edit; parseProjectVocabulary trims + dedupes on read.
+    let items = parseProjectVocabulary(vocabProp.get(null));
+    const commit = (): void => {
+      try { vocabProp.set(null, items.join(', ')); } catch (e) { console.error(e); }
+    };
+
+    const rowsHost = ui.divV([]);
+    const renderRows = (): void => {
+      ui.empty(rowsHost);
+      if (items.length === 0) {
+        rowsHost.appendChild(ui.divText('No projects yet — add one below.',
+          {style: {color: 'var(--grey-4)', fontStyle: 'italic', margin: '4px 0'}}));
+      }
+      items.forEach((val, i) => {
+        const input = ui.input.string('', {value: val});
+        input.input.style.width = '260px';
+        input.onChanged.subscribe(() => { items[i] = (input.value ?? '').trim(); commit(); });
+        const del = ui.icons.delete(() => { items.splice(i, 1); renderRows(); commit(); }, 'Remove project');
+        rowsHost.appendChild(ui.divH([input.input, del], {style: {alignItems: 'center', gap: '8px', margin: '2px 0'}}));
+      });
+    };
+
+    const addBtn = ui.button('+ Add project', () => { items.push(''); renderRows(); });
+    renderRows();
+
+    root.appendChild(ui.h1('Projects', {style: {marginTop: '12px', marginBottom: '4px'}}));
+    root.appendChild(ui.divText('Analysts share each analysis under one of these. Add, rename, or remove names here.',
+      {style: {color: 'var(--grey-5)', marginBottom: '6px'}}));
+    root.appendChild(rowsHost);
+    root.appendChild(addBtn);
+  }
+
+  return DG.Widget.fromRoot(root);
+}

package/src/publishing/publish-project.ts

@@ -4,7 +4,7 @@ import {awaitCheck, delay} from '@datagrok-libraries/test/src/test';
 
 import {
   META_COLUMNS, PUBLISHED_TAGS, PublishOptions, PublishedMetadata,
-  slugifyTarget,
+  slugifyProject,
 } from './publish-state';
 import {trimEnrichmentForPublish, trimForPublish} from './trim-dataframe';
 import {
@@ -135,7 +135,7 @@ export async function publishAnalysis(df: DG.DataFrame, opts: PublishOptions): P
         pThreshold = optsAny.pThreshold;
     } catch { /* defaults */ }
 
-    const slug = slugifyTarget(opts.target);
+    const slug = slugifyProject(opts.project);
     const priorVersionN = parsePriorVersion((opts.priorVersion as any)?.name);
     const version = priorVersionN > 0 ? priorVersionN + 1 : 1;
     const publishId = generateUuid();
@@ -149,7 +149,7 @@ export async function publishAnalysis(df: DG.DataFrame, opts: PublishOptions): P
     })();
 
     const meta: PublishedMetadata = {
-      target: opts.target,
+      project: opts.project,
       publishedAt,
       publishedBy,
       publishedByEmail,
@@ -203,8 +203,8 @@ export async function publishAnalysis(df: DG.DataFrame, opts: PublishOptions): P
     }
     const umbrellaClient = dapiAny.spaces.id(umbrella.id);
 
-    // ─── Step 5 — ensure per-target child Space ─────────────────────────────────
-    pi.description = 'Ensuring per-target Space...';
+    // ─── Step 5 — ensure per-project child Space ────────────────────────────────
+    pi.description = 'Ensuring per-project Space...';
     const childName = `${reviewNamePrefix()}-${slug}`;
     let childSpace: any = null;
 
@@ -231,7 +231,7 @@ export async function publishAnalysis(df: DG.DataFrame, opts: PublishOptions): P
         childSpace = await findChildByName();
         if (!childSpace) {
           throw new Error(
-            `Per-target child Space '${childName}' exists but could not be resolved via ` +
+            `Per-project child Space '${childName}' exists but could not be resolved via ` +
             `umbrella children.list() (msg: ${msg}).`);
         }
       }
@@ -244,10 +244,10 @@ export async function publishAnalysis(df: DG.DataFrame, opts: PublishOptions): P
     const projectName = `${reviewNamePrefix()}-${slug}-v${version}-${dateStr}`;
     (project as any).name = projectName;
     // Set friendlyName explicitly so the platform doesn't "humanize" the slug
-    // (e.g. DMD → "DM D"). Use the original target verbatim for a clean label,
+    // (e.g. DMD → "DM D"). Use the original project name verbatim for a clean label,
     // and derive the label's leading words from the (configurable) name prefix.
     (project as any).friendlyName =
-      `${reviewNamePrefix().replace(/-/g, ' ')} ${opts.target} v${version} ${dateStr}`;
+      `${reviewNamePrefix().replace(/-/g, ' ')} ${opts.project} v${version} ${dateStr}`;
 
     try { (project as any).options[PUBLISHED_TAGS.PUBLISHED_ID] = publishId; } catch { /* swallow */ }
     // Step 9 writes the supersede pointer on the prior project; the NEW

package/src/publishing/publish-settings.ts

@@ -8,7 +8,7 @@
  * What is and isn't configurable, and why:
  *   - The **umbrella Space** ({@link reviewSpaceName}) and the **name prefix**
  *     ({@link reviewNamePrefix}) are free text.
- *   - The structural suffix `-<target-slug>-v<version>-<date>` is NOT configurable: the
+ *   - The structural suffix `-<project-slug>-v<version>-<date>` is NOT configurable: the
  *     republish flow finds the prior version by matching `"<prefix>-<slug>-v"` and parsing
  *     the `-v<n>-` segment (see `findPriorShare` in `publish-state.ts`). Letting the suffix
  *     vary would break version detection. So we expose the prefix, keep the skeleton fixed.
@@ -32,17 +32,27 @@ function readSetting(key: string, fallback: string): string {
   return fallback;
 }
 
-/** Umbrella Space the per-target review Spaces live under. Setting: `reviewSpaceName`. */
+/** Umbrella Space the per-project review Spaces live under. Setting: `reviewSpaceName`. */
 export function reviewSpaceName(): string {
   return readSetting('reviewSpaceName', DEFAULT_REVIEW_SPACE);
 }
 
-/** Prefix for the per-target child Space and the published project name.
+/** Prefix for the per-project child Space and the published project name.
  * Setting: `reviewNamePrefix`. The `-<slug>-v<version>-<date>` suffix stays fixed. */
 export function reviewNamePrefix(): string {
   return readSetting('reviewNamePrefix', DEFAULT_REVIEW_NAME_PREFIX);
 }
 
+/**
+ * Name of the team pre-selected in the Share for Review dialog's "Share with
+ * team" picker. Setting: `defaultReviewerGroup`. Empty (the default) means "no
+ * preference" — the dialog falls back to the first available team. A stale value
+ * (team renamed/removed) is ignored the same way.
+ */
+export function defaultReviewerGroup(): string {
+  return readSetting('defaultReviewerGroup', '');
+}
+
 /**
  * Whether to re-open each published dashboard and assert it survives a reload
  * (the heavy round-trip check). Default ON — keep it for client deliverables;
@@ -57,3 +67,47 @@ export function verifyPublishedDashboard(): boolean {
   } catch { /* settings not ready — use default */ }
   return true;
 }
+
+/**
+ * The controlled list of project names an analyst may share under. Maintained by
+ * package administrators via the `projectVocabulary` package setting — a
+ * comma-separated string they edit in the package Settings panel (add / modify /
+ * remove names); the Share for Review dialog offers exactly these (no free text).
+ *
+ * Parses the setting robustly: a comma / newline-separated string (the string
+ * property), or a JS array (future-proofing if the property is ever promoted to
+ * a `string_list`). Returns a de-duplicated, trimmed, order-preserving list;
+ * `[]` when unset or not-yet-loaded, which the dialog treats as "ask an admin".
+ */
+export function getProjectVocabulary(): string[] {
+  let raw: unknown;
+  try {
+    raw = (_package?.settings as Record<string, unknown> | undefined)?.['projectVocabulary'];
+  } catch { /* settings not ready */ return []; }
+  return parseProjectVocabulary(raw);
+}
+
+/**
+ * Pure parser for the `projectVocabulary` setting value — extracted so it can be
+ * unit-tested without a live package. Accepts a comma / newline-separated string
+ * (the string property) or a JS array (future `string_list`). Returns a
+ * de-duplicated, trimmed, order-preserving list.
+ */
+export function parseProjectVocabulary(raw: unknown): string[] {
+  let items: string[] = [];
+  if (Array.isArray(raw))
+    items = raw.map((v) => String(v));
+  else if (typeof raw === 'string')
+    items = raw.split(/[\r\n,]+/);
+
+  const seen = new Set<string>();
+  const out: string[] = [];
+  for (const it of items) {
+    const t = it.trim();
+    if (t.length > 0 && !seen.has(t)) {
+      seen.add(t);
+      out.push(t);
+    }
+  }
+  return out;
+}

package/src/publishing/publish-state.ts

@@ -26,7 +26,7 @@ export const PUBLISHED_TAGS = {
   PUBLISHED_AT: 'proteomics.published_at',
   PUBLISHED_BY: 'proteomics.published_by',
   PUBLISHED_BY_EMAIL: 'proteomics.published_by_email',
-  PUBLISHED_TARGET: 'proteomics.published_target',
+  PUBLISHED_PROJECT: 'proteomics.published_project',
   PUBLISHED_DE_METHOD: 'proteomics.published_de_method',
   PUBLISHED_FC_THRESHOLD: 'proteomics.published_fc_threshold',
   PUBLISHED_P_THRESHOLD: 'proteomics.published_p_threshold',
@@ -48,7 +48,7 @@ export const META_COLUMNS = {
   PUBLISHED_AT: '_meta_published_at',
   PUBLISHED_BY: '_meta_published_by',
   PUBLISHED_BY_EMAIL: '_meta_published_by_email',
-  PUBLISHED_TARGET: '_meta_published_target',
+  PUBLISHED_PROJECT: '_meta_published_project',
   PUBLISHED_DE_METHOD: '_meta_published_de_method',
   PUBLISHED_FC_THRESHOLD: '_meta_published_fc_threshold',
   PUBLISHED_P_THRESHOLD: '_meta_published_p_threshold',
@@ -59,10 +59,20 @@ export const META_COLUMNS = {
   SUPERSEDES: '_meta_supersedes',
 } as const;
 
+/**
+ * Legacy persisted keys from before the Target→Project rename (the project label
+ * used to be called "target"). Read-only fallbacks so analyses published under
+ * the old naming still open. Never written — {@link setPublishedTags} only emits
+ * the current `PUBLISHED_PROJECT` key.
+ */
+export const LEGACY_PUBLISHED_TARGET_TAG = 'proteomics.published_target' as const;
+export const LEGACY_PUBLISHED_TARGET_COL = '_meta_published_target' as const;
+
 /** Typed view of one published-analysis DataFrame's metadata. */
 export interface PublishedMetadata {
-  /** Raw user input — never use directly for paths/URLs (use {@link slugifyTarget}). */
-  target: string;
+  /** Raw user input — the project name. Never use directly for paths/URLs
+   *  (use {@link slugifyProject}). */
+  project: string;
   /** Normalized to Date when read; ISO string accepted on write. */
   publishedAt: Date;
   publishedBy: string;
@@ -70,7 +80,7 @@ export interface PublishedMetadata {
   deMethod: 'limma' | 'deqms' | 't-test' | 'spectronaut' | string;
   fcThreshold: number;
   pThreshold: number;
-  /** Monotonically increasing per (target, group); first share is version 1. */
+  /** Monotonically increasing per (project, group); first share is version 1. */
   version: number;
   /** The published Project's id — set after `projects.save` returns. */
   publishId: string;
@@ -83,7 +93,7 @@ export interface PublishedMetadata {
 
 /** Input shape consumed by `share-dialog.ts` → `publishAnalysis(df, opts)`. */
 export interface PublishOptions {
-  target: string;
+  project: string;
   reviewerGroup: DG.Group;
   note: string;
   /** Set by {@link findPriorShare} when this is a republish; null on first share. */
@@ -121,7 +131,7 @@ export function isPublished(df: DG.DataFrame): boolean {
  * Reads the published metadata from a DataFrame, column-FIRST and tag-SECOND
  * (Pitfall 3 belt-and-braces). Returns `null` when the DataFrame is not a
  * published analysis. Returns a populated object when at least the required
- * load-bearing fields (target, publishId) are recoverable; per-field corruption
+ * load-bearing fields (project, publishId) are recoverable; per-field corruption
  * falls back gracefully without crashing the whole read.
  */
 export function getPublishedMetadata(df: DG.DataFrame): PublishedMetadata | null {
@@ -171,16 +181,35 @@ export function getPublishedMetadata(df: DG.DataFrame): PublishedMetadata | null
     return s === 'true';
   };
 
-  const target = readString('PUBLISHED_TARGET', 'PUBLISHED_TARGET');
+  // Project label — read the current key, then fall back to the pre-rename
+  // `published_target` tag/column so already-published analyses still open.
+  const readProject = (): string | null => {
+    const current = readString('PUBLISHED_PROJECT', 'PUBLISHED_PROJECT');
+    if (current != null) return current;
+    try {
+      const col = df.col(LEGACY_PUBLISHED_TARGET_COL);
+      if (col != null) {
+        const v = col.get(0);
+        if (v != null && v !== '') return String(v);
+      }
+    } catch { /* fall through to legacy tag */ }
+    try {
+      return df.getTag(LEGACY_PUBLISHED_TARGET_TAG) ?? null;
+    } catch {
+      return null;
+    }
+  };
+
+  const project = readProject();
   const publishId = readString('PUBLISHED_ID', 'PUBLISHED_ID');
-  if (target == null || publishId == null) return null;
+  if (project == null || publishId == null) return null;
 
   const publishedAt = readDate();
   const versionRaw = readString('PUBLISHED_VERSION', 'PUBLISHED_VERSION');
   const versionNum = versionRaw != null ? parseInt(versionRaw, 10) : NaN;
 
   return {
-    target,
+    project,
     publishedAt: publishedAt ?? new Date(NaN),
     publishedBy: readString('PUBLISHED_BY', 'PUBLISHED_BY') ?? '',
     publishedByEmail: readString('PUBLISHED_BY_EMAIL', 'PUBLISHED_BY_EMAIL'),
@@ -212,7 +241,7 @@ export function setPublishedTags(df: DG.DataFrame, meta: PublishedMetadata): voi
   df.setTag(PUBLISHED_TAGS.PUBLISHED_BY, meta.publishedBy);
   if (meta.publishedByEmail != null)
     df.setTag(PUBLISHED_TAGS.PUBLISHED_BY_EMAIL, meta.publishedByEmail);
-  df.setTag(PUBLISHED_TAGS.PUBLISHED_TARGET, meta.target);
+  df.setTag(PUBLISHED_TAGS.PUBLISHED_PROJECT, meta.project);
   df.setTag(PUBLISHED_TAGS.PUBLISHED_DE_METHOD, meta.deMethod);
   df.setTag(PUBLISHED_TAGS.PUBLISHED_FC_THRESHOLD, String(meta.fcThreshold));
   df.setTag(PUBLISHED_TAGS.PUBLISHED_P_THRESHOLD, String(meta.pThreshold));
@@ -226,7 +255,7 @@ export function setPublishedTags(df: DG.DataFrame, meta: PublishedMetadata): voi
 }
 
 /**
- * Sanitizes a freeform target string per D-01 into a safe slug.
+ * Sanitizes a freeform project string per D-01 into a safe slug.
  *
  * Rules:
  *  - Charset `[A-Za-z0-9._-]` (case PRESERVED — do NOT lowercase)
@@ -235,7 +264,7 @@ export function setPublishedTags(df: DG.DataFrame, meta: PublishedMetadata): voi
  *  - Cap at 64 chars
  *  - Empty result → `'unnamed'` (never produce empty slug — would break Project.name)
  */
-export function slugifyTarget(raw: string): string {
+export function slugifyProject(raw: string): string {
   if (raw == null) return 'unnamed';
   let s = String(raw)
     .replace(/[^A-Za-z0-9._-]+/g, '-')
@@ -249,7 +278,7 @@ export function slugifyTarget(raw: string): string {
 
 /**
  * Looks up the most recent prior published Project matching the slugified
- * target. Used by Plan 05 (`share-dialog.ts`) for republish-detection banner
+ * project. Used by Plan 05 (`share-dialog.ts`) for republish-detection banner
  * and Plan 04 (`publish-project.ts`) for the supersede chain.
  *
  * Smart-filter `like` confirmed working by spike 15-00 (assumption A8); the
@@ -260,8 +289,8 @@ export function slugifyTarget(raw: string): string {
  * the platform ACL implicitly scoping `dapi.projects.filter` to projects the
  * current user can administer.
  */
-export async function findPriorShare(target: string, _group: DG.Group | null): Promise<DG.Project | null> {
-  const slug = slugifyTarget(target);
+export async function findPriorShare(project: string, _group: DG.Group | null): Promise<DG.Project | null> {
+  const slug = slugifyProject(project);
   const namePrefix = `${reviewNamePrefix()}-${slug}-v`;
   const versionRe = /-v(\d+)-/;
 

package/src/publishing/reviewer-groups.ts

@@ -0,0 +1,24 @@
+import * as grok from 'datagrok-api/grok';
+import * as DG from 'datagrok-api/dg';
+
+/**
+ * Loads the teams eligible as reviewers — excludes hidden and personal groups
+ * and the built-in 'All users' group. Shared by the Share for Review dialog and
+ * the package settings editor so both offer exactly the same set.
+ */
+export async function loadReviewerGroups(): Promise<DG.Group[]> {
+  const allGroups = await grok.dapi.groups.list();
+  const allUsersId = (DG.Group as any).defaultGroupsIds?.['All users'];
+  return (allGroups ?? []).filter((g: any) => {
+    if (g == null) return false;
+    if (g.hidden) return false;
+    if (g.personal) return false;
+    if (allUsersId && g.id === allUsersId) return false;
+    return true;
+  });
+}
+
+/** Display name used as the choice key — friendlyName, falling back to name. */
+export function reviewerGroupName(g: DG.Group): string {
+  return (g as any).friendlyName ?? (g as any).name ?? '';
+}

package/src/publishing/share-dialog.ts

@@ -3,10 +3,11 @@ import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 
 import {
-  DE_COMPLETE_TAG, PublishOptions, findPriorShare, slugifyTarget,
+  DE_COMPLETE_TAG, PublishOptions, findPriorShare, slugifyProject,
 } from './publish-state';
 import {publishAnalysis} from './publish-project';
-import {reviewNamePrefix, verifyPublishedDashboard} from './publish-settings';
+import {defaultReviewerGroup, getProjectVocabulary, reviewNamePrefix, verifyPublishedDashboard} from './publish-settings';
+import {loadReviewerGroups, reviewerGroupName} from './reviewer-groups';
 
 /**
  * Analyst-facing share dialog. Single entry point into the publish flow —
@@ -32,15 +33,7 @@ export async function showShareForReviewDialog(df: DG.DataFrame): Promise<void>
     return;
   }
 
-  const allGroups = await grok.dapi.groups.list();
-  const allUsersId = (DG.Group as any).defaultGroupsIds?.['All users'];
-  const filteredGroups = (allGroups ?? []).filter((g: any) => {
-    if (g == null) return false;
-    if (g.hidden) return false;
-    if (g.personal) return false;
-    if (allUsersId && g.id === allUsersId) return false;
-    return true;
-  });
+  const filteredGroups = await loadReviewerGroups();
 
   if (filteredGroups.length === 0) {
     grok.shell.warning('No teams available to share with. Ask an admin to create a reviewer team.');
@@ -49,16 +42,38 @@ export async function showShareForReviewDialog(df: DG.DataFrame): Promise<void>
 
   const groupByName = new Map<string, DG.Group>();
   for (const g of filteredGroups) {
-    const name = (g as any).friendlyName ?? (g as any).name ?? '';
+    const name = reviewerGroupName(g);
     if (name && !groupByName.has(name)) groupByName.set(name, g);
   }
   const groupItems = Array.from(groupByName.keys());
 
-  const targetInput = ui.input.string('Target', {value: ''});
-  targetInput.setTooltip('Free text — your team\'s name for this target (e.g., MYH7-DMD, muscle-atrophy panel)');
+  // Pre-select the admin-configured default team when it's still available;
+  // otherwise fall back to the first team in the list.
+  const configuredDefault = defaultReviewerGroup();
+  const defaultGroupName = configuredDefault && groupItems.includes(configuredDefault)
+    ? configuredDefault
+    : groupItems[0];
+
+  // Project is a controlled vocabulary — admins maintain the list in the
+  // `projectVocabulary` package setting; the analyst picks, never free-types.
+  const projectVocabulary = getProjectVocabulary();
+  if (projectVocabulary.length === 0) {
+    grok.shell.warning(
+      'No projects are configured to share under. Ask a package administrator to add project ' +
+      'names in the Proteomics package settings (projectVocabulary).');
+    return;
+  }
+
+  const projectInput = ui.input.choice('Project', {
+    value: projectVocabulary[0],
+    items: projectVocabulary,
+    nullable: false,
+  });
+  projectInput.setTooltip('Pick the project to share this analysis under. ' +
+    'Maintained by package administrators in the Proteomics package settings.');
 
   const groupInput = ui.input.choice('Share with team', {
-    value: groupItems[0],
+    value: defaultGroupName,
     items: groupItems,
     nullable: false,
   });
@@ -92,14 +107,14 @@ export async function showShareForReviewDialog(df: DG.DataFrame): Promise<void>
   };
 
   const updateBannerAndSummary = async (): Promise<void> => {
-    const target = (targetInput.value ?? '').trim();
+    const project = (projectInput.value ?? '').trim();
     const groupName = groupInput.value;
     const group = groupName ? groupByName.get(groupName) ?? null : null;
-    const slug = target ? slugifyTarget(target) : '<no-target>';
+    const slug = project ? slugifyProject(project) : '<no-project>';
     const dateStr = new Date().toISOString().slice(0, 10);
 
-    if (target && group) {
-      try { priorVersion = await findPriorShare(target, group); }
+    if (project && group) {
+      try { priorVersion = await findPriorShare(project, group); }
       catch { priorVersion = null; }
     } else {
       priorVersion = null;
@@ -124,32 +139,32 @@ export async function showShareForReviewDialog(df: DG.DataFrame): Promise<void>
       : 'New share';
 
     summary.innerHTML = '';
-    summary.appendChild(ui.divText(`Project: ${projectName}`));
+    summary.appendChild(ui.divText(`Published as: ${projectName}`));
     summary.appendChild(ui.divText(`Will be visible to: ${groupLabel}`));
     summary.appendChild(ui.divText(`Status: ${statusLabel}`));
     summary.appendChild(ui.divText(`Date: ${dateStr}`));
   };
 
-  targetInput.onChanged.subscribe(() => { void updateBannerAndSummary(); });
+  projectInput.onChanged.subscribe(() => { void updateBannerAndSummary(); });
   groupInput.onChanged.subscribe(() => { void updateBannerAndSummary(); });
 
   await updateBannerAndSummary();
 
   ui.dialog('Share Analysis for Review')
-    .add(targetInput)
+    .add(projectInput)
     .add(groupInput)
     .add(noteInput)
     .add(verifyInput)
     .add(banner)
     .add(summary)
     .onOK(async () => {
-      const target = (targetInput.value ?? '').trim();
-      if (!target) { grok.shell.warning('Target is required.'); return; }
+      const project = (projectInput.value ?? '').trim();
+      if (!project) { grok.shell.warning('Project is required.'); return; }
       const group = groupInput.value ? groupByName.get(groupInput.value) : null;
       if (!group) { grok.shell.warning('Pick a team to share with.'); return; }
 
       const opts: PublishOptions = {
-        target,
+        project,
         reviewerGroup: group,
         note: (noteInput.value ?? '') as string,
         priorVersion,
@@ -157,12 +172,12 @@ export async function showShareForReviewDialog(df: DG.DataFrame): Promise<void>
       };
 
       try {
-        const project = await publishAnalysis(df, opts);
+        const publishedProject = await publishAnalysis(df, opts);
         const groupName = (group as any).friendlyName ?? (group as any).name ?? '(unnamed team)';
         // Single non-modal confirmation — the published project is browsable in the
         // Spaces tree, so no modal or action links are needed. publishAnalysis no
         // longer emits its own toast, so this is the one and only confirmation.
-        grok.shell.info(`Shared as ${(project as any).name} with team ${groupName}.`);
+        grok.shell.info(`Shared as ${(publishedProject as any).name} with team ${groupName}.`);
       } catch (e: any) {
         grok.shell.error(`Share failed: ${e?.message ?? String(e)}`);
       }

package/src/publishing/trim-dataframe.ts

@@ -87,6 +87,11 @@ export function trimForPublish(source: DG.DataFrame, meta: PublishedMetadata): D
   }) ?? null;
   const significant = findColumn(source, '', ['significant', 'sig']);
   const direction = findColumn(source, '', ['direction', 'regulation', 'up_down']);
+  // Per-condition mean abundance (Candidates). Kept so the shared snapshot can
+  // still render the Rank–Abundance / dynamic-range plot; soft (omitted when
+  // absent, e.g. a Report snapshot or an older Candidates export).
+  const qtyNum = findColumn(source, '', ['avg group quantity numerator']);
+  const qtyDen = findColumn(source, '', ['avg group quantity denominator']);
 
   const required: Array<[string, DG.Column | null]> = [
     ['Protein ID', proteinId],
@@ -108,6 +113,8 @@ export function trimForPublish(source: DG.DataFrame, meta: PublishedMetadata): D
     adjPValue!.name,
     significant!.name,
     direction?.name,
+    qtyNum?.name,
+    qtyDen?.name,
   ].filter((n): n is string => typeof n === 'string' && n.length > 0)));
 
   const frozen = source.clone(null, allowlist);
@@ -153,7 +160,7 @@ export function trimForPublish(source: DG.DataFrame, meta: PublishedMetadata): D
     {name: META_COLUMNS.PUBLISHED_AT, value: meta.publishedAt, type: 'datetime'},
     {name: META_COLUMNS.PUBLISHED_BY, value: meta.publishedBy, type: 'string'},
     {name: META_COLUMNS.PUBLISHED_BY_EMAIL, value: meta.publishedByEmail ?? '', type: 'string', emptyForNull: true},
-    {name: META_COLUMNS.PUBLISHED_TARGET, value: meta.target, type: 'string'},
+    {name: META_COLUMNS.PUBLISHED_PROJECT, value: meta.project, type: 'string'},
     {name: META_COLUMNS.PUBLISHED_DE_METHOD, value: meta.deMethod, type: 'string'},
     {name: META_COLUMNS.PUBLISHED_FC_THRESHOLD, value: String(meta.fcThreshold), type: 'string'},
     {name: META_COLUMNS.PUBLISHED_P_THRESHOLD, value: String(meta.pThreshold), type: 'string'},