diff --git a/src/component/elements/tanstack_table/elements/table_row.tsx b/src/component/elements/tanstack_table/elements/table_row.tsx
index f1c42e1e5..3fb252eb5 100644
--- a/src/component/elements/tanstack_table/elements/table_row.tsx
+++ b/src/component/elements/tanstack_table/elements/table_row.tsx
@@ -103,6 +103,7 @@ export default function TableRow<TData extends TanStackRowData>(
     table,
     highlightedSource = 'UNKNOWN',
     getHighlightExtra,
+    getHighlightIDs,
     onContextMenuSelect,
     contextMenu,
     onClick,
@@ -121,7 +122,10 @@ export default function TableRow<TData extends TanStackRowData>(
       }) as HighlightEventSource,
     [highlightedSource, row.original, getHighlightExtra],
   );
-  const highlight = useHighlight(getIDs(row), data);
+  const highlight = useHighlight(
+    getHighlightIDs?.(row.original) ?? getIDs(row),
+    data,
+  );
 
   useEffect(() => {
     return () => {
diff --git a/src/component/elements/tanstack_table/table.tsx b/src/component/elements/tanstack_table/table.tsx
index 81d15754d..d11500fb9 100644
--- a/src/component/elements/tanstack_table/table.tsx
+++ b/src/component/elements/tanstack_table/table.tsx
@@ -118,6 +118,7 @@ function TanStackTableInner<TData extends TanStackRowData>(
     columns,
     highlightedSource,
     getHighlightExtra,
+    getHighlightIDs,
     contextMenu = [],
     onContextMenuSelect,
     onScroll,
@@ -265,6 +266,7 @@ function TanStackTableInner<TData extends TanStackRowData>(
               const highlightSourceProps = {
                 highlightedSource,
                 getHighlightExtra,
+                getHighlightIDs,
               } as TanStackTableHighlightSourceProps<TData>;
 
               return (
diff --git a/src/component/elements/tanstack_table/types.ts b/src/component/elements/tanstack_table/types.ts
index 2443d3693..4e8b8974f 100644
--- a/src/component/elements/tanstack_table/types.ts
+++ b/src/component/elements/tanstack_table/types.ts
@@ -44,6 +44,8 @@ export type TanStackTableHeaderGroup<TData extends TanStackRowData> =
   HeaderGroup<TanStackTableFeatures, TData>;
 
 export type TanStackTableHighlightSourceProps<TData extends TanStackRowData> = {
+  getHighlightIDs?: (row: TData) => string[];
+} & {
   [K in HighlightEventSourceType]: HighlightEventSourceExtra<K> extends never
     ? { highlightedSource?: K; getHighlightExtra?: never }
     : {
diff --git a/src/component/highlight/index.tsx b/src/component/highlight/index.tsx
index 0287be9f5..87995d3b9 100644
--- a/src/component/highlight/index.tsx
+++ b/src/component/highlight/index.tsx
@@ -36,6 +36,7 @@ interface HighlightEventSourceMap {
   MULTIPLE_ANALYSIS_ZONE: { colKey: string };
   DATABASE: { ranges: Range[]; jcampURL: string; baseURL: string };
   ATOM: never;
+  ASSIGNMENT_TABLE: never;
   UNKNOWN: never;
 }
 
diff --git a/src/component/hooks/use_publication_strings.ts b/src/component/hooks/use_publication_strings.ts
index 17310a45d..4a1117ec2 100644
--- a/src/component/hooks/use_publication_strings.ts
+++ b/src/component/hooks/use_publication_strings.ts
@@ -1,4 +1,8 @@
-import type { ACSExportOptions, Spectrum } from '@zakodium/nmrium-core';
+import type {
+  ACSExportOptions,
+  Spectrum1D,
+  Spectrum,
+} from '@zakodium/nmrium-core';
 import { assertSpectrum1D, isSpectrum1D } from '@zakodium/nmrium-core';
 import type { RangesToACSOptions } from 'nmr-processing';
 import { rangesToACS } from 'nmr-processing';
@@ -39,8 +43,7 @@ export function buildPublicationString(options: BuildPublicationStringOptions) {
     info,
     ranges: { values },
   } = spectrum;
-  const { originFrequency, nucleus } = info;
-  const { signalKind, format, couplingFormat, ...otherOptions } = acs;
+  const { signalKind } = acs;
 
   const ranges =
     signalKind === 'all'
@@ -49,7 +52,16 @@ export function buildPublicationString(options: BuildPublicationStringOptions) {
           range.signals?.some((signal) => signal.kind === 'signal'),
         );
 
-  const rangesToACSOptions: RangesToACSOptions = {
+  return rangesToACS(ranges, getRangesToACSOptions(info, acs));
+}
+
+export function getRangesToACSOptions(
+  info: Pick<Spectrum1D['info'], 'nucleus' | 'originFrequency'>,
+  acs: ACSExportOptions,
+): RangesToACSOptions {
+  const { originFrequency, nucleus } = info;
+  const { signalKind, format, couplingFormat, ...otherOptions } = acs;
+  const options: RangesToACSOptions = {
     nucleus,
     observedFrequency: originFrequency,
     ...otherOptions,
@@ -57,9 +69,9 @@ export function buildPublicationString(options: BuildPublicationStringOptions) {
   };
 
   if (format !== 'D') {
-    rangesToACSOptions.format = format;
-    rangesToACSOptions.couplingFormat = couplingFormat;
+    options.format = format;
+    options.couplingFormat = couplingFormat;
   }
 
-  return rangesToACS(ranges, rangesToACSOptions);
+  return options;
 }
diff --git a/src/component/panels/MoleculesPanel/hooks/useAtomAssignment.tsx b/src/component/panels/MoleculesPanel/hooks/useAtomAssignment.tsx
index 1a225492c..78d4b41ae 100644
--- a/src/component/panels/MoleculesPanel/hooks/useAtomAssignment.tsx
+++ b/src/component/panels/MoleculesPanel/hooks/useAtomAssignment.tsx
@@ -102,6 +102,10 @@ export default function useAtomAssignment() {
   const currentDiaIDsToHighlight = useMemo(() => {
     const { highlighted, sourceData } = highlightData.highlight;
 
+    if (sourceData?.type === 'ASSIGNMENT_TABLE') {
+      return highlighted;
+    }
+
     let currentSpectrum = spectrum;
 
     if (
diff --git a/src/component/panels/Panels.tsx b/src/component/panels/Panels.tsx
index f68c09392..1bc1eb00c 100644
--- a/src/component/panels/Panels.tsx
+++ b/src/component/panels/Panels.tsx
@@ -5,8 +5,10 @@ import { memo } from 'react';
 import { Accordion, Toolbar } from 'react-science/ui';
 
 import { usePreferences } from '../context/PreferencesContext.js';
+import useCheckExperimentalFeature from '../hooks/useCheckExperimentalFeature.js';
 
 import type { AccordionItem } from './accordionItems.js';
+import { AssignmentSummaryPanel } from './assignment-summary/AssignmentSummaryPanel.js';
 import { useAccordionItems } from './hooks/useAccordionItems.js';
 import { useGetPanelOptions } from './hooks/useGetPanelOptions.js';
 import { useTogglePanel } from './hooks/useTogglePanel.js';
@@ -18,6 +20,7 @@ const Container = styled.div`
 `;
 
 function PanelsInner() {
+  const isExperimental = useCheckExperimentalFeature();
   const getPanelPreferences = useGetPanelOptions();
 
   const { dispatch } = usePreferences();
@@ -38,27 +41,41 @@ function PanelsInner() {
   return (
     <Container>
       <Accordion>
-        {displayedPanels.map((item) => {
-          const { title, component, id } = item;
-          return (
-            <Accordion.Item
-              unmountChildren
-              id={id}
-              key={title}
-              title={title}
-              open={isOpened(item)}
-              onOpenChange={(isOpened) => {
-                dispatch({
-                  type: 'TOGGLE_PANEL',
-                  payload: { id, options: { open: isOpened } },
-                });
-              }}
-              renderToolbar={() => <RightButtons id={id} />}
-            >
-              {component}
-            </Accordion.Item>
-          );
-        })}
+        {[
+          ...displayedPanels.map((item) => {
+            const { title, component, id } = item;
+            return (
+              <Accordion.Item
+                unmountChildren
+                id={id}
+                key={title}
+                title={title}
+                open={isOpened(item)}
+                onOpenChange={(isOpened) => {
+                  dispatch({
+                    type: 'TOGGLE_PANEL',
+                    payload: { id, options: { open: isOpened } },
+                  });
+                }}
+                renderToolbar={() => <RightButtons id={id} />}
+              >
+                {component}
+              </Accordion.Item>
+            );
+          }),
+          ...(isExperimental
+            ? [
+                <Accordion.Item
+                  key="assignment-summary"
+                  id="assignment-summary"
+                  title="Assignment summary"
+                  unmountChildren
+                >
+                  <AssignmentSummaryPanel />
+                </Accordion.Item>,
+              ]
+            : []),
+        ]}
       </Accordion>
     </Container>
   );
diff --git a/src/component/panels/assignment-summary/AssignmentSummaryPanel.tsx b/src/component/panels/assignment-summary/AssignmentSummaryPanel.tsx
new file mode 100644
index 000000000..60ad99153
--- /dev/null
+++ b/src/component/panels/assignment-summary/AssignmentSummaryPanel.tsx
@@ -0,0 +1,229 @@
+import styled from '@emotion/styled';
+import { Molecule } from 'openchemlib';
+import type { GroupedDiaID } from 'openchemlib-utils';
+import { TopicMolecule } from 'openchemlib-utils';
+import { useMemo, useState } from 'react';
+import { PanelHeader, Toolbar } from 'react-science/ui';
+
+import type { StateMoleculeExtended } from '../../../data/molecules/Molecule.js';
+import { useChartData } from '../../context/ChartContext.js';
+import { EmptyText } from '../../elements/EmptyText.js';
+import Select from '../../elements/Select.js';
+import type { ToolbarPopoverMenuItem } from '../../elements/ToolbarPopoverItem.js';
+import { ToolbarPopoverItem } from '../../elements/ToolbarPopoverItem.js';
+import { TablePanel } from '../extra/BasicPanelStyle.js';
+
+import { AssignmentsExportModal } from './AssignmentsExportModal.js';
+import { MoleculeAssignmentTable } from './MoleculeAssignmentTable.js';
+import { atomGroupsToAssignmentRows } from './utilities/atomGroupsToAssignmentRows.js';
+
+const HeaderControls = styled.div`
+  display: flex;
+  align-items: center;
+  flex: 1;
+  justify-content: flex-start;
+  gap: 8px;
+  min-height: 0;
+  min-width: 0;
+  padding: 4px;
+
+  label {
+    flex-shrink: 0;
+    white-space: nowrap;
+  }
+`;
+
+interface MoleculeAssignmentData {
+  molecule: StateMoleculeExtended;
+  groups: GroupedDiaID[];
+  expandableGroupIds: string[];
+}
+
+function getMoleculeOptions(moleculeAssignments: MoleculeAssignmentData[]) {
+  return moleculeAssignments.map(({ molecule }) => ({
+    value: molecule.id,
+    label: molecule.label,
+  }));
+}
+
+function toggleExpandedRows(
+  expandedRows: ReadonlySet<string>,
+  keys: readonly string[],
+): Set<string> {
+  const shouldCollapse = keys.every((key) => expandedRows.has(key));
+  const next = new Set(expandedRows);
+  for (const key of keys) {
+    if (shouldCollapse) {
+      next.delete(key);
+    } else {
+      next.add(key);
+    }
+  }
+  return next;
+}
+
+function useMoleculeAssignments(molecules: StateMoleculeExtended[]) {
+  const [selectedMoleculeId, selectMolecule] = useState<string>();
+  const moleculeAssignments = useMemo<MoleculeAssignmentData[]>(
+    () =>
+      molecules.map((molecule) => {
+        const topicMolecule = new TopicMolecule(
+          Molecule.fromMolfile(molecule.molfile),
+        );
+        const groups = topicMolecule.getGroupedDiastereotopicAtomIDs() ?? [];
+        return {
+          molecule,
+          groups,
+          expandableGroupIds: atomGroupsToAssignmentRows(groups, false)
+            .filter((row) => row.hasChildren)
+            .map((row) => row.id),
+        };
+      }),
+    [molecules],
+  );
+  const activeAssignment =
+    moleculeAssignments.find(
+      ({ molecule }) => molecule.id === selectedMoleculeId,
+    ) ?? moleculeAssignments[0];
+
+  return { moleculeAssignments, activeAssignment, selectMolecule };
+}
+
+function useAssignmentExpansion(activeAssignment: MoleculeAssignmentData) {
+  const [expandedGroupsByMolecule, setExpandedGroupsByMolecule] = useState<
+    ReadonlyMap<string, ReadonlySet<string>>
+  >(() => new Map());
+  const moleculeId = activeAssignment.molecule.id;
+  const { expandableGroupIds } = activeAssignment;
+  const expandedGroups =
+    expandedGroupsByMolecule.get(moleculeId) ?? new Set<string>();
+
+  function toggleRows(groupIds: readonly string[]) {
+    setExpandedGroupsByMolecule((previous) => {
+      const next = new Map(previous);
+      next.set(
+        moleculeId,
+        toggleExpandedRows(previous.get(moleculeId) ?? new Set(), groupIds),
+      );
+      return next;
+    });
+  }
+
+  function setAllRows(expanded: boolean) {
+    setExpandedGroupsByMolecule((previous) => {
+      const next = new Map(previous);
+      next.set(moleculeId, new Set(expanded ? expandableGroupIds : []));
+      return next;
+    });
+  }
+
+  function toggleRow(groupId: string) {
+    toggleRows([groupId]);
+  }
+
+  return {
+    expandedGroups,
+    canExpand: expandableGroupIds.some((id) => !expandedGroups.has(id)),
+    canCollapse: expandableGroupIds.some((id) => expandedGroups.has(id)),
+    toggleRow,
+    setAllRows,
+  };
+}
+
+type ExpansionAction = 'expand' | 'collapse';
+
+const EXPANSION_MENU: Array<ToolbarPopoverMenuItem<ExpansionAction>> = [
+  { text: 'Expand all', icon: 'expand-all', data: 'expand' },
+  { text: 'Collapse all', icon: 'collapse-all', data: 'collapse' },
+];
+
+interface ExpansionMenuProps {
+  canExpand: boolean;
+  canCollapse: boolean;
+  onSelect: (expanded: boolean) => void;
+}
+
+function ExpansionMenu(props: ExpansionMenuProps) {
+  const { canExpand, canCollapse, onSelect } = props;
+  const options = EXPANSION_MENU.map((option) => ({
+    ...option,
+    disabled: option.data === 'expand' ? !canExpand : !canCollapse,
+  }));
+
+  return (
+    <ToolbarPopoverItem<ExpansionAction>
+      icon="expand-all"
+      tooltip="Expand / collapse rows"
+      tooltipProps={{ minimal: true }}
+      options={options}
+      onClick={(action) => onSelect(action === 'expand')}
+    />
+  );
+}
+
+export function AssignmentSummaryPanel() {
+  const { molecules } = useChartData();
+  const { moleculeAssignments, activeAssignment, selectMolecule } =
+    useMoleculeAssignments(molecules);
+
+  if (!activeAssignment) {
+    return <EmptyText text="No molecules available" />;
+  }
+
+  return (
+    <AssignmentSummary
+      moleculeAssignments={moleculeAssignments}
+      activeAssignment={activeAssignment}
+      onSelectMolecule={selectMolecule}
+    />
+  );
+}
+
+interface AssignmentSummaryProps {
+  moleculeAssignments: MoleculeAssignmentData[];
+  activeAssignment: MoleculeAssignmentData;
+  onSelectMolecule: (moleculeId: string) => void;
+}
+
+function AssignmentSummary(props: AssignmentSummaryProps) {
+  const { moleculeAssignments, activeAssignment, onSelectMolecule } = props;
+  const expansion = useAssignmentExpansion(activeAssignment);
+  const { molecule } = activeAssignment;
+
+  return (
+    <TablePanel>
+      <PanelHeader>
+        <Toolbar>
+          <AssignmentsExportModal
+            groups={activeAssignment.groups}
+            expandedGroups={expansion.expandedGroups}
+            moleculeLabel={molecule.label}
+          />
+          <ExpansionMenu
+            canExpand={expansion.canExpand}
+            canCollapse={expansion.canCollapse}
+            onSelect={expansion.setAllRows}
+          />
+        </Toolbar>
+        <HeaderControls>
+          {moleculeAssignments.length > 1 && (
+            <Select
+              items={getMoleculeOptions(moleculeAssignments)}
+              value={molecule.id}
+              onChange={onSelectMolecule}
+              style={{ width: 140 }}
+            />
+          )}
+        </HeaderControls>
+      </PanelHeader>
+      <div className="inner-container">
+        <MoleculeAssignmentTable
+          key={molecule.id}
+          groups={activeAssignment.groups}
+          expandedGroups={expansion.expandedGroups}
+          onToggleRow={expansion.toggleRow}
+        />
+      </div>
+    </TablePanel>
+  );
+}
diff --git a/src/component/panels/assignment-summary/AssignmentsExportModal.tsx b/src/component/panels/assignment-summary/AssignmentsExportModal.tsx
new file mode 100644
index 000000000..67d074163
--- /dev/null
+++ b/src/component/panels/assignment-summary/AssignmentsExportModal.tsx
@@ -0,0 +1,237 @@
+import { Classes, DialogFooter, RadioCard } from '@blueprintjs/core';
+import styled from '@emotion/styled';
+import type { GroupedDiaID } from 'openchemlib-utils';
+import { useState } from 'react';
+import { FaCopy, FaDownload, FaFileExport } from 'react-icons/fa';
+import { AppForm, Button, useForm } from 'react-science/ui';
+
+import { ClipboardFallbackModal } from '../../../utils/clipboard/clipboardComponents.js';
+import { useClipboard } from '../../../utils/clipboard/clipboardHooks.js';
+import { useChartData } from '../../context/ChartContext.js';
+import { usePreferences } from '../../context/PreferencesContext.js';
+import { useToaster } from '../../context/ToasterContext.js';
+import { StandardDialog } from '../../elements/StandardDialog.js';
+import { StyledDialogBody } from '../../elements/StyledDialogBody.js';
+import type { ToolbarPopoverMenuItem } from '../../elements/ToolbarPopoverItem.js';
+import { ToolbarPopoverItem } from '../../elements/ToolbarPopoverItem.js';
+import { useDialogToggle } from '../../hooks/useDialogToggle.js';
+import { useACSSettings } from '../../hooks/use_acs_settings.js';
+import { saveAs } from '../../utility/save_as.js';
+
+import type { AssignmentExportRowMode } from './utilities/exportAssignments.js';
+import { exportAssignments } from './utilities/exportAssignments.js';
+
+type ExportAction = 'copy' | 'export';
+
+interface RowOption {
+  label: string;
+  description: string;
+  value: AssignmentExportRowMode;
+}
+
+const EXPORT_MENU = [
+  { text: 'Copy as TSV', icon: <FaCopy />, data: 'copy' },
+  { text: 'Export as CSV', icon: <FaDownload />, data: 'export' },
+] satisfies Array<ToolbarPopoverMenuItem<ExportAction>>;
+
+const ROW_OPTIONS: RowOption[] = [
+  {
+    label: 'Current table view',
+    description: 'Keep the rows exactly as they are currently shown.',
+    value: 'current',
+  },
+  {
+    label: 'Expanded view',
+    description:
+      'Show each hydrogen group on a separate row below its parent atom.',
+    value: 'expanded',
+  },
+  {
+    label: 'Collapsed view',
+    description:
+      'Include hydrogen numbers and labels in parentheses on the parent row.',
+    value: 'collapsed',
+  },
+];
+
+const INITIAL_VALUES: { rows: AssignmentExportRowMode } = { rows: 'current' };
+
+interface AssignmentsExportModalProps {
+  groups: GroupedDiaID[];
+  expandedGroups: ReadonlySet<string>;
+  moleculeLabel: string;
+}
+
+export function AssignmentsExportModal(props: AssignmentsExportModalProps) {
+  const { groups, expandedGroups, moleculeLabel } = props;
+  const { data } = useChartData();
+  const { current } = usePreferences();
+  const defaultACSOptions = useACSSettings(undefined);
+  const toaster = useToaster();
+  const [action, setAction] = useState<ExportAction>('copy');
+  const { dialog, openDialog, closeDialog } = useDialogToggle({
+    exportAssignments: false,
+  });
+  const { rawWriteWithType, shouldFallback, cleanShouldFallback, text } =
+    useClipboard();
+
+  const exportMenu = EXPORT_MENU.map((option) => ({
+    ...option,
+    onClick: () => handleOpenDialog(option.data),
+  }));
+
+  function handleOpenDialog(exportAction: ExportAction) {
+    setAction(exportAction);
+    openDialog('exportAssignments');
+  }
+
+  async function handleExport(
+    exportAction: ExportAction,
+    rowMode: AssignmentExportRowMode,
+  ) {
+    const isCopy = exportAction === 'copy';
+    try {
+      const delimitedText = exportAssignments({
+        groups,
+        spectra: data,
+        expandedGroups,
+        rowMode,
+        acsExportSettings: current.acsExportSettings,
+        defaultACSOptions,
+        delimiter: isCopy ? '\t' : ',',
+      });
+
+      if (isCopy) {
+        await rawWriteWithType(delimitedText, 'text/plain');
+        return closeDialog();
+      }
+
+      saveAs({
+        blob: new Blob([delimitedText], { type: 'text/csv;charset=utf-8' }),
+        name: `${moleculeLabel}-assignments`,
+        extension: '.csv',
+      });
+
+      closeDialog();
+    } catch (error: unknown) {
+      toaster.show({
+        message: `Could not ${exportAction} assignments as ${isCopy ? 'TSV' : 'CSV'}: ${
+          error instanceof Error ? error.message : String(error)
+        }`,
+        intent: 'danger',
+      });
+    }
+  }
+
+  return (
+    <>
+      <ToolbarPopoverItem<ExportAction>
+        id="assignment-export"
+        icon={<FaFileExport />}
+        tooltip="Export"
+        options={exportMenu}
+        disabled={groups.length === 0}
+      />
+      {dialog.exportAssignments && (
+        <AssignmentsExportModalContent
+          action={action}
+          onClose={closeDialog}
+          onSubmit={(rowMode) => handleExport(action, rowMode)}
+        />
+      )}
+      <ClipboardFallbackModal
+        mode={shouldFallback}
+        onDismiss={cleanShouldFallback}
+        text={text}
+        label="Assignments as TSV"
+      />
+    </>
+  );
+}
+
+const ExportDialogBody = styled(StyledDialogBody)`
+  .${Classes.FORM_GROUP} > div {
+    width: 100%;
+  }
+
+  padding: 20px;
+  display: flex;
+  flex-direction: column;
+  gap: 16px;
+`;
+
+const Description = styled.p`
+  margin: 4px 0 0;
+  font-size: 12px;
+  line-height: 1.5;
+`;
+
+interface AssignmentsExportModalContentProps {
+  action: ExportAction;
+  onClose: () => void;
+  onSubmit: (rowMode: AssignmentExportRowMode) => Promise<void>;
+}
+
+function AssignmentsExportModalContent(
+  props: AssignmentsExportModalContentProps,
+) {
+  const { action, onClose, onSubmit } = props;
+  const isCopy = action === 'copy';
+  const actionLabel = isCopy ? 'Copy' : 'Export';
+  const formatLabel = isCopy ? 'TSV' : 'CSV';
+  const form = useForm({
+    defaultValues: INITIAL_VALUES,
+    onSubmit: ({ value }) => onSubmit(value.rows),
+  });
+
+  return (
+    <StandardDialog
+      isOpen
+      title={`${actionLabel} assignment table as ${formatLabel}`}
+      icon={isCopy ? 'clipboard' : 'export'}
+      onClose={onClose}
+      style={{ width: 520 }}
+    >
+      <AppForm form={form}>
+        <ExportDialogBody>
+          <form.AppField name="rows">
+            {(field) => (
+              <field.RadioGroup
+                label={`${formatLabel} layout`}
+                style={{ display: 'grid', gap: 10 }}
+              >
+                {ROW_OPTIONS.map((option) => (
+                  <RadioCard
+                    key={option.value}
+                    value={option.value}
+                    alignIndicator="start"
+                  >
+                    <strong>{option.label}</strong>
+                    <Description className={Classes.TEXT_MUTED}>
+                      {option.description}
+                    </Description>
+                  </RadioCard>
+                ))}
+              </field.RadioGroup>
+            )}
+          </form.AppField>
+        </ExportDialogBody>
+        <DialogFooter
+          actions={
+            <>
+              <Button variant="outlined" onClick={onClose}>
+                Cancel
+              </Button>
+              <form.SubmitButton
+                intent="primary"
+                icon={isCopy ? <FaCopy /> : <FaDownload />}
+              >
+                {`${isCopy ? 'Copy' : 'Download'} ${formatLabel}`}
+              </form.SubmitButton>
+            </>
+          }
+        />
+      </AppForm>
+    </StandardDialog>
+  );
+}
diff --git a/src/component/panels/assignment-summary/MoleculeAssignmentTable.tsx b/src/component/panels/assignment-summary/MoleculeAssignmentTable.tsx
new file mode 100644
index 000000000..7cb258ba1
--- /dev/null
+++ b/src/component/panels/assignment-summary/MoleculeAssignmentTable.tsx
@@ -0,0 +1,175 @@
+import { Tag } from '@blueprintjs/core';
+import styled from '@emotion/styled';
+import type { GroupedDiaID } from 'openchemlib-utils';
+import { useMemo } from 'react';
+
+import { useChartData } from '../../context/ChartContext.js';
+import IsotopesViewer from '../../elements/IsotopesViewer.js';
+import {
+  TanStackTable,
+  createTanStackColumnHelper,
+} from '../../elements/tanstack_table/index.js';
+
+import { AssignmentAtomCell } from './table-cells/AssignmentAtomCell.js';
+import { AssignmentChemicalShiftCell } from './table-cells/AssignmentChemicalShiftCell.js';
+import { AssignmentLabelCell } from './table-cells/AssignmentLabelCell.js';
+import type { AssignmentListRow } from './utilities/atomGroupsToAssignmentRows.js';
+import {
+  atomGroupsToAssignmentRows,
+  getHydrogenIDsByParent,
+  getVisibleAssignmentRows,
+} from './utilities/atomGroupsToAssignmentRows.js';
+import { getAssignedAtomCounts } from './utilities/getAssignedAtomCounts.js';
+import { getSignalsByNucleus } from './utilities/getSignalsByNucleus.js';
+import type { SignalsByOclID } from './utilities/types.js';
+
+interface MoleculeAssignmentTableProps {
+  groups: GroupedDiaID[];
+  expandedGroups: ReadonlySet<string>;
+  onToggleRow: (id: string) => void;
+}
+
+const columnHelper = createTanStackColumnHelper<AssignmentListRow>();
+
+const SpectrumHeader = styled.div`
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  gap: 5px;
+  white-space: nowrap;
+`;
+
+interface SpectrumColumnHeaderProps {
+  nucleus: string;
+  groups: GroupedDiaID[];
+  signalsByOclID: SignalsByOclID;
+}
+
+function SpectrumColumnHeader({
+  nucleus,
+  groups,
+  signalsByOclID,
+}: SpectrumColumnHeaderProps) {
+  const counts = getAssignedAtomCounts(groups, signalsByOclID, nucleus);
+  const atomLabel = nucleus.replace(/^\d+/, '');
+  const tooltip = `${counts.assigned} of ${counts.total} ${atomLabel} atoms assigned.`;
+  // Green means every atom has an assignment link, not a verified assignment.
+  const isFullyAssigned = counts.total > 0 && counts.assigned === counts.total;
+  return (
+    <SpectrumHeader>
+      <IsotopesViewer value={nucleus} />
+      <Tag
+        minimal
+        intent={isFullyAssigned ? 'success' : 'danger'}
+        title={tooltip}
+      >
+        {counts.assigned}/{counts.total}
+      </Tag>
+    </SpectrumHeader>
+  );
+}
+
+export function MoleculeAssignmentTable(props: MoleculeAssignmentTableProps) {
+  const { groups, expandedGroups, onToggleRow } = props;
+  const { data } = useChartData();
+  // Build once per data change.
+  // headers and cells share the same nucleus lookup.
+  const signalsByNucleus = useMemo(() => getSignalsByNucleus(data), [data]);
+  // Keep the complete hierarchy for assignments.
+  // Expansion Only hides rows.
+  const allRows = useMemo(
+    () => atomGroupsToAssignmentRows(groups, true),
+    [groups],
+  );
+  const hydrogenIDsByParent = useMemo(
+    () => getHydrogenIDsByParent(allRows),
+    [allRows],
+  );
+  const rows = useMemo(
+    () => getVisibleAssignmentRows(allRows, expandedGroups),
+    [allRows, expandedGroups],
+  );
+  const columns = useMemo(() => {
+    return columnHelper.columns([
+      {
+        header: 'Atom',
+        accessorKey: 'atomLabel',
+        meta: { style: { width: '50px' } },
+        enableSorting: false,
+        cell: ({ row }) => (
+          <AssignmentAtomCell row={row.original} onToggle={onToggleRow} />
+        ),
+      },
+      {
+        header: 'Atom numbers',
+        accessorKey: 'atomNumbers',
+        enableSorting: false,
+        cell: ({ row }) => (
+          <AssignmentLabelCell
+            value={row.original.atomNumbers}
+            hydrogenValue={row.original.hydrogenAtomNumbers}
+            isExpanded={row.original.isExpanded}
+          />
+        ),
+      },
+      {
+        header: 'Atom labels',
+        accessorKey: 'atomLabels',
+        enableSorting: false,
+        cell: ({ row }) => (
+          <AssignmentLabelCell
+            value={row.original.atomLabels}
+            hydrogenValue={row.original.hydrogenAtomLabels}
+            isExpanded={row.original.isExpanded}
+          />
+        ),
+      },
+      // One column per nucleus, combining assignments from all of its spectra.
+      ...Array.from(signalsByNucleus).flatMap(([nucleus, signalsByOclID]) =>
+        columnHelper.columns([
+          {
+            header: () => (
+              <SpectrumColumnHeader
+                nucleus={nucleus}
+                groups={groups}
+                signalsByOclID={signalsByOclID}
+              />
+            ),
+            id: nucleus,
+            enableSorting: false,
+            cell: ({ row }) => (
+              <AssignmentChemicalShiftCell
+                options={{
+                  row: row.original,
+                  hydrogenIDsByParent,
+                  signalsByOclID,
+                }}
+              />
+            ),
+          },
+        ]),
+      ),
+    ]);
+  }, [groups, onToggleRow, signalsByNucleus, hydrogenIDsByParent]);
+
+  function getHighlightIDs(row: AssignmentListRow): string[] {
+    return [row.id, ...(hydrogenIDsByParent.get(row.id) ?? [])];
+  }
+
+  return (
+    <TanStackTable
+      data={rows}
+      columns={columns}
+      getHighlightIDs={getHighlightIDs}
+      highlightedSource="ASSIGNMENT_TABLE"
+      style={{ height: '100%' }}
+      rowStyle={({ original }) => ({
+        base: {
+          backgroundColor:
+            !original.isHydrogen && original.isExpanded ? '#f2f2f2' : 'white',
+        },
+      })}
+      emptyDataRowText="No atom groups to display"
+    />
+  );
+}
diff --git a/src/component/panels/assignment-summary/table-cells/AssignmentAtomCell.tsx b/src/component/panels/assignment-summary/table-cells/AssignmentAtomCell.tsx
new file mode 100644
index 000000000..5fab00d0e
--- /dev/null
+++ b/src/component/panels/assignment-summary/table-cells/AssignmentAtomCell.tsx
@@ -0,0 +1,36 @@
+import { Button } from '@blueprintjs/core';
+import styled from '@emotion/styled';
+
+import type { AssignmentListRow } from '../utilities/atomGroupsToAssignmentRows.js';
+
+interface AssignmentAtomCellProps {
+  row: AssignmentListRow;
+  onToggle: (id: string) => void;
+}
+
+const AtomCellContainer = styled.span`
+  display: flex;
+  align-items: center;
+`;
+
+export function AssignmentAtomCell({ row, onToggle }: AssignmentAtomCellProps) {
+  return (
+    <AtomCellContainer>
+      <Button
+        variant="minimal"
+        size="small"
+        icon={row.isExpanded ? 'chevron-down' : 'chevron-right'}
+        style={{
+          visibility: row.hasChildren ? 'visible' : 'hidden',
+        }}
+        onClick={(event) => {
+          event.stopPropagation();
+          onToggle(row.id);
+        }}
+      />
+      <span style={{ paddingInlineStart: row.isHydrogen ? '0.5em' : 0 }}>
+        {row.atomLabel}
+      </span>
+    </AtomCellContainer>
+  );
+}
diff --git a/src/component/panels/assignment-summary/table-cells/AssignmentChemicalShiftCell.tsx b/src/component/panels/assignment-summary/table-cells/AssignmentChemicalShiftCell.tsx
new file mode 100644
index 000000000..6c391d3a3
--- /dev/null
+++ b/src/component/panels/assignment-summary/table-cells/AssignmentChemicalShiftCell.tsx
@@ -0,0 +1,57 @@
+import { Fragment } from 'react';
+
+import { useACSSettings } from '../../../hooks/use_acs_settings.js';
+import { formatAssignmentACS } from '../utilities/formatAssignmentACS.js';
+import { formatAssignmentShifts } from '../utilities/formatAssignmentShifts.js';
+import { getAssignmentSignals } from '../utilities/getAssignmentSignals.js';
+import type {
+  AssignmentSignals,
+  GetAssignmentSignalsOptions,
+} from '../utilities/types.js';
+
+interface AssignmentShiftLineProps {
+  assignment: AssignmentSignals;
+  shiftsOnly: boolean;
+}
+
+function AssignmentShift(options: AssignmentShiftLineProps) {
+  const { assignment, shiftsOnly } = options;
+  const { spectrum } = assignment;
+  const acs = useACSSettings(spectrum.info.nucleus);
+  const value = shiftsOnly
+    ? formatAssignmentShifts({ assignment, deltaFormat: acs.deltaFormat })
+    : formatAssignmentACS({ assignment, acs });
+
+  return (
+    <span>
+      {shiftsOnly ? (
+        <span>{value} ppm</span>
+      ) : (
+        // eslint-disable-next-line @eslint-react/dom-no-dangerously-set-innerhtml
+        <span dangerouslySetInnerHTML={{ __html: value }} />
+      )}
+    </span>
+  );
+}
+
+interface AssignmentChemicalShiftCellProps {
+  options: GetAssignmentSignalsOptions;
+}
+
+export function AssignmentChemicalShiftCell(
+  props: AssignmentChemicalShiftCellProps,
+) {
+  const { options } = props;
+  const assignments = getAssignmentSignals(options);
+
+  // Separate spectra's values with commas while retaining per-spectrum formatting.
+  return assignments.map((assignment, index) => (
+    <Fragment key={assignment.spectrum.id}>
+      {index > 0 && ', '}
+      <AssignmentShift
+        assignment={assignment}
+        shiftsOnly={options.row.isHydrogen}
+      />
+    </Fragment>
+  ));
+}
diff --git a/src/component/panels/assignment-summary/table-cells/AssignmentLabelCell.tsx b/src/component/panels/assignment-summary/table-cells/AssignmentLabelCell.tsx
new file mode 100644
index 000000000..30c80aa9c
--- /dev/null
+++ b/src/component/panels/assignment-summary/table-cells/AssignmentLabelCell.tsx
@@ -0,0 +1,16 @@
+interface AssignmentLabelCellProps {
+  value: string;
+  hydrogenValue: string;
+  isExpanded: boolean;
+}
+
+export function AssignmentLabelCell(props: AssignmentLabelCellProps) {
+  return formatAssignmentLabel(props);
+}
+
+export function formatAssignmentLabel(options: AssignmentLabelCellProps) {
+  const { value, hydrogenValue, isExpanded } = options;
+  if (isExpanded || !hydrogenValue) return value;
+
+  return value ? `${value} (${hydrogenValue})` : `(${hydrogenValue})`;
+}
diff --git a/src/component/panels/assignment-summary/utilities/atomGroupsToAssignmentRows.ts b/src/component/panels/assignment-summary/utilities/atomGroupsToAssignmentRows.ts
new file mode 100644
index 000000000..4ce80b374
--- /dev/null
+++ b/src/component/panels/assignment-summary/utilities/atomGroupsToAssignmentRows.ts
@@ -0,0 +1,254 @@
+import type { GroupedDiaID } from 'openchemlib-utils';
+
+import { sortAssignmentLabels } from '../../MoleculesPanel/utilities/sortAssignmentLabels.js';
+
+/**
+ * Controls which atoms show their attached hydrogens in the table.
+ * - `true`: show hydrogens beneath every atom group.
+ * - `false`: hide all hydrogen rows.
+ * - A set of group IDs: show hydrogens only beneath the selected groups.
+ * Hydrogens without a matching parent remain visible unless this is `false`.
+ */
+export type AssignmentExpansion = boolean | ReadonlySet<string>;
+
+export interface AssignmentListRow {
+  /**
+   * The atom group's oclID, used to look up signal assignments.
+   */
+  id: string;
+  parentOclId?: string;
+  atomLabel: string;
+  atomNumbers: string;
+  atomLabels: string;
+  hydrogenAtomNumbers: string;
+  hydrogenAtomLabels: string;
+  isHydrogen: boolean;
+  hasChildren: boolean;
+  isExpanded: boolean;
+}
+
+interface AssignmentRowOptions {
+  /**
+   * ID of the atom group this hydrogen row appears beneath.
+   */
+  parentOclId?: string;
+  hasChildren?: boolean;
+  isExpanded?: boolean;
+}
+
+/**
+ * Select visible rows from the complete hierarchy and update expansion flags.
+ * Rows with no parent or whose parent is expanded remain visible.
+ */
+export function getVisibleAssignmentRows(
+  allRows: readonly AssignmentListRow[],
+  expandedGroups: ReadonlySet<string>,
+): AssignmentListRow[] {
+  const rows: AssignmentListRow[] = [];
+  for (const row of allRows) {
+    if (row.parentOclId !== undefined && !expandedGroups.has(row.parentOclId)) {
+      continue;
+    }
+    rows.push(
+      row.hasChildren
+        ? { ...row, isExpanded: expandedGroups.has(row.id) }
+        : row,
+    );
+  }
+  return rows;
+}
+
+export function getHydrogenIDsByParent(
+  rows: readonly AssignmentListRow[],
+): ReadonlyMap<string, readonly string[]> {
+  const hydrogenIDsByParent = new Map<string, string[]>();
+  for (const row of rows) {
+    if (row.parentOclId === undefined) continue;
+    const hydrogenIDs = hydrogenIDsByParent.get(row.parentOclId);
+    if (hydrogenIDs) {
+      hydrogenIDs.push(row.id);
+    } else {
+      hydrogenIDsByParent.set(row.parentOclId, [row.id]);
+    }
+  }
+  return hydrogenIDsByParent;
+}
+
+interface HydrogenPartition {
+  /**
+   * The attached hydrogen groups to display beneath each atom group.
+   */
+  hydrogensByParentOclId: Map<string, GroupedDiaID[]>;
+  /**
+   * Hydrogen groups that could not be matched to an atom group.
+   */
+  unattachedHydrogens: GroupedDiaID[];
+}
+
+function isHydrogenGroup(group: GroupedDiaID): boolean {
+  return group.atomLabel === 'H';
+}
+
+function compareByFirstAtomIndex(a: GroupedDiaID, b: GroupedDiaID): number {
+  // Keep groups in molecule order using the first atom number in each group.
+  return a.atoms[0] - b.atoms[0];
+}
+
+function compareNumbers(a: number, b: number): number {
+  return a - b;
+}
+
+function isGroupExpanded(
+  expansion: AssignmentExpansion,
+  parentOclId: string,
+): boolean {
+  return typeof expansion === 'boolean'
+    ? expansion
+    : expansion.has(parentOclId);
+}
+
+function toAssignmentRow(
+  group: GroupedDiaID,
+  options: AssignmentRowOptions = {},
+): AssignmentListRow {
+  const { parentOclId, hasChildren = false, isExpanded = false } = options;
+
+  return {
+    id: group.oclID,
+    parentOclId,
+    atomLabel: group.atomLabel,
+    atomNumbers: group.atoms.toSorted(compareNumbers).join(','),
+    atomLabels: sortAssignmentLabels(group.customLabels).join(','),
+    // The molecule already provides attached H values; keep them separate from the parent's.
+    hydrogenAtomNumbers: group.attachedHydrogens
+      .toSorted(compareNumbers)
+      .join(','),
+    hydrogenAtomLabels: sortAssignmentLabels(
+      group.attachedHydrogensCustomLabels,
+    ).join(','),
+    isHydrogen: isHydrogenGroup(group),
+    hasChildren,
+    isExpanded,
+  };
+}
+
+/**
+ * Find which atom group each hydrogen group belongs beneath.
+ * A "heavy atom" means any atom other than hydrogen.
+ *
+ * Use the molecule's atom numbers to find attachments.
+ * First record the group containing each heavy atom, then use that record to place the hydrogens without repeated searches.
+ * Each heavy atom is expected to belong to only one group.
+ */
+function partitionHydrogenGroups(
+  heavyAtomGroups: readonly GroupedDiaID[],
+  hydrogenGroups: readonly GroupedDiaID[],
+): HydrogenPartition {
+  const heavyGroupByAtomIndex = new Map<number, GroupedDiaID>();
+  for (const heavyGroup of heavyAtomGroups) {
+    for (const atomIndex of heavyGroup.atoms) {
+      heavyGroupByAtomIndex.set(atomIndex, heavyGroup);
+    }
+  }
+
+  const hydrogensByParentOclId = new Map<string, GroupedDiaID[]>();
+  const unattachedHydrogens: GroupedDiaID[] = [];
+
+  for (const hydrogenGroup of hydrogenGroups) {
+    // Several attached atoms may share one group; show its hydrogen row only once.
+    const parentGroups = new Set<GroupedDiaID>();
+    for (const heavyAtomIndex of hydrogenGroup.heavyAtoms) {
+      const parentGroup = heavyGroupByAtomIndex.get(heavyAtomIndex);
+      if (parentGroup) parentGroups.add(parentGroup);
+    }
+
+    if (parentGroups.size === 0) {
+      unattachedHydrogens.push(hydrogenGroup);
+      continue;
+    }
+
+    for (const parentGroup of parentGroups) {
+      const siblings = hydrogensByParentOclId.get(parentGroup.oclID);
+      if (siblings) {
+        siblings.push(hydrogenGroup);
+      } else {
+        hydrogensByParentOclId.set(parentGroup.oclID, [hydrogenGroup]);
+      }
+    }
+  }
+
+  return { hydrogensByParentOclId, unattachedHydrogens };
+}
+
+/**
+ * Prepare the rows shown in the assignment list.
+ *
+ * Input comes from `TopicMolecule.getGroupedDiastereotopicAtomIDs()`.
+ * Each group describes equivalent atoms that belong in the same table row:
+ * - `oclID`: the group's identifier.
+ * - `atomLabel`: the element symbol, such as C or H.
+ * - `atoms`: the atom numbers in this group, starting at zero.
+ * - `customLabels`: custom names assigned to these atoms, such as "3a".
+ * - `heavyAtoms`: for hydrogens, the numbers of the atoms they are attached to.
+ *
+ * The table lists each heavy-atom group, followed by its hydrogen groups when
+ * expanded. Parents retain their attached hydrogen values for collapsed cells.
+ * for example:
+ *   Input: carbon c1 contains atom 0, carbon c2 contains atom 1, and hydrogen group h1 contains atoms 2, 3, 4 attached to atom 0.
+ *   atomGroupsToAssignmentRows(groups, new Set(['c1']));
+ *  Output table:
+ *  Atom | Atom numbers
+ *  C    | 0
+ *    H  | 2,3,4
+ *  C    | 1
+ */
+export function atomGroupsToAssignmentRows(
+  groups: readonly GroupedDiaID[],
+  expansion: AssignmentExpansion,
+): AssignmentListRow[] {
+  // 1. Put groups in molecule order and separate hydrogens from other atoms.
+  const sortedGroups = groups.toSorted(compareByFirstAtomIndex);
+  const heavyAtomGroups = sortedGroups.filter(
+    (group) => !isHydrogenGroup(group),
+  );
+  const hydrogenGroups = sortedGroups.filter(isHydrogenGroup);
+
+  // 2. Find the parent groups for the hydrogens.
+  const { hydrogensByParentOclId, unattachedHydrogens } =
+    partitionHydrogenGroups(heavyAtomGroups, hydrogenGroups);
+
+  const rows: AssignmentListRow[] = [];
+
+  // 3. Add each parent, followed by its hydrogens if the row is expanded.
+  for (const parentGroup of heavyAtomGroups) {
+    const childHydrogens = hydrogensByParentOclId.get(parentGroup.oclID) ?? [];
+    const hasChildren = childHydrogens.length > 0;
+    const isExpanded =
+      hasChildren && isGroupExpanded(expansion, parentGroup.oclID);
+
+    rows.push(
+      toAssignmentRow(parentGroup, {
+        hasChildren,
+        isExpanded,
+      }),
+    );
+
+    if (isExpanded) {
+      for (const hydrogenGroup of childHydrogens) {
+        rows.push(
+          toAssignmentRow(hydrogenGroup, { parentOclId: parentGroup.oclID }),
+        );
+      }
+    }
+  }
+
+  // Currently this case is not exits but it is a fallback for any unattached hydrogens.
+  // 4. Keep unmatched hydrogens at the end so they are not lost from the list.
+  if (expansion !== false) {
+    for (const hydrogenGroup of unattachedHydrogens) {
+      rows.push(toAssignmentRow(hydrogenGroup));
+    }
+  }
+
+  return rows;
+}
diff --git a/src/component/panels/assignment-summary/utilities/exportAssignments.ts b/src/component/panels/assignment-summary/utilities/exportAssignments.ts
new file mode 100644
index 000000000..a0c70bf2c
--- /dev/null
+++ b/src/component/panels/assignment-summary/utilities/exportAssignments.ts
@@ -0,0 +1,112 @@
+import type { ACSExportOptions, Spectrum } from '@zakodium/nmrium-core';
+import type { GroupedDiaID } from 'openchemlib-utils';
+import papa from 'papaparse';
+
+import { formatAssignmentLabel } from '../table-cells/AssignmentLabelCell.js';
+
+import {
+  atomGroupsToAssignmentRows,
+  getHydrogenIDsByParent,
+  getVisibleAssignmentRows,
+} from './atomGroupsToAssignmentRows.js';
+import { formatAssignmentACS } from './formatAssignmentACS.js';
+import { formatAssignmentShifts } from './formatAssignmentShifts.js';
+import { getAssignmentSignals } from './getAssignmentSignals.js';
+import { getSignalsByNucleus } from './getSignalsByNucleus.js';
+import type { GetAssignmentSignalsOptions } from './types.js';
+
+export type AssignmentExportRowMode = 'current' | 'expanded' | 'collapsed';
+
+interface ExportAssignmentsOptions {
+  groups: readonly GroupedDiaID[];
+  spectra: Spectrum[];
+  expandedGroups: ReadonlySet<string>;
+  rowMode: AssignmentExportRowMode;
+  acsExportSettings: Record<string, ACSExportOptions>;
+  defaultACSOptions: ACSExportOptions;
+  delimiter: ',' | '\t';
+}
+
+/**
+ * Export the selected molecule as CSV or TSV using the table's formatting rules.
+ */
+export function exportAssignments(options: ExportAssignmentsOptions): string {
+  const {
+    groups,
+    spectra,
+    expandedGroups,
+    rowMode,
+    acsExportSettings,
+    defaultACSOptions,
+    delimiter,
+  } = options;
+  const allRows = atomGroupsToAssignmentRows(groups, true);
+  const rows =
+    rowMode === 'expanded'
+      ? allRows
+      : getVisibleAssignmentRows(
+          allRows,
+          rowMode === 'current' ? expandedGroups : new Set<string>(),
+        );
+  const hydrogenIDsByParent = getHydrogenIDsByParent(allRows);
+  const nuclei = Array.from(
+    getSignalsByNucleus(spectra),
+    ([nucleus, signals]) => ({
+      nucleus,
+      signalsByOclID: signals,
+      acs: acsExportSettings[nucleus] ?? defaultACSOptions,
+    }),
+  );
+
+  const fields = [
+    'Atom',
+    'Atom numbers',
+    'Atom labels',
+    ...nuclei.map(({ nucleus }) => nucleus),
+  ];
+  const data = rows.map((row) => [
+    row.atomLabel,
+    formatAssignmentLabel({
+      value: row.atomNumbers,
+      hydrogenValue: row.hydrogenAtomNumbers,
+      isExpanded: row.isExpanded,
+    }),
+    formatAssignmentLabel({
+      value: row.atomLabels,
+      hydrogenValue: row.hydrogenAtomLabels,
+      isExpanded: row.isExpanded,
+    }),
+    ...nuclei.map(({ signalsByOclID, acs }) =>
+      formatAssignmentCell({
+        row,
+        signalsByOclID,
+        hydrogenIDsByParent,
+        acs,
+      }),
+    ),
+  ]);
+
+  return papa.unparse({ fields, data }, { delimiter, escapeFormulae: true });
+}
+
+interface FormatAssignmentCellOptions extends GetAssignmentSignalsOptions {
+  acs: ACSExportOptions;
+}
+
+function formatAssignmentCell(options: FormatAssignmentCellOptions): string {
+  const { row, acs } = options;
+
+  return getAssignmentSignals(options)
+    .map((assignment) => {
+      if (row.isHydrogen) {
+        return `${formatAssignmentShifts({ assignment, deltaFormat: acs.deltaFormat })} ppm`;
+      }
+      // The ACS formatter emits <i>J</i> for couplings
+      // Strip HTML tags so spreadsheet cells contain plain text.
+      return formatAssignmentACS({ assignment, acs }).replaceAll(
+        /<[^>]+>/g,
+        '',
+      );
+    })
+    .join(', ');
+}
diff --git a/src/component/panels/assignment-summary/utilities/formatAssignmentACS.ts b/src/component/panels/assignment-summary/utilities/formatAssignmentACS.ts
new file mode 100644
index 000000000..d7605a429
--- /dev/null
+++ b/src/component/panels/assignment-summary/utilities/formatAssignmentACS.ts
@@ -0,0 +1,55 @@
+import type { Range, Signal1D } from '@zakodium/nmr-types';
+import type { ACSExportOptions } from '@zakodium/nmrium-core';
+import { rangesToACS } from 'nmr-processing';
+
+import { getRangesToACSOptions } from '../../../hooks/use_publication_strings.js';
+
+import type { AssignedSignal, FormatAssignmentOptions } from './types.js';
+
+const assignmentACSOptions: Partial<ACSExportOptions> = {
+  signalKind: 'signal',
+  ascending: true,
+  format: 'IMJ',
+  textStyle: {},
+};
+
+/**
+ * Format one spectrum's assignments as ACS HTML without the spectrum header,
+ * delta prefix, or final period.
+ */
+export function formatAssignmentACS(options: FormatAssignmentOptions): string {
+  const { assignment } = options;
+  const { spectrum, entries } = assignment;
+  const acs = {
+    ...options.acs,
+    ...assignmentACSOptions,
+    ...(spectrum.info.nucleus === '13C' && { format: 'D' }),
+  };
+
+  const acsString = rangesToACS(getAssignedRanges(entries), {
+    ...getRangesToACSOptions(spectrum.info, acs),
+    filter: false,
+  });
+
+  // "1H NMR (600 MHz): δ 4.04 (d)." becomes "4.04 (d)".
+  return acsString.replaceAll(/^(?:[^:]*:\s*)?\u{03B4}\s*|\.$/gu, '');
+}
+
+/**
+ * Rebuild the selected ranges with only the collected signals.
+ */
+function getAssignedRanges(entries: AssignedSignal[]): Range[] {
+  const signalsByRange = new Map<Range, Signal1D[]>();
+  for (const { range, signal } of entries) {
+    const signals = signalsByRange.get(range);
+    if (signals) {
+      signals.push(signal);
+    } else {
+      signalsByRange.set(range, [signal]);
+    }
+  }
+  return Array.from(signalsByRange, ([range, signals]) => ({
+    ...range,
+    signals,
+  }));
+}
diff --git a/src/component/panels/assignment-summary/utilities/formatAssignmentShifts.ts b/src/component/panels/assignment-summary/utilities/formatAssignmentShifts.ts
new file mode 100644
index 000000000..60b5f18cb
--- /dev/null
+++ b/src/component/panels/assignment-summary/utilities/formatAssignmentShifts.ts
@@ -0,0 +1,25 @@
+import { formatNumber } from '../../../utility/formatNumber.js';
+
+import type { AssignmentSignals } from './types.js';
+
+interface FormatAssignmentShiftsOptions {
+  assignment: AssignmentSignals;
+  deltaFormat: string;
+}
+
+/**
+ * Sort and format signal deltas without adding spectrum details or units.
+ * @returns Shift values joined with ', '
+ */
+export function formatAssignmentShifts(
+  options: FormatAssignmentShiftsOptions,
+): string {
+  const { assignment, deltaFormat } = options;
+  const { entries } = assignment;
+
+  return entries
+    .map(({ signal }) => signal.delta)
+    .toSorted((a, b) => a - b)
+    .map((delta) => formatNumber(delta, deltaFormat))
+    .join(', ');
+}
diff --git a/src/component/panels/assignment-summary/utilities/getAssignedAtomCounts.ts b/src/component/panels/assignment-summary/utilities/getAssignedAtomCounts.ts
new file mode 100644
index 000000000..14d51811a
--- /dev/null
+++ b/src/component/panels/assignment-summary/utilities/getAssignedAtomCounts.ts
@@ -0,0 +1,32 @@
+import type { GroupedDiaID } from 'openchemlib-utils';
+
+import type { AssignedAtomCounts, SignalsByOclID } from './types.js';
+
+/**
+ * Count atoms of the nucleus's element in the selected molecule.
+ * The lookup must belong to that nucleus. Counts measure assignment coverage,
+ * not the number of signals or whether the assignments have been verified.
+ */
+export function getAssignedAtomCounts(
+  groups: GroupedDiaID[],
+  signalsByOclID: SignalsByOclID,
+  nucleus: string,
+): AssignedAtomCounts {
+  let assigned = 0;
+  let total = 0;
+  const atomLabel = nucleus.replace(/^\d+/, '');
+
+  for (const group of groups) {
+    if (group.atomLabel !== atomLabel) continue;
+
+    // Count individual equivalent atoms (for example, 3 H in a methyl group),
+    // not one atom per group. The total is independent of observed signals.
+    total += group.atoms.length;
+    // A group counts once if assigned in any spectrum of this nucleus.
+    if (signalsByOclID.has(group.oclID)) {
+      assigned += group.atoms.length;
+    }
+  }
+
+  return { assigned, total };
+}
diff --git a/src/component/panels/assignment-summary/utilities/getAssignmentSignals.ts b/src/component/panels/assignment-summary/utilities/getAssignmentSignals.ts
new file mode 100644
index 000000000..b08bb8020
--- /dev/null
+++ b/src/component/panels/assignment-summary/utilities/getAssignmentSignals.ts
@@ -0,0 +1,50 @@
+import type {
+  AssignedSignal,
+  AssignmentSignals,
+  AssignmentSpectrum,
+  GetAssignmentSignalsOptions,
+} from './types.js';
+
+/**
+ * Collect a row's signals and those of its attached hydrogen groups.
+ *
+ * @param options - The row (`row.id` is its OCL ID), nucleus-specific signal
+ * lookup, precomputed parent-to-hydrogen lookup, and optional spectrum ID.
+ * @returns One group per matching spectrum, with duplicate entries removed when
+ * the same signal matches several OCL IDs.
+ */
+export function getAssignmentSignals(
+  options: GetAssignmentSignalsOptions,
+): AssignmentSignals[] {
+  const { row, signalsByOclID, hydrogenIDsByParent, spectrumId } = options;
+  // Include attached H assignments on the parent row even when H rows are hidden.
+  const oclIDs = [row.id, ...(hydrogenIDsByParent.get(row.id) ?? [])];
+  const signalsBySpectrum = new Map<
+    string,
+    { spectrum: AssignmentSpectrum; signals: Set<AssignedSignal> }
+  >();
+
+  for (const oclID of oclIDs) {
+    for (const entry of signalsByOclID.get(oclID) ?? []) {
+      if (spectrumId !== undefined && entry.spectrum.id !== spectrumId) {
+        continue;
+      }
+      let group = signalsBySpectrum.get(entry.spectrum.id);
+
+      if (!group) {
+        group = { spectrum: entry.spectrum, signals: new Set() };
+        signalsBySpectrum.set(entry.spectrum.id, group);
+      }
+      // A signal linked to several of this row's groups should appear only once.
+      group.signals.add(entry);
+    }
+  }
+
+  return Array.from(signalsBySpectrum.values(), (group) => {
+    const entries = Array.from(group.signals);
+    return {
+      spectrum: group.spectrum,
+      entries,
+    };
+  });
+}
diff --git a/src/component/panels/assignment-summary/utilities/getSignalsByNucleus.ts b/src/component/panels/assignment-summary/utilities/getSignalsByNucleus.ts
new file mode 100644
index 000000000..3254980b9
--- /dev/null
+++ b/src/component/panels/assignment-summary/utilities/getSignalsByNucleus.ts
@@ -0,0 +1,60 @@
+import type { Spectrum } from '@zakodium/nmrium-core';
+import { isSpectrum1D } from '@zakodium/nmrium-core';
+
+import type {
+  AssignedSignal,
+  AssignmentSpectrum,
+  SignalsByNucleus,
+} from './types.js';
+
+/**
+ * Build a nucleus to oclIDs lookup of assigned 1D signals.
+ *
+ * @returns A map containing an OCL ID lookup for each 1D nucleus, including
+ * nuclei without assignments so their columns remain visible.
+ * Only the spectrum ID, nucleus, and frequency are retained in a shared metadata
+ * object.
+ *
+ * Notes:
+ * 1. Unassigned signals are omitted.
+ * 2. Repeated IDs within a signal occur once.
+ */
+export function getSignalsByNucleus(spectra: Spectrum[]): SignalsByNucleus {
+  const signalsByNucleus = new Map<string, Map<string, AssignedSignal[]>>();
+  for (const spectrum of spectra) {
+    if (!isSpectrum1D(spectrum)) continue;
+
+    // Share one atom-group lookup across all 1D spectra of the same nucleus.
+    // Create it even without assignments so the nucleus column stays visible.
+    const nucleus = spectrum.info.nucleus;
+    let signalsByOclID = signalsByNucleus.get(nucleus);
+
+    if (!signalsByOclID) {
+      signalsByOclID = new Map();
+      signalsByNucleus.set(nucleus, signalsByOclID);
+    }
+    // Keep each spectrum's frequency for formatting its own coupling values.
+    const assignmentSpectrum: AssignmentSpectrum = {
+      id: spectrum.id,
+      info: {
+        nucleus: spectrum.info.nucleus,
+        originFrequency: spectrum.info.originFrequency,
+      },
+    };
+    for (const range of spectrum.ranges.values) {
+      for (const signal of range.signals) {
+        const entry = { spectrum: assignmentSpectrum, range, signal };
+        // Index a signal under every linked group, without repeating a link.
+        for (const oclID of new Set(signal.diaIDs)) {
+          const entries = signalsByOclID.get(oclID);
+          if (entries) {
+            entries.push(entry);
+          } else {
+            signalsByOclID.set(oclID, [entry]);
+          }
+        }
+      }
+    }
+  }
+  return signalsByNucleus;
+}
diff --git a/src/component/panels/assignment-summary/utilities/types.ts b/src/component/panels/assignment-summary/utilities/types.ts
new file mode 100644
index 000000000..df733758d
--- /dev/null
+++ b/src/component/panels/assignment-summary/utilities/types.ts
@@ -0,0 +1,46 @@
+import type { Range, Signal1D } from '@zakodium/nmr-types';
+import type { ACSExportOptions, Spectrum1D } from '@zakodium/nmrium-core';
+
+import type { AssignmentListRow } from './atomGroupsToAssignmentRows.js';
+
+export interface AssignmentSpectrum {
+  id: string;
+  info: Pick<Spectrum1D['info'], 'nucleus' | 'originFrequency'>;
+}
+
+export interface AssignedSignal {
+  spectrum: AssignmentSpectrum;
+  range: Range;
+  signal: Signal1D;
+}
+
+export type SignalsByOclID = ReadonlyMap<string, readonly AssignedSignal[]>;
+
+/**
+ * Index signals by nucleus, then OCL ID, so each column can directly look up
+ * assignments across all spectra of its nucleus without filtering other nuclei.
+ * Entries retain spectrum metadata because ACS formatting needs its frequency.
+ */
+export type SignalsByNucleus = ReadonlyMap<string, SignalsByOclID>;
+
+export interface AssignedAtomCounts {
+  assigned: number;
+  total: number;
+}
+
+export interface AssignmentSignals {
+  spectrum: AssignmentSpectrum;
+  entries: AssignedSignal[];
+}
+
+export interface GetAssignmentSignalsOptions {
+  row: AssignmentListRow;
+  signalsByOclID: SignalsByOclID;
+  hydrogenIDsByParent: ReadonlyMap<string, readonly string[]>;
+  spectrumId?: string;
+}
+
+export interface FormatAssignmentOptions {
+  assignment: AssignmentSignals;
+  acs: ACSExportOptions;
+}