diff --git a/locales/en-US/app.ftl b/locales/en-US/app.ftl
index 91c30908bb..f7620a44a3 100644
--- a/locales/en-US/app.ftl
+++ b/locales/en-US/app.ftl
@@ -775,6 +775,8 @@ MenuButtons--publish--cancel-upload = Cancel Upload
 MenuButtons--publish--message-something-went-wrong = Uh oh, something went wrong when uploading the profile.
 MenuButtons--publish--message-try-again = Try again
 MenuButtons--publish--download = Download
+MenuButtons--publish--download-json = Download as JSON
+MenuButtons--publish--download-json-error = Error preparing JSON download
 MenuButtons--publish--compressing = Compressing…
 MenuButtons--publish--error-while-compressing = Error while compressing, try unchecking some checkboxes to reduce the profile size.
 
diff --git a/src/actions/publish.ts b/src/actions/publish.ts
index f4b3869bd2..391044d46f 100644
--- a/src/actions/publish.ts
+++ b/src/actions/publish.ts
@@ -60,9 +60,14 @@ import type {
   ProfileIndexTranslationMaps,
   ProfileEncodingResult,
   SharingMode,
+  PublishProfileFormat,
 } from 'firefox-profiler/types';
 import { compress } from 'firefox-profiler/utils/gz';
