data: isOriginalRelease -> isMainRelease, etc

Also isRerelease -> isSecondaryRelease

Im sure this is completely bug free and will not
involve squashing one million additional commits

21 files changed, 183 insertions, 187 deletions

diff --git a/src/common-util/search-spec.js b/src/common-util/search-spec.js
index 3d05c021..75de0d16 100644
--- a/src/common-util/search-spec.js
+++ b/src/common-util/search-spec.js
@@ -109,7 +109,7 @@ export const searchSpec = {
       trackData
         // Exclude rereleases - there's no reasonable way to differentiate
         // them from the main release as part of this query.
-        .filter(track => !track.originalReleaseTrack),
+        .filter(track => !track.mainReleaseTrack),
     ].flat(),
 
     process(thing, opts) {
diff --git a/src/common-util/wiki-data.js b/src/common-util/wiki-data.js
index e012759d..24212e90 100644
--- a/src/common-util/wiki-data.js
+++ b/src/common-util/wiki-data.js
@@ -167,10 +167,10 @@ export function getFlashLink(flash) {
 }
 
 export function getTotalDuration(tracks, {
-  originalReleasesOnly = false,
+  mainReleasesOnly = false,
 } = {}) {
-  if (originalReleasesOnly) {
-    tracks = tracks.filter(t => !t.originalReleaseTrack);
+  if (mainReleasesOnly) {
+    tracks = tracks.filter(t => !t.mainReleaseTrack);
   }
 
   return accumulateSum(tracks, track => track.duration);
diff --git a/src/content/dependencies/generateArtistGroupContributionsInfo.js b/src/content/dependencies/generateArtistGroupContributionsInfo.js
index f84d00de..3e0cd1d2 100644
--- a/src/content/dependencies/generateArtistGroupContributionsInfo.js
+++ b/src/content/dependencies/generateArtistGroupContributionsInfo.js
@@ -36,7 +36,7 @@ export default {
     for (const track of filteredTracks) {
       for (const group of track.album.groups) {
         groupToCountMap.set(group, groupToCountMap.get(group) + 1);
-        if (track.duration && track.originalReleaseTrack === null) {
+        if (track.duration && track.mainReleaseTrack === null) {
           groupToDurationMap.set(group, groupToDurationMap.get(group) + track.duration);
           groupToDurationCountMap.set(group, groupToDurationCountMap.get(group) + 1);
         }
diff --git a/src/content/dependencies/generateArtistInfoPageTracksChunk.js b/src/content/dependencies/generateArtistInfoPageTracksChunk.js
index b42e4165..f6d70901 100644
--- a/src/content/dependencies/generateArtistInfoPageTracksChunk.js
+++ b/src/content/dependencies/generateArtistInfoPageTracksChunk.js
@@ -40,7 +40,7 @@ export default {
         contribs
           .filter(contrib => contrib.countInDurationTotals)
           .map(contrib => contrib.thing)
-          .filter(track => track.isOriginalRelease)
+          .filter(track => track.isMainRelease)
           .filter(track => track.duration > 0));
 
     data.duration =
diff --git a/src/content/dependencies/generateArtistInfoPageTracksChunkItem.js b/src/content/dependencies/generateArtistInfoPageTracksChunkItem.js
index 96976826..ba3005e2 100644
--- a/src/content/dependencies/generateArtistInfoPageTracksChunkItem.js
+++ b/src/content/dependencies/generateArtistInfoPageTracksChunkItem.js
@@ -80,7 +80,7 @@ export default {
       query.track.duration,
 
     rerelease:
-      query.track.isRerelease,
+      query.track.isSecondaryRelease,
 
     contribAnnotations:
       (query.displayedContributions
diff --git a/src/content/dependencies/generateGroupGalleryPage.js b/src/content/dependencies/generateGroupGalleryPage.js
index 79746cd0..206c495d 100644
--- a/src/content/dependencies/generateGroupGalleryPage.js
+++ b/src/content/dependencies/generateGroupGalleryPage.js
@@ -86,7 +86,7 @@ export default {
 
     data.numAlbums = albums.length;
     data.numTracks = tracks.length;
-    data.totalDuration = getTotalDuration(tracks, {originalReleasesOnly: true});
+    data.totalDuration = getTotalDuration(tracks, {mainReleasesOnly: true});
 
     data.gridNames = albums.map(album => album.name);
     data.gridDurations = albums.map(album => getTotalDuration(album.tracks));
diff --git a/src/content/dependencies/generateTrackArtistCommentarySection.js b/src/content/dependencies/generateTrackArtistCommentarySection.js
index 399c804a..63c4e93d 100644
--- a/src/content/dependencies/generateTrackArtistCommentarySection.js
+++ b/src/content/dependencies/generateTrackArtistCommentarySection.js
@@ -13,7 +13,7 @@ export default {
   query: (track) => ({
     otherRereleasesWithCommentary:
       track.otherReleases
-        .filter(track => !track.isOriginalRelease)
+        .filter(track => !track.isMainRelease)
         .filter(track => !empty(track.commentary)),
   }),
 
@@ -21,14 +21,14 @@ export default {
     contentHeading:
       relation('generateContentHeading'),
 
-    originalReleaseTrackLink:
-      (track.isRerelease
-        ? relation('linkTrack', track.originalReleaseTrack)
+    mainReleaseTrackLink:
+      (track.isSecondaryRelease
+        ? relation('linkTrack', track.mainReleaseTrack)
         : null),
 
-    originalReleaseArtistCommentaryEntries:
-      (track.isRerelease
-        ? track.originalReleaseTrack.commentary
+    mainReleaseArtistCommentaryEntries:
+      (track.isSecondaryRelease
+        ? track.mainReleaseTrack.commentary
             .map(entry => relation('generateCommentaryEntry', entry))
         : null),
 
@@ -48,22 +48,22 @@ export default {
     name:
       track.name,
 
-    isRerelease:
-      track.isRerelease,
+    isSecondaryRelease:
+      track.isSecondaryRelease,
 
-    originalReleaseName:
-      (track.isRerelease
-        ? track.originalReleaseTrack.name
+    mainReleaseName:
+      (track.isSecondaryRelease
+        ? track.mainReleaseTrack.name
         : null),
 
-    originalReleaseAlbumName:
-      (track.isRerelease
-        ? track.originalReleaseTrack.album.name
+    mainReleaseAlbumName:
+      (track.isSecondaryRelease
+        ? track.mainReleaseTrack.album.name
         : null),
 
-    originalReleaseAlbumColor:
-      (track.isRerelease
-        ? track.originalReleaseTrack.album.color
+    mainReleaseAlbumColor:
+      (track.isSecondaryRelease
+        ? track.mainReleaseTrack.album.color
         : null),
 
     otherReleaseAlbumNames:
@@ -84,7 +84,7 @@ export default {
             title: language.$('misc.artistCommentary'),
           }),
 
-        data.isRerelease &&
+        data.isSecondaryRelease &&
           html.tags([
             html.tag('p', {class: ['drop', 'commentary-drop']},
               {[html.onlyIfSiblings]: true},
@@ -93,29 +93,29 @@ export default {
                 const workingOptions = {};
 
                 workingOptions.album =
-                  relations.originalReleaseTrackLink.slots({
+                  relations.mainReleaseTrackLink.slots({
                     content:
-                      data.originalReleaseAlbumName,
+                      data.mainReleaseAlbumName,
 
                     color:
-                      data.originalReleaseAlbumColor,
+                      data.mainReleaseAlbumColor,
                   });
 
-                if (data.name !== data.originalReleaseName) {
+                if (data.name !== data.mainReleaseName) {
                   workingCapsule += '.namedDifferently';
                   workingOptions.name =
-                    html.tag('i', data.originalReleaseName);
+                    html.tag('i', data.mainReleaseName);
                 }
 
                 return language.$(workingCapsule, workingOptions);
               })),
 
-            relations.originalReleaseArtistCommentaryEntries,
+            relations.mainReleaseArtistCommentaryEntries,
           ]),
 
         html.tags([
-          data.isRerelease &&
-          !html.isBlank(relations.originalReleaseArtistCommentaryEntries) &&
+          data.isSecondaryRelease &&
+          !html.isBlank(relations.mainReleaseArtistCommentaryEntries) &&
             html.tag('p', {class: ['drop', 'commentary-drop']},
               {[html.onlyIfSiblings]: true},
 
diff --git a/src/content/dependencies/generateTrackInfoPage.js b/src/content/dependencies/generateTrackInfoPage.js
index 9af85aac..1c349c2e 100644
--- a/src/content/dependencies/generateTrackInfoPage.js
+++ b/src/content/dependencies/generateTrackInfoPage.js
@@ -27,10 +27,10 @@ export default {
   extraDependencies: ['html', 'language'],
 
   query: (track) => ({
-    originalReleaseTrack:
-      (track.isOriginalRelease
+    mainReleaseTrack:
+      (track.isMainRelease
         ? track
-        : track.originalReleaseTrack),
+        : track.mainReleaseTrack),
   }),
 
   relations: (relation, query, track) => ({
@@ -83,11 +83,11 @@ export default {
 
     referencedByTracksList:
       relation('generateTrackListDividedByGroups',
-        query.originalReleaseTrack.referencedByTracks),
+        query.mainReleaseTrack.referencedByTracks),
 
     sampledByTracksList:
       relation('generateTrackListDividedByGroups',
-        query.originalReleaseTrack.sampledByTracks),
+        query.mainReleaseTrack.sampledByTracks),
 
     flashesThatFeatureList:
       relation('generateTrackInfoPageFeaturedByFlashesList', track),
diff --git a/src/content/dependencies/listGroupsByDuration.js b/src/content/dependencies/listGroupsByDuration.js
index da2f26db..c79e1bc4 100644
--- a/src/content/dependencies/listGroupsByDuration.js
+++ b/src/content/dependencies/listGroupsByDuration.js
@@ -16,7 +16,7 @@ export default {
       groups.map(group =>
         getTotalDuration(
           group.albums.flatMap(album => album.tracks),
-          {originalReleasesOnly: true}));
+          {mainReleasesOnly: true}));
 
     filterByCount(groups, durations);
     sortByCount(groups, durations, {greatestFirst: true});
diff --git a/src/content/dependencies/listTracksByDate.js b/src/content/dependencies/listTracksByDate.js
index 0a2bfd6c..b2cba5e6 100644
--- a/src/content/dependencies/listTracksByDate.js
+++ b/src/content/dependencies/listTracksByDate.js
@@ -42,10 +42,10 @@ export default {
         query.chunks
           .map(({date}) => date),
 
-      rereleases:
+      secreleases:
         query.chunks.map(({chunk}) =>
           chunk.map(track =>
-            track.originalReleaseTrack !== null)),
+            track.mainReleaseTrack !== null)),
     };
   },
 
@@ -65,20 +65,20 @@ export default {
       chunkRows:
         stitchArrays({
           trackLinks: relations.trackLinks,
-          rereleases: data.rereleases,
-        }).map(({trackLinks, rereleases}) =>
+          secreleases: data.secreleases,
+        }).map(({trackLinks, secreleases}) =>
             stitchArrays({
               trackLink: trackLinks,
-              rerelease: rereleases,
-            }).map(({trackLink, rerelease}) =>
-                (rerelease
+              secrelease: secreleases,
+            }).map(({trackLink, secrelease}) =>
+                (secrelease
                   ? {stringsKey: 'rerelease', track: trackLink}
                   : {track: trackLink}))),
 
       chunkRowAttributes:
-        data.rereleases.map(rereleases =>
-          rereleases.map(rerelease =>
-            (rerelease
+        data.secreleases.map(secreleases =>
+          secreleases.map(secrelease =>
+            (secrelease
               ? {class: 'rerelease'}
               : null))),
     });
diff --git a/src/data/checks.js b/src/data/checks.js
index ff278d36..10261e4f 100644
--- a/src/data/checks.js
+++ b/src/data/checks.js
@@ -228,11 +228,11 @@ export function filterReferenceErrors(wikiData, {
       artistContribs: '_contrib',
       contributorContribs: '_contrib',
       coverArtistContribs: '_contrib',
-      referencedTracks: '_trackNotRerelease',
-      sampledTracks: '_trackNotRerelease',
+      referencedTracks: '_trackMainReleasesOnly',
+      sampledTracks: '_trackMainReleasesOnly',
       artTags: '_artTag',
       referencedArtworks: '_artwork',
-      originalReleaseTrack: '_trackNotRerelease',
+      mainReleaseTrack: '_trackMainReleasesOnly',
       commentary: '_commentary',
     }],
 
@@ -358,29 +358,28 @@ export function filterReferenceErrors(wikiData, {
                 findFn = ref => boundFind.track(ref.reference);
                 break;
 
-              case '_trackNotRerelease':
+              case '_trackMainReleasesOnly':
                 findFn = trackRef => {
                   const track = boundFind.track(trackRef);
-                  const originalRef = track && CacheableObject.getUpdateValue(track, 'originalReleaseTrack');
+                  const mainRef = track && CacheableObject.getUpdateValue(track, 'mainReleaseTrack');
 
-                  if (originalRef) {
-                    // It's possible for the original to not actually exist, in this case.
-                    // It should still be reported since the 'Originally Released As' field
-                    // was present.
-                    const original = boundFind.track(originalRef, {mode: 'quiet'});
+                  if (mainRef) {
+                    // It's possible for the main release to not actually exist, in this case.
+                    // It should still be reported since the 'Main Release' field was present.
+                    const main = boundFind.track(mainRef, {mode: 'quiet'});
 
                     // Prefer references by name, but only if it's unambiguous.
-                    const originalByName =
-                      (original
-                        ? boundFind.track(original.name, {mode: 'quiet'})
+                    const mainByName =
+                      (main
+                        ? boundFind.track(main.name, {mode: 'quiet'})
                         : null);
 
                     const shouldBeMessage =
-                      (originalByName
-                        ? colors.green(original.name)
-                     : original
-                        ? colors.green('track:' + original.directory)
-                        : colors.green(originalRef));
+                      (mainByName
+                        ? colors.green(main.name)
+                     : main
+                        ? colors.green('track:' + main.directory)
+                        : colors.green(mainRef));
 
                     throw new Error(`Reference ${colors.red(trackRef)} is to a rerelease, should be ${shouldBeMessage}`);
                   }
diff --git a/src/data/composite/things/artist/artistTotalDuration.js b/src/data/composite/things/artist/artistTotalDuration.js
index a4a33542..b8a205fe 100644
--- a/src/data/composite/things/artist/artistTotalDuration.js
+++ b/src/data/composite/things/artist/artistTotalDuration.js
@@ -48,18 +48,18 @@ export default templateCompositeFrom({
 
     withPropertyFromList({
       list: '#allContributions.thing',
-      property: input.value('isOriginalRelease'),
+      property: input.value('isMainRelease'),
     }),
 
     withFilteredList({
       list: '#allContributions',
-      filter: '#allContributions.thing.isOriginalRelease',
+      filter: '#allContributions.thing.isMainRelease',
     }).outputs({
-      '#filteredList': '#originalContributions',
+      '#filteredList': '#mainReleaseContributions',
     }),
 
     withContributionListSums({
-      list: '#originalContributions',
+      list: '#mainReleaseContributions',
     }),
 
     exposeDependency({
diff --git a/src/data/composite/things/track/index.js b/src/data/composite/things/track/index.js
index 32c72f78..492b35be 100644
--- a/src/data/composite/things/track/index.js
+++ b/src/data/composite/things/track/index.js
@@ -1,15 +1,15 @@
 export {default as exitWithoutUniqueCoverArt} from './exitWithoutUniqueCoverArt.js';
-export {default as inheritContributionListFromOriginalRelease} from './inheritContributionListFromOriginalRelease.js';
-export {default as inheritFromOriginalRelease} from './inheritFromOriginalRelease.js';
+export {default as inheritContributionListFromMainRelease} from './inheritContributionListFromMainRelease.js';
+export {default as inheritFromMainRelease} from './inheritFromMainRelease.js';
 export {default as withAlbum} from './withAlbum.js';
 export {default as withAlwaysReferenceByDirectory} from './withAlwaysReferenceByDirectory.js';
 export {default as withContainingTrackSection} from './withContainingTrackSection.js';
 export {default as withDate} from './withDate.js';
 export {default as withDirectorySuffix} from './withDirectorySuffix.js';
 export {default as withHasUniqueCoverArt} from './withHasUniqueCoverArt.js';
-export {default as withOriginalRelease} from './withOriginalRelease.js';
+export {default as withMainRelease} from './withMainRelease.js';
 export {default as withOtherReleases} from './withOtherReleases.js';
 export {default as withPropertyFromAlbum} from './withPropertyFromAlbum.js';
-export {default as withPropertyFromOriginalRelease} from './withPropertyFromOriginalRelease.js';
+export {default as withPropertyFromMainRelease} from './withPropertyFromMainRelease.js';
 export {default as withSuffixDirectoryFromAlbum} from './withSuffixDirectoryFromAlbum.js';
 export {default as withTrackArtDate} from './withTrackArtDate.js';
diff --git a/src/data/composite/things/track/inheritContributionListFromOriginalRelease.js b/src/data/composite/things/track/inheritContributionListFromMainRelease.js
index f4ae3ddb..89252feb 100644
--- a/src/data/composite/things/track/inheritContributionListFromOriginalRelease.js
+++ b/src/data/composite/things/track/inheritContributionListFromMainRelease.js
@@ -1,5 +1,5 @@
-// Like inheritFromOriginalRelease, but tuned for contributions.
-// Recontextualized contributions for this track.
+// Like inheritFromMainRelease, but tuned for contributions.
+// Recontextualizes contributions for this track.
 
 import {input, templateCompositeFrom} from '#composite';
 
@@ -9,36 +9,36 @@ import {withRecontextualizedContributionList, withRedatedContributionList}
   from '#composite/wiki-data';
 
 import withDate from './withDate.js';
-import withPropertyFromOriginalRelease
-  from './withPropertyFromOriginalRelease.js';
+import withPropertyFromMainRelease
+  from './withPropertyFromMainRelease.js';
 
 export default templateCompositeFrom({
-  annotation: `inheritContributionListFromOriginalRelease`,
+  annotation: `inheritContributionListFromMainRelease`,
 
   steps: () => [
-    withPropertyFromOriginalRelease({
+    withPropertyFromMainRelease({
       property: input.thisProperty(),
       notFoundValue: input.value([]),
     }),
 
     raiseOutputWithoutDependency({
-      dependency: '#isRerelease',
+      dependency: '#isSecondaryRelease',
       mode: input.value('falsy'),
     }),
 
     withRecontextualizedContributionList({
-      list: '#originalValue',
+      list: '#mainReleaseValue',
     }),
 
     withDate(),
 
     withRedatedContributionList({
-      list: '#originalValue',
+      list: '#mainReleaseValue',
       date: '#date',
     }),
 
     exposeDependency({
-      dependency: '#originalValue',
+      dependency: '#mainReleaseValue',
     }),
   ],
 });
diff --git a/src/data/composite/things/track/inheritFromOriginalRelease.js b/src/data/composite/things/track/inheritFromMainRelease.js
index 38ab06be..b1cbb65e 100644
--- a/src/data/composite/things/track/inheritFromOriginalRelease.js
+++ b/src/data/composite/things/track/inheritFromMainRelease.js
@@ -1,9 +1,9 @@
 // Early exits with the value for the same property as specified on the
-// original release, if this track is a rerelease, and otherwise continues
+// main release, if this track is a secondary release, and otherwise continues
 // without providing any further dependencies.
 //
-// Like withOriginalRelease, this will early exit (with notFoundValue) if the
-// original release is specified by reference and that reference doesn't
+// Like withMainRelease, this will early exit (with notFoundValue) if the
+// main release is specified by reference and that reference doesn't
 // resolve to anything.
 
 import {input, templateCompositeFrom} from '#composite';
@@ -11,11 +11,11 @@ import {input, templateCompositeFrom} from '#composite';
 import {exposeDependency, raiseOutputWithoutDependency}
   from '#composite/control-flow';
 
-import withPropertyFromOriginalRelease
-  from './withPropertyFromOriginalRelease.js';
+import withPropertyFromMainRelease
+  from './withPropertyFromMainRelease.js';
 
 export default templateCompositeFrom({
-  annotation: `inheritFromOriginalRelease`,
+  annotation: `inheritFromMainRelease`,
 
   inputs: {
     notFoundValue: input({
@@ -24,18 +24,18 @@ export default templateCompositeFrom({
   },
 
   steps: () => [
-    withPropertyFromOriginalRelease({
+    withPropertyFromMainRelease({
       property: input.thisProperty(),
       notFoundValue: input('notFoundValue'),
     }),
 
     raiseOutputWithoutDependency({
-      dependency: '#isRerelease',
+      dependency: '#isSecondaryRelease',
       mode: input.value('falsy'),
     }),
 
     exposeDependency({
-      dependency: '#originalValue',
+      dependency: '#mainReleaseValue',
     }),
   ],
 });
diff --git a/src/data/composite/things/track/withAlwaysReferenceByDirectory.js b/src/data/composite/things/track/withAlwaysReferenceByDirectory.js
index 26c5ba97..aebcf793 100644
--- a/src/data/composite/things/track/withAlwaysReferenceByDirectory.js
+++ b/src/data/composite/things/track/withAlwaysReferenceByDirectory.js
@@ -51,7 +51,7 @@ export default templateCompositeFrom({
 
     // Remaining code is for defaulting to true if this track is a rerelease of
     // another with the same name, so everything further depends on access to
-    // trackData as well as originalReleaseTrack.
+    // trackData as well as mainReleaseTrack.
 
     exitWithoutDependency({
       dependency: 'trackData',
@@ -60,45 +60,46 @@ export default templateCompositeFrom({
     }),
 
     exitWithoutDependency({
-      dependency: 'originalReleaseTrack',
+      dependency: 'mainReleaseTrack',
       value: input.value(false),
     }),
 
-    // It's necessary to use the custom trackOriginalReleasesOnly find function
+    // It's necessary to use the custom trackMainReleasesOnly find function
     // here, so as to avoid recursion issues - the find.track() function depends
     // on accessing each track's alwaysReferenceByDirectory, which means it'll
     // hit *this track* - and thus this step - and end up recursing infinitely.
-    // By definition, find.trackOriginalReleasesOnly excludes tracks which have
-    // an originalReleaseTrack update value set, which means even though it does
+    // By definition, find.trackMainReleasesOnly excludes tracks which have
+    // an mainReleaseTrack update value set, which means even though it does
     // still access each of tracks' `alwaysReferenceByDirectory` property, it
     // won't access that of *this* track - it will never proceed past the
     // `exitWithoutDependency` step directly above, so there's no opportunity
     // for recursion.
     withResolvedReference({
-      ref: 'originalReleaseTrack',
+      ref: 'mainReleaseTrack',
       data: 'trackData',
-      find: input.value(find.trackOriginalReleasesOnly),
+      find: input.value(find.trackMainReleasesOnly),
     }).outputs({
-      '#resolvedReference': '#originalRelease',
+      '#resolvedReference': '#mainRelease',
     }),
 
     exitWithoutDependency({
-      dependency: '#originalRelease',
+      dependency: '#mainRelease',
       value: input.value(false),
     }),
 
     withPropertyFromObject({
-      object: '#originalRelease',
+      object: '#mainRelease',
       property: input.value('name'),
     }),
 
     {
-      dependencies: ['name', '#originalRelease.name'],
+      dependencies: ['name', '#mainRelease.name'],
       compute: (continuation, {
         name,
-        ['#originalRelease.name']: originalName,
+        ['#mainRelease.name']: mainReleaseName,
       }) => continuation({
-        ['#alwaysReferenceByDirectory']: name === originalName,
+        ['#alwaysReferenceByDirectory']:
+          name === mainReleaseName,
       }),
     },
   ],
diff --git a/src/data/composite/things/track/withOriginalRelease.js b/src/data/composite/things/track/withMainRelease.js
index 7aefc64a..3a91edae 100644
--- a/src/data/composite/things/track/withOriginalRelease.js
+++ b/src/data/composite/things/track/withMainRelease.js
@@ -1,7 +1,7 @@
-// Just includes the original release of this track as a dependency.
-// If this track isn't a rerelease, then it'll provide null, unless the
-// {selfIfOriginal} option is set, in which case it'll provide this track
-// itself. This will early exit (with notFoundValue) if the original release
+// Just includes the main release of this track as a dependency.
+// If this track isn't a secondary release, then it'll provide null, unless
+// the {selfIfMain} option is set, in which case it'll provide this track
+// itself. This will early exit (with notFoundValue) if the main release
 // is specified by reference and that reference doesn't resolve to anything.
 
 import {input, templateCompositeFrom} from '#composite';
@@ -12,42 +12,42 @@ import {withResolvedReference} from '#composite/wiki-data';
 import {soupyFind} from '#composite/wiki-properties';
 
 export default templateCompositeFrom({
-  annotation: `withOriginalRelease`,
+  annotation: `withMainRelease`,
 
   inputs: {
-    selfIfOriginal: input({type: 'boolean', defaultValue: false}),
+    selfIfMain: input({type: 'boolean', defaultValue: false}),
     notFoundValue: input({defaultValue: null}),
   },
 
-  outputs: ['#originalRelease'],
+  outputs: ['#mainRelease'],
 
   steps: () => [
     withResultOfAvailabilityCheck({
-      from: 'originalReleaseTrack',
+      from: 'mainReleaseTrack',
     }),
 
     {
       dependencies: [
         input.myself(),
-        input('selfIfOriginal'),
+        input('selfIfMain'),
         '#availability',
       ],
 
       compute: (continuation, {
         [input.myself()]: track,
-        [input('selfIfOriginal')]: selfIfOriginal,
+        [input('selfIfMain')]: selfIfMain,
         '#availability': availability,
       }) =>
         (availability
           ? continuation()
           : continuation.raiseOutput({
-              ['#originalRelease']:
-                (selfIfOriginal ? track : null),
+              ['#mainRelease']:
+                (selfIfMain ? track : null),
             })),
     },
 
     withResolvedReference({
-      ref: 'originalReleaseTrack',
+      ref: 'mainReleaseTrack',
       find: soupyFind.input('track'),
     }),
 
@@ -63,7 +63,7 @@ export default templateCompositeFrom({
         ['#resolvedReference']: resolvedReference,
       }) =>
         continuation({
-          ['#originalRelease']: resolvedReference,
+          ['#mainRelease']: resolvedReference,
         }),
     },
   ],
diff --git a/src/data/composite/things/track/withOtherReleases.js b/src/data/composite/things/track/withOtherReleases.js
index f8c1c3f0..3fec8742 100644
--- a/src/data/composite/things/track/withOtherReleases.js
+++ b/src/data/composite/things/track/withOtherReleases.js
@@ -2,7 +2,7 @@ import {input, templateCompositeFrom} from '#composite';
 
 import {exitWithoutDependency} from '#composite/control-flow';
 
-import withOriginalRelease from './withOriginalRelease.js';
+import withMainRelease from './withMainRelease.js';
 
 export default templateCompositeFrom({
   annotation: `withOtherReleases`,
@@ -15,26 +15,27 @@ export default templateCompositeFrom({
       mode: input.value('empty'),
     }),
 
-    withOriginalRelease({
-      selfIfOriginal: input.value(true),
+    withMainRelease({
+      selfIfMain: input.value(true),
       notFoundValue: input.value([]),
     }),
 
+    // TODO: Jegus shouldn't this be a proper reverse list
     {
-      dependencies: [input.myself(), '#originalRelease', 'trackData'],
+      dependencies: [input.myself(), '#mainRelease', 'trackData'],
       compute: (continuation, {
         [input.myself()]: thisTrack,
-        ['#originalRelease']: originalRelease,
+        ['#mainRelease']: mainRelease,
         trackData,
       }) => continuation({
         ['#otherReleases']:
-          (originalRelease === thisTrack
+          (mainRelease === thisTrack
             ? []
-            : [originalRelease])
+            : [mainRelease])
             .concat(trackData.filter(track =>
-              track !== originalRelease &&
+              track !== mainRelease &&
               track !== thisTrack &&
-              track.originalReleaseTrack === originalRelease)),
+              track.mainReleaseTrack === mainRelease)),
       }),
     },
   ],
diff --git a/src/data/composite/things/track/withPropertyFromOriginalRelease.js b/src/data/composite/things/track/withPropertyFromMainRelease.js
index fd37f6de..393a4c63 100644
--- a/src/data/composite/things/track/withPropertyFromOriginalRelease.js
+++ b/src/data/composite/things/track/withPropertyFromMainRelease.js
@@ -1,8 +1,8 @@
-// Provides a value inherited from the original release, if applicable, and a
-// flag indicating if this track is a rerelase or not.
+// Provides a value inherited from the main release, if applicable, and a
+// flag indicating if this track is a secondary release or not.
 //
-// Like withOriginalRelease, this will early exit (with notFoundValue) if the
-// original release is specified by reference and that reference doesn't
+// Like withMainRelease, this will early exit (with notFoundValue) if the
+// main release is specified by reference and that reference doesn't
 // resolve to anything.
 
 import {input, templateCompositeFrom} from '#composite';
@@ -10,10 +10,10 @@ import {input, templateCompositeFrom} from '#composite';
 import {withResultOfAvailabilityCheck} from '#composite/control-flow';
 import {withPropertyFromObject} from '#composite/data';
 
-import withOriginalRelease from './withOriginalRelease.js';
+import withMainRelease from './withMainRelease.js';
 
 export default templateCompositeFrom({
-  annotation: `inheritFromOriginalRelease`,
+  annotation: `inheritFromMainRelease`,
 
   inputs: {
     property: input({type: 'string'}),
@@ -26,18 +26,18 @@ export default templateCompositeFrom({
   outputs: ({
     [input.staticValue('property')]: property,
   }) =>
-    ['#isRerelease'].concat(
+    ['#isSecondaryRelease'].concat(
       (property
-        ? ['#original.' + property]
-        : ['#originalValue'])),
+        ? ['#mainRelease.' + property]
+        : ['#mainReleaseValue'])),
 
   steps: () => [
-    withOriginalRelease({
+    withMainRelease({
       notFoundValue: input('notFoundValue'),
     }),
 
     withResultOfAvailabilityCheck({
-      from: '#originalRelease',
+      from: '#mainRelease',
     }),
 
     {
@@ -54,14 +54,14 @@ export default templateCompositeFrom({
           ? continuation()
           : continuation.raiseOutput(
               Object.assign(
-                {'#isRerelease': false},
+                {'#isSecondaryRelease': false},
                 (property
-                  ? {['#original.' + property]: null}
-                  : {'#originalValue': null})))),
+                  ? {['#mainRelease.' + property]: null}
+                  : {'#mainReleaseValue': null})))),
     },
 
     withPropertyFromObject({
-      object: '#originalRelease',
+      object: '#mainRelease',
       property: input('property'),
     }),
 
@@ -77,10 +77,10 @@ export default templateCompositeFrom({
       }) =>
         continuation.raiseOutput(
           Object.assign(
-            {'#isRerelease': true},
+            {'#isSecondaryRelease': true},
             (property
-              ? {['#original.' + property]: value}
-              : {'#originalValue': value}))),
+              ? {['#mainRelease.' + property]: value}
+              : {'#mainReleaseValue': value}))),
     },
   ],
 });
diff --git a/src/data/things/track.js b/src/data/things/track.js
index af2206f0..6ac417b5 100644
--- a/src/data/things/track.js
+++ b/src/data/things/track.js
@@ -60,15 +60,15 @@ import {
 
 import {
   exitWithoutUniqueCoverArt,
-  inheritContributionListFromOriginalRelease,
-  inheritFromOriginalRelease,
+  inheritContributionListFromMainRelease,
+  inheritFromMainRelease,
   withAlbum,
   withAlwaysReferenceByDirectory,
   withContainingTrackSection,
   withDate,
   withDirectorySuffix,
   withHasUniqueCoverArt,
-  withOriginalRelease,
+  withMainRelease,
   withOtherReleases,
   withPropertyFromAlbum,
   withSuffixDirectoryFromAlbum,
@@ -208,7 +208,7 @@ export class Track extends Thing {
     creditSources: commentary(),
 
     lyrics: [
-      inheritFromOriginalRelease(),
+      inheritFromMainRelease(),
       contentString(),
     ],
 
@@ -216,7 +216,7 @@ export class Track extends Thing {
     sheetMusicFiles: additionalFiles(),
     midiProjectFiles: additionalFiles(),
 
-    originalReleaseTrack: singleReference({
+    mainReleaseTrack: singleReference({
       class: input.value(Track),
       find: soupyFind.input('track'),
     }),
@@ -230,7 +230,7 @@ export class Track extends Thing {
     }),
 
     artistContribs: [
-      inheritContributionListFromOriginalRelease(),
+      inheritContributionListFromMainRelease(),
 
       withDate(),
 
@@ -266,7 +266,7 @@ export class Track extends Thing {
     ],
 
     contributorContribs: [
-      inheritContributionListFromOriginalRelease(),
+      inheritContributionListFromMainRelease(),
 
       withDate(),
 
@@ -276,9 +276,6 @@ export class Track extends Thing {
       }),
     ],
 
-    // Cover artists aren't inherited from the original release, since it
-    // typically varies by release and isn't defined by the musical qualities
-    // of the track.
     coverArtistContribs: [
       exitWithoutUniqueCoverArt({
         value: input.value([]),
@@ -320,7 +317,7 @@ export class Track extends Thing {
     ],
 
     referencedTracks: [
-      inheritFromOriginalRelease({
+      inheritFromMainRelease({
         notFoundValue: input.value([]),
       }),
 
@@ -331,7 +328,7 @@ export class Track extends Thing {
     ],
 
     sampledTracks: [
-      inheritFromOriginalRelease({
+      inheritFromMainRelease({
         notFoundValue: input.value([]),
       }),
 
@@ -405,20 +402,20 @@ export class Track extends Thing {
       exposeDependency({dependency: '#hasUniqueCoverArt'}),
     ],
 
-    isOriginalRelease: [
-      withOriginalRelease(),
+    isMainRelease: [
+      withMainRelease(),
 
       exposeWhetherDependencyAvailable({
-        dependency: '#originalRelease',
+        dependency: '#mainRelease',
         negate: input.value(true),
       }),
     ],
 
-    isRerelease: [
-      withOriginalRelease(),
+    isSecondaryRelease: [
+      withMainRelease(),
 
       exposeWhetherDependencyAvailable({
-        dependency: '#originalRelease',
+        dependency: '#mainRelease',
       }),
     ],
 
@@ -525,7 +522,7 @@ export class Track extends Thing {
         transform: parseAdditionalFiles,
       },
 
-      'Originally Released As': {property: 'originalReleaseTrack'},
+      'Main Release': {property: 'mainReleaseTrack'},
       'Referenced Tracks': {property: 'referencedTracks'},
       'Sampled Tracks': {property: 'sampledTracks'},
 
@@ -558,28 +555,28 @@ export class Track extends Thing {
     },
 
     invalidFieldCombinations: [
-      {message: `Rereleases inherit references from the original`, fields: [
-        'Originally Released As',
+      {message: `Secondary releases inherit references from the main one`, fields: [
+        'Main Release',
         'Referenced Tracks',
       ]},
 
-      {message: `Rereleases inherit samples from the original`, fields: [
-        'Originally Released As',
+      {message: `Secondary releases inherit samples from the main one`, fields: [
+        'Main Release',
         'Sampled Tracks',
       ]},
 
-      {message: `Rereleases inherit artists from the original`, fields: [
-        'Originally Released As',
+      {message: `Secondary releases inherit artists from the main one`, fields: [
+        'Main Release',
         'Artists',
       ]},
 
-      {message: `Rereleases inherit contributors from the original`, fields: [
-        'Originally Released As',
+      {message: `Secondary releases inherit contributors from the main one`, fields: [
+        'Main Release',
         'Contributors',
       ]},
 
-      {message: `Rereleases inherit lyrics from the original`, fields: [
-        'Originally Released As',
+      {message: `Secondary releases inherit lyrics from the main one`, fields: [
+        'Main Release',
         'Lyrics',
       ]},
 
@@ -609,12 +606,12 @@ export class Track extends Thing {
           : [track.name]),
     },
 
-    trackOriginalReleasesOnly: {
+    trackMainReleasesOnly: {
       referenceTypes: ['track'],
       bindTo: 'trackData',
 
       include: track =>
-        !CacheableObject.getUpdateValue(track, 'originalReleaseTrack'),
+        !CacheableObject.getUpdateValue(track, 'mainReleaseTrack'),
 
       // It's still necessary to check alwaysReferenceByDirectory here, since
       // it may be set manually (with `Always Reference By Directory: true`),
@@ -649,14 +646,14 @@ export class Track extends Thing {
     tracksWhichReference: {
       bindTo: 'trackData',
 
-      referencing: track => track.isOriginalRelease ? [track] : [],
+      referencing: track => track.isMainRelease ? [track] : [],
       referenced: track => track.referencedTracks,
     },
 
     tracksWhichSample: {
       bindTo: 'trackData',
 
-      referencing: track => track.isOriginalRelease ? [track] : [],
+      referencing: track => track.isMainRelease ? [track] : [],
       referenced: track => track.sampledTracks,
     },
 
@@ -692,8 +689,8 @@ export class Track extends Thing {
 
     parts.push(Thing.prototype[inspect.custom].apply(this));
 
-    if (CacheableObject.getUpdateValue(this, 'originalReleaseTrack')) {
-      parts.unshift(`${colors.yellow('[rerelease]')} `);
+    if (CacheableObject.getUpdateValue(this, 'mainReleaseTrack')) {
+      parts.unshift(`${colors.yellow('[secrelease]')} `);
     }
 
     let album;
diff --git a/src/strings-default.yaml b/src/strings-default.yaml
index 716769a2..131faa82 100644
--- a/src/strings-default.yaml
+++ b/src/strings-default.yaml
@@ -510,8 +510,6 @@ misc:
         date.sometime.range: "sometime {DATE_RANGE}"
         date.throughout.range: "throughout {DATE_RANGE}"
 
-      seeOriginalRelease: "See {ORIGINAL}!"
-
     info:
       fromMainRelease: >-
         This commentary is properly placed on this track's main release, {ALBUM}.