-import { serializeProfileToJsonString } from 'firefox-profiler/profile-logic/process-profile';
+import {
+  optimizeProfileForStorage,
+  serializeProfileToJsonSlabsFile,
+  serializeProfileToJsonString,
+} from 'firefox-profiler/profile-logic/process-profile';
 
 export function updateSharingOption(
   mode: SharingMode,
@@ -78,33 +83,45 @@ export function updateSharingOption(
 }
 
 export function sanitizedProfileEncodingStarted(
+  mode: SharingMode,
+  format: PublishProfileFormat,
   sanitizedProfile: Profile,
   encodingPromise: Promise<ProfileEncodingResult>
 ): Action {
   return {
     type: 'SANITIZED_PROFILE_ENCODING_STARTED',
+    mode,
+    format,
     sanitizedProfile,
     encodingPromise,
   };
 }
 
 export function sanitizedProfileEncodingCompleted(
+  mode: SharingMode,
+  format: PublishProfileFormat,
   sanitizedProfile: Profile,
   profileData: Blob
 ): Action {
   return {
     type: 'SANITIZED_PROFILE_ENCODING_COMPLETED',
+    mode,
+    format,
     sanitizedProfile,
     profileData,
   };
 }
 
 export function sanitizedProfileEncodingFailed(
+  mode: SharingMode,
+  format: PublishProfileFormat,
   sanitizedProfile: Profile,
   error: Error
 ): Action {
   return {
     type: 'SANITIZED_PROFILE_ENCODING_FAILED',
+    mode,
+    format,
     sanitizedProfile,
     error,
   };
@@ -268,10 +285,21 @@ function unwrapEncodedProfile(encodingResult: ProfileEncodingResult): Blob {
   return encodingResult.profileData;
 }
 
-export type InflightProfileEncoding = {
-  sanitizedProfile: Profile;
-  encodingPromise: Promise<ProfileEncodingResult>;
-};
+function serializeSanitizedProfile(
+  format: PublishProfileFormat,
+  sanitizedProfile: Profile
+): string | Uint8Array<ArrayBuffer> {
+  switch (format) {
+    case 'jslb':
+      return serializeProfileToJsonSlabsFile(
+        optimizeProfileForStorage(sanitizedProfile)
+      );
+    case 'json':
+      return serializeProfileToJsonString(sanitizedProfile);
+    default:
+      throw new Error(`Unknown publish format: ${format as string}`);
+  }
+}
 
 /**
  * Kick off "encoding" of the sanitized profile. Specifically this means:
@@ -281,7 +309,7 @@ export type InflightProfileEncoding = {
  *
  * The asynchronous compression can take a few seconds, so we kick it off
  * immediately when the download or share panel is opened. The in-flight
- * compression is tracked in the redux state, so opening the other panel or
+ * compression is tracked in the redux state, so reopening the panel or
  * pressing Upload reuses it (for the same sanitized profile) instead of
  * compressing again. The returned promise lets the caller wait on the
  * compressed result.
@@ -289,61 +317,69 @@ export type InflightProfileEncoding = {
  * This thunk action is synchronous.
  */
 export function encodeSanitizedProfile(
-  mode: SharingMode
-): ThunkAction<InflightProfileEncoding> {
-  return (dispatch, getState): InflightProfileEncoding => {
+  mode: SharingMode,
+  format: PublishProfileFormat
+): ThunkAction<Promise<ProfileEncodingResult>> {
+  return (dispatch, getState): Promise<ProfileEncodingResult> => {
     const state = getState();
     const sanitizedProfile = getSanitizedProfile(state, mode).profile;
 
-    const encodingState = getSanitizedProfileEncodingState(state);
+    const encodingState = getSanitizedProfileEncodingState(state, mode, format);
     if (
       encodingState.phase === 'ENCODING' &&
       encodingState.sanitizedProfile === sanitizedProfile
     ) {
       // A compression for this profile is already in-flight; reuse it.
-      return {
-        sanitizedProfile,
-        encodingPromise: encodingState.encodingPromise,
-      };
+      return encodingState.encodingPromise;
     }
     if (
       encodingState.phase === 'DONE' &&
       encodingState.sanitizedProfile === sanitizedProfile
     ) {
       // We already have an encoded version of this profile in our state! Use it.
-      return {
-        sanitizedProfile,
-        encodingPromise: Promise.resolve({
-          type: 'SUCCESS',
-          profileData: encodingState.profileData,
-        }),
-      };
+      return Promise.resolve({
+        type: 'SUCCESS',
+        profileData: encodingState.profileData,
+      });
     }
 
     // Kick off a new encoding for this profile. Don't await the promise,
-    // just return it as part of the InflightProfileEncoding.
+    // just hand it back to the caller.
     const encodingPromise: Promise<ProfileEncodingResult> = (async function () {
       // Yield so the ENCODING phase (dispatched below) is in the store before a
       // synchronous failure here could dispatch FAILED, which the reducer drops.
       await Promise.resolve();
       try {
-        const gzipData = await compress(
-          serializeProfileToJsonString(sanitizedProfile)
-        );
+        const serialized = serializeSanitizedProfile(format, sanitizedProfile);
+        const gzipData = await compress(serialized);
         const blob = new Blob([gzipData], { type: 'application/octet-binary' });
-        dispatch(sanitizedProfileEncodingCompleted(sanitizedProfile, blob));
+        dispatch(
+          sanitizedProfileEncodingCompleted(
+            mode,
+            format,
+            sanitizedProfile,
+            blob
+          )
+        );
         return { type: 'SUCCESS', profileData: blob };
       } catch (error) {
-        dispatch(sanitizedProfileEncodingFailed(sanitizedProfile, error));
+        dispatch(
+          sanitizedProfileEncodingFailed(mode, format, sanitizedProfile, error)
+        );
         console.error('Error while compressing the profile data', error);
         return { type: 'ERROR', error };
       }
     })();
 
     dispatch(
-      sanitizedProfileEncodingStarted(sanitizedProfile, encodingPromise)
+      sanitizedProfileEncodingStarted(
+        mode,
+        format,
+        sanitizedProfile,
+        encodingPromise
+      )
     );
-    return { sanitizedProfile, encodingPromise };
+    return encodingPromise;
   };
 }
 
@@ -394,8 +430,9 @@ export function attemptToPublish(): ThunkAction<Promise<boolean>> {
         prePublishedState,
         'upload'
       );
-      const profileEncoding = dispatch(encodeSanitizedProfile('upload'));
-      const encodingResult = await profileEncoding.encodingPromise;
+      const encodingResult = await dispatch(
+        encodeSanitizedProfile('upload', 'jslb')
+      );
 
       // The previous line was async, check to make sure that this request is still valid.
       // The upload could have been aborted while we were compressing the data.
diff --git a/src/components/app/MenuButtons/Publish.css b/src/components/app/MenuButtons/Publish.css
index 4d6d4ca9b1..1162af6384 100644
--- a/src/components/app/MenuButtons/Publish.css
+++ b/src/components/app/MenuButtons/Publish.css
@@ -170,6 +170,54 @@
   background-image: url(../../../../res/img/svg/download-light.svg);
 }
 
+/* Split-button styling: primary "Download" button on the left, dropdown
+ * toggle on the right, visually joined. */
+.publishPanelSplitButton {
+  display: inline-flex;
+  margin: 0 8px;
+}
+
+.publishPanelSplitButtonMain {
+  margin: 0;
+  border-bottom-right-radius: 0;
+  border-top-right-radius: 0;
+}
+
+.publishPanelSplitButtonToggleButton {
+  position: relative;
+  width: 24px;
+  min-width: 0;
+  height: 32px;
+  padding: 0;
+  border-left: 1px solid var(--grey-30-a60, rgb(12 12 13 / 0.2));
+  border-bottom-left-radius: 0;
+  border-top-left-radius: 0;
+  cursor: default;
+}
+
+/* Down-caret drawn with borders, matching the marker-chart filter/copy
+ * buttons' style. */
+.publishPanelSplitButtonToggleButton::after {
+  position: absolute;
+  top: 50%;
+  left: 50%;
+  width: 0;
+  height: 0;
+  border-top: 5px solid;
+  border-right: 4px solid transparent;
+  border-left: 4px solid transparent;
+  color: var(--clickable-foreground-color);
+  content: '';
+  transform: translate(-50%, -25%);
+}
+
+/* Pin the download-format menu to a fixed width. The JS side subtracts this
+ * width from the toggle button's right edge to right-anchor the menu; the
+ * two must stay in sync. */
+.publishPanelDownloadFormatContextMenu {
+  width: 220px;
+}
+
 .menuButtonsDownloadSize {
   display: inline-block;
   margin: 0 4px;
diff --git a/src/components/app/MenuButtons/Publish.tsx b/src/components/app/MenuButtons/Publish.tsx
index 413b8c49f6..ff9af1f56a 100644
--- a/src/components/app/MenuButtons/Publish.tsx
+++ b/src/components/app/MenuButtons/Publish.tsx
@@ -20,15 +20,17 @@ import {
 import {
   getAbortFunction,
   getCheckedSharingOptions,
-  getFilenameString,
+  getDownloadFilename,
   getUploadPhase,
   getUploadProgress,
   getUploadProgressString,
   getUploadError,
   getShouldSanitizeByDefault,
-  getSanitizedProfileEncodingState,
+  getSanitizedProfileEncodingStates,
 } from 'firefox-profiler/selectors/publish';
 import { BlobUrlLink } from 'firefox-profiler/components/shared/BlobUrlLink';
+import { ContextMenu } from 'firefox-profiler/components/shared/ContextMenu';
+import { MenuItem, showMenu } from '@firefox-devtools/react-contextmenu';
 import { assertExhaustiveCheck } from 'firefox-profiler/utils/types';
 import prettyBytes from 'firefox-profiler/utils/pretty-bytes';
 
@@ -45,6 +47,7 @@ import type {
   StartEndRange,
   UploadPhase,
   SanitizedProfileEncodingState,
+  PublishProfileFormat,
 } from 'firefox-profiler/types';
 
 import './Publish.css';
@@ -62,8 +65,12 @@ type StateProps = {
   readonly profileContainsPrivateBrowsingInformation: boolean;
   readonly profileHasJSTracingArgumentValues: boolean;
   readonly checkedSharingOptions: CheckedSharingOptions;
-  readonly sanitizedProfileEncodingState: SanitizedProfileEncodingState;
-  readonly downloadFileName: string;
+  readonly sanitizedProfileEncodingStates: Record<
+    PublishProfileFormat,
+    SanitizedProfileEncodingState
+  >;
+  readonly jslbDownloadFileName: string;
+  readonly jsonDownloadFileName: string;
   readonly uploadPhase: UploadPhase;
   readonly uploadProgress: number;
   readonly uploadProgressString: string;
@@ -83,9 +90,13 @@ type PublishProps = ConnectedProps<OwnProps, StateProps, DispatchProps>;
 
 class PublishPanelImpl extends React.PureComponent<PublishProps, {}> {
   override componentDidMount(): void {
-    this.props.encodeSanitizedProfile(this.props.mode);
+    this._refreshEncoding('jslb');
   }
 
+  _refreshEncoding = (format: PublishProfileFormat) => {
+    this.props.encodeSanitizedProfile(this.props.mode, format);
+  };
+
   _onCheckboxChange = (e: React.ChangeEvent<HTMLInputElement>) => {
     const sharingOption = e.target.name as keyof CheckedSharingOptions;
     this.props.updateSharingOption(
@@ -94,7 +105,16 @@ class PublishPanelImpl extends React.PureComponent<PublishProps, {}> {
       e.target.checked
     );
 
-    this.props.encodeSanitizedProfile(this.props.mode);
+    this._refreshEncoding('jslb');
+    // Only keep the JSON encoding fresh if it has already been requested at
+    // least once (i.e. the user has opened the download dropdown).
+    if (this.props.sanitizedProfileEncodingStates.json.phase !== 'INITIAL') {
+      this._refreshEncoding('json');
+    }
+  };
+
+  _onJsonDropdownOpen = () => {
+    this._refreshEncoding('json');
   };
 
   _renderCheckbox(
@@ -102,9 +122,13 @@ class PublishPanelImpl extends React.PureComponent<PublishProps, {}> {
     labelL10nId: string,
     additionalContent?: React.ReactNode
   ) {
-    const { checkedSharingOptions, uploadPhase } = this.props;
+    const { checkedSharingOptions, uploadPhase, mode } = this.props;
+    // Only the panel whose upload is in flight needs to freeze its options.
+    // The two modes have independent options, so an upload started from Share
+    // is no reason to stop someone adjusting what they save to disk.
     const isUploading =
-      uploadPhase === 'uploading' || uploadPhase === 'compressing';
+      mode === 'upload' &&
+      (uploadPhase === 'uploading' || uploadPhase === 'compressing');
     return (
       <label className="photon-label publishPanelDataChoicesLabel">
         <input
@@ -123,17 +147,43 @@ class PublishPanelImpl extends React.PureComponent<PublishProps, {}> {
     );
   }
 
-  _onSubmit = () => {
+  _onSubmit = (event: React.FormEvent<HTMLFormElement>) => {
+    // Without this, submitting the form navigates to the current URL and
+    // reloads the whole app. Today that is masked by attemptToPublish
+    // dispatching synchronously, which unmounts the form before the browser
+    // gets to the default action -- don't rely on that.
+    event.preventDefault();
+    if (this.props.mode === 'download') {
+      // The download panel has no submit button; there is nothing to publish.
+      return;
+    }
     this.props.attemptToPublish();
   };
 
+  _renderDownloadButton(primary: boolean) {
+    const {
+      sanitizedProfileEncodingStates,
+      jslbDownloadFileName,
+      jsonDownloadFileName,
+    } = this.props;
+    return (
+      <DownloadSplitButton
+        primary={primary}
+        jslbEncodingState={sanitizedProfileEncodingStates.jslb}
+        jsonEncodingState={sanitizedProfileEncodingStates.json}
+        jslbDownloadFileName={jslbDownloadFileName}
+        jsonDownloadFileName={jsonDownloadFileName}
+        onJsonDropdownOpen={this._onJsonDropdownOpen}
+      />
+    );
+  }
+
   _renderPublishPanel() {
     const {
       shouldShowPreferenceOption,
       profileContainsPrivateBrowsingInformation,
       profileHasJSTracingArgumentValues,
-      sanitizedProfileEncodingState,
-      downloadFileName,
+      sanitizedProfileEncodingStates,
       shouldSanitizeByDefault,
       isRepublish,
       mode,
@@ -166,7 +216,7 @@ class PublishPanelImpl extends React.PureComponent<PublishProps, {}> {
       <div data-testid="PublishPanel-container">
         <form
           className="publishPanelContent photon-body-10"
-          onSubmit={isDownload ? undefined : this._onSubmit}
+          onSubmit={this._onSubmit}
         >
           <h1 className="publishPanelTitle photon-title-30">{title}</h1>
           <p className="publishPanelInfoDescription">
@@ -256,7 +306,7 @@ class PublishPanelImpl extends React.PureComponent<PublishProps, {}> {
                 )
               : null}
           </div>
-          {sanitizedProfileEncodingState.phase === 'ERROR' ? (
+          {sanitizedProfileEncodingStates.jslb.phase === 'ERROR' ? (
             <div className="photon-message-bar photon-message-bar-error photon-message-bar-inner-content">
               <div className="photon-message-bar-inner-text">
                 <Localized id="MenuButtons--publish--error-while-compressing">
@@ -268,26 +318,22 @@ class PublishPanelImpl extends React.PureComponent<PublishProps, {}> {
           ) : null}
           <div className="publishPanelButtons">
             {isDownload ? (
-              <DownloadButton
-                primary
-                downloadFileName={downloadFileName}
-                sanitizedProfileEncodingState={sanitizedProfileEncodingState}
-              />
+              this._renderDownloadButton(true)
             ) : (
               <button
                 type="submit"
                 className="photon-button photon-button-primary publishPanelButton publishPanelButtonsUpload"
-                disabled={sanitizedProfileEncodingState.phase === 'ERROR'}
+                disabled={sanitizedProfileEncodingStates.jslb.phase === 'ERROR'}
               >
                 <span className="publishPanelButtonsSvg publishPanelButtonsSvgUpload" />
                 <Localized id="MenuButtons--publish--button-upload">
                   Upload
                 </Localized>{' '}
-                {sanitizedProfileEncodingState.phase === 'DONE' ? (
+                {sanitizedProfileEncodingStates.jslb.phase === 'DONE' ? (
                   <span className="menuButtonsDownloadSize">
                     (
                     {prettyBytes(
-                      sanitizedProfileEncodingState.profileData.size
+                      sanitizedProfileEncodingStates.jslb.profileData.size
                     )}
                     )
                   </span>
@@ -301,13 +347,7 @@ class PublishPanelImpl extends React.PureComponent<PublishProps, {}> {
   }
 
   _renderUploadPanel() {
-    const {
-      uploadProgress,
-      uploadProgressString,
-      abortFunction,
-      downloadFileName,
-      sanitizedProfileEncodingState,
-    } = this.props;
+    const { uploadProgress, uploadProgressString, abortFunction } = this.props;
 
     return (
       <div
@@ -331,10 +371,7 @@ class PublishPanelImpl extends React.PureComponent<PublishProps, {}> {
           </div>
         </div>
         <div className="publishPanelButtons">
-          <DownloadButton
-            downloadFileName={downloadFileName}
-            sanitizedProfileEncodingState={sanitizedProfileEncodingState}
-          />
+          {this._renderDownloadButton(false)}
           <button
             type="button"
             className="photon-button photon-button-default publishPanelButton publishPanelButtonsCancelUpload"
@@ -424,8 +461,12 @@ export const PublishPanel = explicitConnect<
       getContainsPrivateBrowsingInformation(state),
     profileHasJSTracingArgumentValues: getHasJSTracingArgumentValues(state),
     checkedSharingOptions: getCheckedSharingOptions(state, ownProps.mode),
-    downloadFileName: getFilenameString(state),
-    sanitizedProfileEncodingState: getSanitizedProfileEncodingState(state),
+    jslbDownloadFileName: getDownloadFilename(state, 'jslb'),
+    jsonDownloadFileName: getDownloadFilename(state, 'json'),
+    sanitizedProfileEncodingStates: getSanitizedProfileEncodingStates(
+      state,
+      ownProps.mode
+    ),
     uploadPhase: getUploadPhase(state),
     uploadProgress: getUploadProgress(state),
     uploadProgressString: getUploadProgressString(state),
@@ -442,27 +483,148 @@ export const PublishPanel = explicitConnect<
   component: PublishPanelImpl,
 });
 
-type DownloadButtonProps = {
-  readonly sanitizedProfileEncodingState: SanitizedProfileEncodingState;
+const DOWNLOAD_FORMAT_MENU_ID = 'PublishDownloadFormatContextMenu';
+// react-contextmenu positions the menu with its top-left at `position`. To
+// right-anchor to the toggle button we subtract an estimated menu width; the
+// actual width is pinned to this value via CSS.
+const DOWNLOAD_FORMAT_MENU_WIDTH_PX = 220;
+
+type DownloadSplitButtonProps = {
+  readonly primary: boolean;
+  readonly jslbEncodingState: SanitizedProfileEncodingState;
+  readonly jsonEncodingState: SanitizedProfileEncodingState;
+  readonly jslbDownloadFileName: string;
+  readonly jsonDownloadFileName: string;
+  readonly onJsonDropdownOpen: () => void;
+};
+
+type DownloadSplitButtonState = {
+  readonly isMenuVisible: boolean;
+  // react-contextmenu hides the menu on mousedown even if it's already
+  // visible. We track visibility at mousedown time so that clicking the
+  // toggle button while the menu is open results in a net "close" rather
+  // than a hide-then-reshow.
+  readonly wasMenuVisibleOnMouseDown: boolean;
+};
+
+/**
+ * Split button: the main body downloads the profile as JSLB, and the arrow
+ * on the right opens a dropdown menu with alternate download formats.
+ * The dropdown uses the same react-contextmenu-based menu style as the
+ * marker chart's filter/copy buttons.
+ */
+class DownloadSplitButton extends React.PureComponent<
+  DownloadSplitButtonProps,
+  DownloadSplitButtonState
+> {
+  override state: DownloadSplitButtonState = {
+    isMenuVisible: false,
+    wasMenuVisibleOnMouseDown: false,
+  };
+
+  _onToggleClick = (event: React.MouseEvent<HTMLElement>) => {
+    if (this.state.wasMenuVisibleOnMouseDown) {
+      // The menu was already open on mousedown, so react-contextmenu has
+      // already hidden it. Don't reopen it.
+      return;
+    }
+
+    const rect = event.currentTarget.getBoundingClientRect();
+    // Right-anchor the menu: its top-right sits at the toggle button's
+    // bottom-right, so it grows leftwards into the panel.
+    showMenu({
+      data: null,
+      id: DOWNLOAD_FORMAT_MENU_ID,
+      position: {
+        x: rect.right - DOWNLOAD_FORMAT_MENU_WIDTH_PX,
+        y: rect.bottom,
+      },
+      target: event.target,
+    });
+  };
+
+  _onToggleMouseDown = () => {
+    this.setState((state) => ({
+      wasMenuVisibleOnMouseDown: state.isMenuVisible,
+    }));
+  };
+
+  _onMenuShow = () => {
+    this.setState({ isMenuVisible: true });
+    // Defer the JSON encoding so the menu can paint first. The serializer
+    // is synchronous and can take a while on large profiles; running it on
+    // the current task would delay the menu's first paint.
+    setTimeout(this.props.onJsonDropdownOpen, 0);
+  };
+
+  _onMenuHide = () => {
+    this.setState({ isMenuVisible: false });
+  };
+
+  override render() {
+    const {
+      primary,
+      jslbEncodingState,
+      jsonEncodingState,
+      jslbDownloadFileName,
+      jsonDownloadFileName,
+    } = this.props;
+    const { isMenuVisible } = this.state;
+
+    return (
+      <div className="publishPanelSplitButton">
+        <DownloadPrimary
+          primary={primary}
+          encodingState={jslbEncodingState}
+          downloadFileName={jslbDownloadFileName}
+        />
+        <button
+          type="button"
+          className={classNames(
+            'photon-button',
+            'publishPanelSplitButtonToggleButton',
+            {
+              'publishPanelSplitButtonToggleButton--open': isMenuVisible,
+            }
+          )}
+          title="Other download formats"
+          aria-haspopup="menu"
+          aria-expanded={isMenuVisible}
+          onClick={this._onToggleClick}
+          onMouseDown={this._onToggleMouseDown}
+        />
+        <DownloadFormatContextMenu
+          menuId={DOWNLOAD_FORMAT_MENU_ID}
+          onShow={this._onMenuShow}
+          onHide={this._onMenuHide}
+          jsonEncodingState={jsonEncodingState}
+          jsonDownloadFileName={jsonDownloadFileName}
+        />
+      </div>
+    );
+  }
+}
+
+type DownloadPrimaryProps = {
+  readonly encodingState: SanitizedProfileEncodingState;
   readonly downloadFileName: string;
   readonly primary?: boolean;
 };
 
 /**
- * The DownloadButton handles unpacking the compressed profile promise.
+ * The primary (left) part of the split button. Downloads the profile as JSLB.
  */
-class DownloadButton extends React.PureComponent<DownloadButtonProps, {}> {
+class DownloadPrimary extends React.PureComponent<DownloadPrimaryProps> {
   override render() {
-    const { sanitizedProfileEncodingState, downloadFileName, primary } =
-      this.props;
+    const { encodingState, downloadFileName, primary } = this.props;
     const className = classNames(
-      'photon-button publishPanelButton publishPanelButtonsDownload',
+      'photon-button publishPanelButton publishPanelSplitButtonMain publishPanelButtonsDownload',
       { 'photon-button-primary publishPanelButtonsDownloadPrimary': primary }
     );
 
-    switch (sanitizedProfileEncodingState.phase) {
+    switch (encodingState.phase) {
       case 'DONE': {
-        const { profileData } = sanitizedProfileEncodingState;
+        const { profileData } = encodingState;
         return (
           <BlobUrlLink
             blob={profileData}
@@ -498,7 +660,103 @@ class DownloadButton extends React.PureComponent<DownloadButtonProps, {}> {
         );
       }
       default:
-        throw assertExhaustiveCheck(sanitizedProfileEncodingState);
+        throw assertExhaustiveCheck(encodingState);
+    }
+  }
+}
+
+type DownloadFormatContextMenuProps = {
+  readonly menuId: string;
+  readonly onShow: () => void;
+  readonly onHide: () => void;
+  readonly jsonEncodingState: SanitizedProfileEncodingState;
+  readonly jsonDownloadFileName: string;
+};
+
+/**
+ * Trigger a file download for a Blob without needing a persistent
+ * BlobUrlLink anchor. Used from a react-contextmenu MenuItem's onClick,
+ * where we can't wrap the item in an <a download>.
+ */
+function _triggerBlobDownload(blob: Blob, downloadFileName: string): void {
+  const url = URL.createObjectURL(blob);
+  const anchor = document.createElement('a');
+  anchor.href = url;
+  anchor.download = downloadFileName;
+  anchor.style.display = 'none';
+  document.body.appendChild(anchor);
+  anchor.click();
+  document.body.removeChild(anchor);
+  // Revoke asynchronously so Safari has a chance to start the download.
+  setTimeout(() => URL.revokeObjectURL(url), 5000);
+}
+
+/**
+ * The dropdown menu for alternative download formats, rendered as a
+ * react-contextmenu (the same menu style used next to the marker chart
+ * search field).
+ */
+class DownloadFormatContextMenu extends React.PureComponent<DownloadFormatContextMenuProps> {
+  _onDownloadJson = () => {
+    const { jsonEncodingState, jsonDownloadFileName } = this.props;
+    if (jsonEncodingState.phase !== 'DONE') {
+      return;
+    }
+    _triggerBlobDownload(
+      jsonEncodingState.profileData,
+      `${jsonDownloadFileName}.gz`
+    );
+  };
+
+  _renderJsonMenuItemLabel() {
+    const { jsonEncodingState } = this.props;
+    switch (jsonEncodingState.phase) {
+      case 'DONE':
+        return (
+          <>
+            <Localized id="MenuButtons--publish--download-json">
+              Download as JSON
+            </Localized>
+            {` (${prettyBytes(jsonEncodingState.profileData.size)})`}
+          </>
+        );
+      case 'ERROR':
+        return (
+          <Localized id="MenuButtons--publish--download-json-error">
+            Error preparing JSON download
+          </Localized>
+        );
+      case 'INITIAL':
+      case 'ENCODING':
+        return (
+          <Localized id="MenuButtons--publish--compressing">
+            Compressing…
+          </Localized>
+        );
+      default:
+        throw assertExhaustiveCheck(jsonEncodingState);
     }
   }
+
+  override render() {
+    const { menuId, onShow, onHide, jsonEncodingState } = this.props;
+    const jsonReady = jsonEncodingState.phase === 'DONE';
+
+    return (
+      <ContextMenu
+        id={menuId}
+        className="publishPanelDownloadFormatContextMenu"
+        onShow={onShow}
+        onHide={onHide}
+      >
+        <MenuItem
+          onClick={this._onDownloadJson}
+          disabled={!jsonReady}
+          preventClose={!jsonReady}
+        >
+          {this._renderJsonMenuItemLabel()}
+        </MenuItem>
+      </ContextMenu>
+    );
+  }
 }
diff --git a/src/reducers/publish.ts b/src/reducers/publish.ts
index 896d1e4cc8..9f75892d15 100644
--- a/src/reducers/publish.ts
+++ b/src/reducers/publish.ts
@@ -14,6 +14,7 @@ import type {
   Reducer,
   State,
   SanitizedProfileEncodingState,
+  PublishProfileFormat,
 } from 'firefox-profiler/types';
 
 function _getSanitizingSharingOptions(): CheckedSharingOptions {
@@ -46,8 +47,10 @@ function _getMostlyNonSanitizingSharingOptions(): CheckedSharingOptions {
   };
 }
 
-// Both modes reference the same object until one is edited, so an untouched
-// profile is only encoded once.
+// Both modes start out referencing the same options object. Note that this
+// does not make them share an encoding: the sanitized profile is memoized per
+// mode, and sanitizePII always returns a fresh object, so each mode encodes
+// its own copy. See sanitizedProfileEncodingStates below.
 function _sharingOptionsForBothModes(
   options: CheckedSharingOptions
 ): Record<SharingMode, CheckedSharingOptions> {
@@ -230,32 +233,77 @@ const hasSanitizedProfile: Reducer<boolean> = (state = false, action) => {
   }
 };
 
-const sanitizedProfileEncodingState: Reducer<SanitizedProfileEncodingState> = (
-  state = { phase: 'INITIAL' },
+type FormatEncodingStates = Record<
+  PublishProfileFormat,
+  SanitizedProfileEncodingState
+>;
+type EncodingStates = Record<SharingMode, FormatEncodingStates>;
+
+const INITIAL_FORMAT_ENCODING_STATES: FormatEncodingStates = {
+  jslb: { phase: 'INITIAL' },
+  json: { phase: 'INITIAL' },
+};
+
+const INITIAL_ENCODING_STATES: EncodingStates = {
+  download: INITIAL_FORMAT_ENCODING_STATES,
+  upload: INITIAL_FORMAT_ENCODING_STATES,
+};
+
+function _withEncodingState(
+  state: EncodingStates,
+  mode: SharingMode,
+  format: PublishProfileFormat,
+  encodingState: SanitizedProfileEncodingState
+): EncodingStates {
+  return {
+    ...state,
+    [mode]: { ...state[mode], [format]: encodingState },
+  };
+}
+
+// One slot per (sharing mode, format) pair. Keying by mode keeps each panel's
+// encoding stable across reopens, and guarantees a panel can never be handed a
+// blob that was encoded for the other mode's sharing options.
+const sanitizedProfileEncodingStates: Reducer<EncodingStates> = (
+  state = INITIAL_ENCODING_STATES,
   action
-): SanitizedProfileEncodingState => {
+): EncodingStates => {
   switch (action.type) {
     case 'SANITIZED_PROFILE_ENCODING_STARTED': {
-      const { sanitizedProfile, encodingPromise } = action;
-      return { phase: 'ENCODING', sanitizedProfile, encodingPromise };
+      const { mode, format, sanitizedProfile, encodingPromise } = action;
+      return _withEncodingState(state, mode, format, {
+        phase: 'ENCODING',
+        sanitizedProfile,
+        encodingPromise,
+      });
     }
     case 'SANITIZED_PROFILE_ENCODING_COMPLETED': {
-      const { sanitizedProfile, profileData } = action;
+      const { mode, format, sanitizedProfile, profileData } = action;
+      const current = state[mode][format];
       if (
-        state.phase === 'ENCODING' &&
-        state.sanitizedProfile === sanitizedProfile
+        current.phase === 'ENCODING' &&
+        current.sanitizedProfile === sanitizedProfile
       ) {
-        return { phase: 'DONE', sanitizedProfile, profileData };
+        return _withEncodingState(state, mode, format, {
+          phase: 'DONE',
+          sanitizedProfile,
+          profileData,
+        });
       }
       return state; // Ignore updates from earlier encodings.
     }
     case 'SANITIZED_PROFILE_ENCODING_FAILED': {
-      const { sanitizedProfile, error } = action;
+      const { mode, format, sanitizedProfile, error } = action;
+      const current = state[mode][format];
       if (
-        state.phase === 'ENCODING' &&
-        state.sanitizedProfile === sanitizedProfile
+        current.phase === 'ENCODING' &&
+        current.sanitizedProfile === sanitizedProfile
       ) {
-        return { phase: 'ERROR', sanitizedProfile, error };
+        return _withEncodingState(state, mode, format, {
+          phase: 'ERROR',
+          sanitizedProfile,
+          error,
+        });
       }
       return state; // Ignore updates from earlier encodings.
     }
@@ -266,7 +314,7 @@ const sanitizedProfileEncodingState: Reducer<SanitizedProfileEncodingState> = (
 
 const publishReducer: Reducer<PublishState> = combineReducers({
   checkedSharingOptions,
-  sanitizedProfileEncodingState,
+  sanitizedProfileEncodingStates,
   upload,
   isHidingStaleProfile,
   hasSanitizedProfile,
diff --git a/src/selectors/publish.ts b/src/selectors/publish.ts
index fe3d1aa103..ac896ebcfb 100644
--- a/src/selectors/publish.ts
+++ b/src/selectors/publish.ts
@@ -40,6 +40,7 @@ import type {
   ThreadIndex,
   CounterIndex,
   SanitizedProfileEncodingState,
+  PublishProfileFormat,
 } from 'firefox-profiler/types';
 import { getThreadSelectors } from './per-thread';
 
@@ -50,7 +51,7 @@ export const getCheckedSharingOptions: DangerousSelectorWithArguments<
   SharingMode
 > = (state, mode) => getPublishState(state).checkedSharingOptions[mode];
 
-export const getFilenameString: Selector<string> = createSelector(
+const getFilenameStem: Selector<string> = createSelector(
   getProfile,
   getProfileRootRange,
   (profile, rootRange) => {
@@ -68,11 +69,17 @@ export const getFilenameString: Selector<string> = createSelector(
     const min = pad(date.getMinutes());
     const dateString = `${year}-${month}-${day} ${hour}.${min}`;
 
-    // Return the final file name
-    return `${product} ${dateString} profile.json`;
+    return `${product} ${dateString} profile`;
   }
 );
 
+export function getDownloadFilename(
+  state: State,
+  format: PublishProfileFormat
+): string {
+  return `${getFilenameStem(state)}.${format}`;
+}
+
 const _makeGetRemoveProfileInformation = (mode: SharingMode) =>
   createSelector(
     (state: State) => getCheckedSharingOptions(state, mode),
@@ -275,9 +282,19 @@ export const getSanitizedProfile: DangerousSelectorWithArguments<
   SharingMode
 > = (state, mode) => _sanitizedProfileSelectors[mode](state);
 
-export const getSanitizedProfileEncodingState: Selector<
-  SanitizedProfileEncodingState
-> = (state) => getPublishState(state).sanitizedProfileEncodingState;
+export const getSanitizedProfileEncodingStates: DangerousSelectorWithArguments<
+  Record<PublishProfileFormat, SanitizedProfileEncodingState>,
+  SharingMode
+> = (state, mode) =>
+  getPublishState(state).sanitizedProfileEncodingStates[mode];
+
+export function getSanitizedProfileEncodingState(
+  state: State,
+  mode: SharingMode,
+  format: PublishProfileFormat
+): SanitizedProfileEncodingState {
+  return getSanitizedProfileEncodingStates(state, mode)[format];
+}
 
 export const getUploadState: Selector<UploadState> = (state) =>
   getPublishState(state).upload;
diff --git a/src/test/components/MenuButtons.test.tsx b/src/test/components/MenuButtons.test.tsx
index 44c649483a..659852439e 100644
--- a/src/test/components/MenuButtons.test.tsx
+++ b/src/test/components/MenuButtons.test.tsx
@@ -519,17 +519,18 @@ describe('app/MenuButtons', function () {
       expect(getPanel()).toMatchSnapshot();
     });
 
-    it('keeps Download available but locks the options while uploading', async () => {
+    it('keeps Download available and editable while uploading', async () => {
       const { openPublishPanel, getPanelForm, openDownloadPanel } =
         setupForPublish();
       await openPublishPanel();
       fireEvent.submit(getPanelForm());
 
-      // The Download button stays in the toolbar while the upload is running.
+      // The Download button stays in the toolbar while the upload is running,
+      // and its options stay editable: they are independent of the upload's.
       await openDownloadPanel();
       expect(
         screen.getByRole('checkbox', { name: /Include hidden threads/ })
-      ).toBeDisabled();
+      ).toBeEnabled();
     });
   });
 
diff --git a/src/test/components/__snapshots__/MenuButtons.test.tsx.snap b/src/test/components/__snapshots__/MenuButtons.test.tsx.snap
index cfddb3ad72..63dfb0a8dd 100644
--- a/src/test/components/__snapshots__/MenuButtons.test.tsx.snap
+++ b/src/test/components/__snapshots__/MenuButtons.test.tsx.snap
@@ -2217,24 +2217,52 @@ exports[`app/MenuButtons <Publish> matches the snapshot for the menu buttons and
     <div
       class="publishPanelButtons"
     >
-      <a
-        class="photon-button publishPanelButton publishPanelButtonsDownload photon-button-primary publishPanelButtonsDownloadPrimary"
-        download="Firefox 1970-01-01 00.00 profile.json.gz"
-        href="mockCreateObjectUrl"
+      <div
+        class="publishPanelSplitButton"
       >
-        <span
-          class="publishPanelButtonsSvg publishPanelButtonsSvgDownload"
-        />
-        Download
-         
-        <span
-          class="menuButtonsDownloadSize"
+        <a
+          class="photon-button publishPanelButton publishPanelSplitButtonMain publishPanelButtonsDownload photon-button-primary publishPanelButtonsDownloadPrimary"
+          download="Firefox 1970-01-01 00.00 profile.jslb.gz"
+          href="mockCreateObjectUrl"
         >
-          (
-          1.58 kB
-          )
-        </span>
-      </a>
+          <span
+            class="publishPanelButtonsSvg publishPanelButtonsSvgDownload"
+          />
+          Download
+           
+          <span
+            class="menuButtonsDownloadSize"
+          >
+            (
+            1.58 kB
+            )
+          </span>
+        </a>
+        <button
+          aria-expanded="false"
+          aria-haspopup="menu"
+          class="photon-button publishPanelSplitButtonToggleButton"
+          title="Other download formats"
+          type="button"
+        />
+        <div>
+          <nav
+            class="react-contextmenu publishPanelDownloadFormatContextMenu"
+            role="menu"
+            style="position: fixed; opacity: 0; pointer-events: none;"
+            tabindex="-1"
+          >
+            <div
+              aria-disabled="true"
+              class="react-contextmenu-item react-contextmenu-item--disabled"
+              role="menuitem"
+              tabindex="-1"
+            >
+              Compressing…
+            </div>
+          </nav>
+        </div>
+      </div>
     </div>
   </form>
 </div>
@@ -2336,24 +2364,52 @@ exports[`app/MenuButtons <Publish> matches the snapshot for the opened panel for
     <div
       class="publishPanelButtons"
     >
-      <a
-        class="photon-button publishPanelButton publishPanelButtonsDownload photon-button-primary publishPanelButtonsDownloadPrimary"
-        download="Firefox 1970-01-01 00.00 profile.json.gz"
-        href="mockCreateObjectUrl"
+      <div
+        class="publishPanelSplitButton"
       >
-        <span
-          class="publishPanelButtonsSvg publishPanelButtonsSvgDownload"
-        />
-        Download
-         
-        <span
-          class="menuButtonsDownloadSize"
+        <a
+          class="photon-button publishPanelButton publishPanelSplitButtonMain publishPanelButtonsDownload photon-button-primary publishPanelButtonsDownloadPrimary"
+          download="Firefox 1970-01-01 00.00 profile.jslb.gz"
+          href="mockCreateObjectUrl"
         >
-          (
-          1.58 kB
-          )
-        </span>
-      </a>
+          <span
+            class="publishPanelButtonsSvg publishPanelButtonsSvgDownload"
+          />
+          Download
+           
+          <span
+            class="menuButtonsDownloadSize"
+          >
+            (
+            1.58 kB
+            )
+          </span>
+        </a>
+        <button
+          aria-expanded="false"
+          aria-haspopup="menu"
+          class="photon-button publishPanelSplitButtonToggleButton"
+          title="Other download formats"
+          type="button"
+        />
+        <div>
+          <nav
+            class="react-contextmenu publishPanelDownloadFormatContextMenu"
+            role="menu"
+            style="position: fixed; opacity: 0; pointer-events: none;"
+            tabindex="-1"
+          >
+            <div
+              aria-disabled="true"
+              class="react-contextmenu-item react-contextmenu-item--disabled"
+              role="menuitem"
+              tabindex="-1"
+            >
+              Compressing…
+            </div>
+          </nav>
+        </div>
+      </div>
     </div>
   </form>
 </div>
@@ -2450,24 +2506,52 @@ exports[`app/MenuButtons <Publish> matches the snapshot for the opened panel for
     <div
       class="publishPanelButtons"
     >
-      <a
-        class="photon-button publishPanelButton publishPanelButtonsDownload photon-button-primary publishPanelButtonsDownloadPrimary"
-        download="Firefox 1970-01-01 00.00 profile.json.gz"
-        href="mockCreateObjectUrl"
+      <div
+        class="publishPanelSplitButton"
       >
-        <span
-          class="publishPanelButtonsSvg publishPanelButtonsSvgDownload"
-        />
-        Download
-         
-        <span
-          class="menuButtonsDownloadSize"
+        <a
+          class="photon-button publishPanelButton publishPanelSplitButtonMain publishPanelButtonsDownload photon-button-primary publishPanelButtonsDownloadPrimary"
+          download="Firefox 1970-01-01 00.00 profile.jslb.gz"
+          href="mockCreateObjectUrl"
         >
-          (
-          1.58 kB
-          )
-        </span>
-      </a>
+          <span
+            class="publishPanelButtonsSvg publishPanelButtonsSvgDownload"
+          />
+          Download
+           
+          <span
+            class="menuButtonsDownloadSize"
+          >
+            (
+            1.58 kB
+            )
+          </span>
+        </a>
+        <button
+          aria-expanded="false"
+          aria-haspopup="menu"
+          class="photon-button publishPanelSplitButtonToggleButton"
+          title="Other download formats"
+          type="button"
+        />
+        <div>
+          <nav
+            class="react-contextmenu publishPanelDownloadFormatContextMenu"
+            role="menu"
+            style="position: fixed; opacity: 0; pointer-events: none;"
+            tabindex="-1"
+          >
+            <div
+              aria-disabled="true"
+              class="react-contextmenu-item react-contextmenu-item--disabled"
+              role="menuitem"
+              tabindex="-1"
+            >
+              Compressing…
+            </div>
+          </nav>
+        </div>
+      </div>
     </div>
   </form>
 </div>
diff --git a/src/test/store/publish.test.ts b/src/test/store/publish.test.ts
index a38d10b558..90ebaaaab4 100644
--- a/src/test/store/publish.test.ts
+++ b/src/test/store/publish.test.ts
@@ -23,6 +23,7 @@ import {
   getUploadProgress,
   getUploadProgressString,
   getUploadGeneration,
+  getSanitizedProfileEncodingState,
 } from '../../selectors/publish';
 import {
   getUrlState,
@@ -68,7 +69,7 @@ import {
   listAllUploadedProfileInformationFromDb,
 } from 'firefox-profiler/app-logic/uploaded-profiles-db';
 
-import type { Store, UploadPhase } from 'firefox-profiler/types';
+import type { Store, UploadPhase, SharingMode } from 'firefox-profiler/types';
 
 import { autoMockIndexedDB } from 'firefox-profiler/test/fixtures/mocks/indexeddb';
 autoMockIndexedDB();
@@ -186,11 +187,73 @@ describe('encodeSanitizedProfile', function () {
     const { profile } = getProfileFromTextSamples('A');
     const { dispatch } = storeWithProfile(profile);
 
-    const first = dispatch(encodeSanitizedProfile('upload'));
-    const second = dispatch(encodeSanitizedProfile('upload'));
+    const first = dispatch(encodeSanitizedProfile('upload', 'jslb'));
+    const second = dispatch(encodeSanitizedProfile('upload', 'jslb'));
 
-    expect(second.encodingPromise).toBe(first.encodingPromise);
-    await first.encodingPromise;
+    expect(second).toBe(first);
+    await first;
+  });
+
+  it('keeps a separate encoding per mode, so alternating panel opens each reuse their own', async function () {
+    const { profile } = getProfileFromTextSamples('A');
+    const { dispatch } = storeWithProfile(profile);
+
+    // The two modes sanitize to different profiles, so they each need their own
+    // encoding...
+    const download = dispatch(encodeSanitizedProfile('download', 'jslb'));
+    const upload = dispatch(encodeSanitizedProfile('upload', 'jslb'));
+    expect(upload).not.toBe(download);
+
+    // ...but reopening a panel must not start a third and fourth encoding.
+    expect(dispatch(encodeSanitizedProfile('download', 'jslb'))).toBe(download);
+    expect(dispatch(encodeSanitizedProfile('upload', 'jslb'))).toBe(upload);
+
+    await Promise.all([download, upload]);
+  });
+
+  it('never exposes a mode the blob that was encoded for the other mode', async function () {
+    const { profile } = getProfileFromTextSamples('A');
+    profile.pages = [
+      {
+        tabID: 1,
+        innerWindowID: 1,
+        url: 'https://example.com/private-page',
+        embedderInnerWindowID: 0,
+      },
+    ];
+    const { dispatch, getState } = storeWithProfile(profile);
+
+    // Opt into URLs for uploading only, and let that encoding finish.
+    dispatch(updateSharingOption('upload', 'includeUrls', true));
+    await dispatch(encodeSanitizedProfile('upload', 'jslb'));
+    expect(
+      getSanitizedProfileEncodingState(getState(), 'upload', 'jslb').phase
+    ).toBe('DONE');
+
+    // The download panel, whose options still strip URLs, must not see it.
+    const forDownload = getSanitizedProfileEncodingState(
+      getState(),
+      'download',
+      'jslb'
+    );
+    expect(forDownload.phase).toBe('INITIAL');
+
+    // And once download has encoded too, each mode keeps its own blob.
+    await dispatch(encodeSanitizedProfile('download', 'jslb'));
+    const encodedBlob = (mode: SharingMode) => {
+      const encodingState = getSanitizedProfileEncodingState(
+        getState(),
+        mode,
+        'jslb'
+      );
+      if (encodingState.phase !== 'DONE') {
+        throw new Error(
+          `Expected the ${mode} encoding to be DONE, but it is ${encodingState.phase}.`
+        );
+      }
+      return encodingState.profileData;
+    };
+    expect(encodedBlob('download')).not.toBe(encodedBlob('upload'));
   });
 });
 
diff --git a/src/types/actions.ts b/src/types/actions.ts
index 888a3b05a9..3cfb38fd95 100644
--- a/src/types/actions.ts
+++ b/src/types/actions.ts
@@ -46,6 +46,7 @@ import type {
   TableViewOptions,
   DecodedInstruction,
   ProfileEncodingResult,
+  PublishProfileFormat,
 } from './state';
 import type { CssPixels, StartEndRange, Milliseconds } from './units';
 import type { BrowserConnectionStatus } from '../app-logic/browser-connection';
@@ -656,16 +657,22 @@ type PublishAction =
     }
   | {
       readonly type: 'SANITIZED_PROFILE_ENCODING_STARTED';
+      readonly mode: SharingMode;
+      readonly format: PublishProfileFormat;
       readonly sanitizedProfile: Profile;
       readonly encodingPromise: Promise<ProfileEncodingResult>;
     }
   | {
       readonly type: 'SANITIZED_PROFILE_ENCODING_COMPLETED';
+      readonly mode: SharingMode;
+      readonly format: PublishProfileFormat;
       readonly sanitizedProfile: Profile;
       readonly profileData: Blob;
     }
   | {
       readonly type: 'SANITIZED_PROFILE_ENCODING_FAILED';
+      readonly mode: SharingMode;
+      readonly format: PublishProfileFormat;
       readonly sanitizedProfile: Profile;
       readonly error: Error;
     }
diff --git a/src/types/state.ts b/src/types/state.ts
index 5583e72181..0f4d1faf1d 100644
--- a/src/types/state.ts
+++ b/src/types/state.ts
@@ -237,9 +237,22 @@ export type SanitizedProfileEncodingState =
     }
   | { phase: 'ERROR'; sanitizedProfile: Profile; error: Error };
 
+// The upload path always uses 'jslb'; 'json' is only used for the "Download
+// as JSON" option in the publish panel's split download button.
+export type PublishProfileFormat = 'jslb' | 'json';
+
 export type PublishState = {
   readonly checkedSharingOptions: Record<SharingMode, CheckedSharingOptions>;
-  readonly sanitizedProfileEncodingState: SanitizedProfileEncodingState;
+  // One encoding slot per (sharing mode, format) pair. The two modes have
+  // independent sharing options, so they sanitize to different profiles and
+  // must not share a slot: otherwise each mode's encoding clobbers the
+  // other's, and a panel could offer a blob that was encoded for the *other*
+  // mode's options. The formats are independent for the same reason: each is
+  // a separate serialization, offered by a different control.
+  readonly sanitizedProfileEncodingStates: Record<
+    SharingMode,
+    Record<PublishProfileFormat, SanitizedProfileEncodingState>
+  >;
   readonly upload: UploadState;
   readonly isHidingStaleProfile: boolean;
   readonly hasSanitizedProfile: boolean;