diff --git a/contentcuration/contentcuration/frontend/channelEdit/components/sidePanels/PublishSidePanel.vue b/contentcuration/contentcuration/frontend/channelEdit/components/sidePanels/PublishSidePanel.vue
index 403cdebdac..f16745cd5e 100644
--- a/contentcuration/contentcuration/frontend/channelEdit/components/sidePanels/PublishSidePanel.vue
+++ b/contentcuration/contentcuration/frontend/channelEdit/components/sidePanels/PublishSidePanel.vue
@@ -8,7 +8,7 @@
       @closePanel="onClose"
     >
       <template #header>
-        <h1 class="side-panel-title">{{ getPanelTitle() }}</h1>
+        <h1 class="side-panel-title">{{ publishChannel$() }}</h1>
       </template>
 
       <template #default>
@@ -49,28 +49,29 @@
                   <div class="form-section">
                     <KTextbox
                       v-model="version_notes"
+                      showInvalidText
                       :label="versionDescriptionLabel$()"
-                      :invalid="version_notes.length === 0"
-                      :invalidText="'Version notes are required'"
-                      :showInvalidText="showVersionNotesInvalidText"
+                      :invalid="isVersionNotesBlurred && !isVersionNotesValid"
+                      :invalidText="versionNotesRequiredMessage$()"
                       textArea
                       :maxlength="250"
                       :appearanceOverrides="{ maxWidth: 'none' }"
-                      @blur="onVersionNotesBlur"
+                      @blur="isVersionNotesBlurred = true"
                     />
                   </div>
                   <!-- Language selector -->
+                  <KCircularLoader v-if="isChannelLanguageLoading" />
                   <div
-                    v-if="showLanguageDropdown"
+                    v-else-if="showLanguageDropdown"
                     class="form-section"
                   >
                     <KSelect
-                      v-model="language"
+                      v-model="newChannelLanguage"
                       :label="languageLabel$()"
-                      :invalid="showLanguageInvalidText"
+                      :invalid="isLanguageSelectBlurred && !isNewLanguageValid"
                       :invalidText="languageRequiredMessage$()"
-                      :options="languages"
-                      @change="onLanguageChange"
+                      :options="languageOptions"
+                      @blur="isLanguageSelectBlurred = true"
                     />
                   </div>
                 </div>
@@ -152,7 +153,7 @@
 
 <script>
 
-  import { ref, computed, getCurrentInstance, onMounted } from 'vue';
+  import { ref, computed, getCurrentInstance } from 'vue';
   import SidePanelModal from 'shared/views/SidePanelModal';
   import { Channel, CommunityLibrarySubmission } from 'shared/data/resources';
   import { forceServerSync } from 'shared/data/serverSync';
@@ -173,12 +174,14 @@
 
       const mode = ref(PublishModes.LIVE);
       const version_notes = ref('');
+      const newChannelLanguage = ref({});
+      const languageOptions = ref(null);
+
+      const isChannelLanguageLoading = ref(false);
       const submitting = ref(false);
-      const language = ref({});
-      const showLanguageInvalidText = ref(false);
-      const showVersionNotesInvalidText = ref(false); // lazy validation
-      const channelLanguages = ref([]);
-      const channelLanguageExists = ref(true);
+      const isVersionNotesBlurred = ref(false);
+      const isLanguageSelectBlurred = ref(false);
+      const isCurrentChannelLanguageValid = ref(false);
 
       const instance = getCurrentInstance();
       const store = instance.proxy.$store;
@@ -205,6 +208,7 @@
         cancelAction$,
         languageLabel$,
         languageRequiredMessage$,
+        versionNotesRequiredMessage$,
       } = communityChannelsStrings;
 
       const currentChannel = computed(() => store.getters['currentChannel/currentChannel']);
@@ -223,24 +227,17 @@
         const isCheffedChannel = Boolean(currentChannel.value.ricecooker_version);
         const isPrivateChannel = currentChannel.value.public === false;
         const isFirstPublish = currentChannel.value.version === 0;
-        const channelLanguageExists = currentChannel.value.language;
-
-        return ((isCheffedChannel || isPrivateChannel) && isFirstPublish) || !channelLanguageExists;
-      });
-
-      const languages = computed(() => {
-        if (!currentChannel.value) return [];
-        return filterLanguages(l => channelLanguages.value.includes(l.id));
-      });
 
-      const defaultLanguage = computed(() => {
-        if (!currentChannel.value?.language) return {};
-        const channelLang = filterLanguages(l => l.id === currentChannel.value.language)[0];
-        return languages.value.some(lang => lang.value === channelLang?.value) ? channelLang : {};
+        if (isFirstPublish) {
+          return isCheffedChannel || isPrivateChannel;
+        }
+        return !isCurrentChannelLanguageValid.value;
       });
 
-      const isLanguageValid = computed(() => {
-        return Object.keys(language.value).length > 0;
+      const isNewLanguageValid = computed(() => {
+        // If language selector is not shown do not prevent submission
+        if (!showLanguageDropdown.value) return true;
+        return Object.keys(newChannelLanguage.value).length > 0;
       });
 
       const isVersionNotesValid = computed(() => {
@@ -250,9 +247,7 @@
       // Validate the version and language for live mode
       const isFormValid = computed(() => {
         if (mode.value === PublishModes.LIVE) {
-          const versionNotesValid = isVersionNotesValid.value;
-          const languageValid = showLanguageDropdown.value ? isLanguageValid.value : true;
-          return versionNotesValid && languageValid;
+          return isVersionNotesValid.value && isNewLanguageValid.value;
         }
         return true;
       });
@@ -261,48 +256,92 @@
         return mode.value === PublishModes.DRAFT ? saveDraft$() : publishAction$();
       });
 
-      const filterLanguages = filterFn => {
-        return LanguagesList.filter(filterFn).map(l => ({
+      const getLanguagesOptions = languages => {
+        return mapLanguagesOptions(LanguagesList.filter(lang => languages.includes(lang.id)));
+      };
+      const mapLanguagesOptions = languages => {
+        return languages.map(l => ({
           value: l.id,
           label: l.native_name,
         }));
       };
 
-      // Validate the selected language when it changes
-      const validateSelectedLanguage = () => {
-        if (Object.keys(language.value).length > 0 && languages.value.length > 0) {
-          const isValidLanguage = languages.value.some(lang => lang.value === language.value.value);
-          if (!isValidLanguage) {
-            language.value = {};
+      /**
+       * Makes sure that the channel.language is consistent with the channel resources languages
+       * If not, show the language selector for the user to select a valid language for the channel
+       */
+      const _auditChannelLanguage = async () => {
+        if (!currentChannel.value) {
+          return;
+        }
+
+        const currentChannelLanguage = currentChannel.value.language;
+        // If the current `channel.language` exists among its resources languages,
+        // the channel language is valid
+        isCurrentChannelLanguageValid.value = await channelLanguageExistsInResources();
+        const channelLanguageOption = getLanguagesOptions([currentChannelLanguage])[0];
+
+        if (!isCurrentChannelLanguageValid.value || !channelLanguageOption) {
+          // If not valid, or it doesn't exist in our LanguagesList, load resources languages
+          const resourcesLanguages = await getLanguagesInChannelResources();
+          if (resourcesLanguages.length > 0) {
+            languageOptions.value = getLanguagesOptions(resourcesLanguages);
+            return;
           }
         }
+
+        // if not found in LanguagesList and no resources languages found, set the whole
+        // LanguagesList as options
+        if (!channelLanguageOption) {
+          languageOptions.value = mapLanguagesOptions(LanguagesList);
+          return;
+        }
+        // In any other case, just set the channel language as the only option
+        languageOptions.value = [channelLanguageOption];
+        newChannelLanguage.value = channelLanguageOption;
       };
 
-      onMounted(async () => {
-        if (currentChannel.value) {
-          const exists = await channelLanguageExistsInResources();
-          channelLanguageExists.value = exists;
+      const auditChannelLanguage = async () => {
+        isChannelLanguageLoading.value = true;
+        await _auditChannelLanguage();
+        isChannelLanguageLoading.value = false;
+      };
 
-          if (!exists) {
-            const languages = await getLanguagesInChannelResources();
-            channelLanguages.value = languages.length ? languages : [currentChannel.value.language];
-            language.value = defaultLanguage.value;
-            validateSelectedLanguage();
-          } else {
-            channelLanguages.value = [currentChannel.value.language];
-            language.value = defaultLanguage.value;
-            validateSelectedLanguage();
-          }
-        }
-      });
+      auditChannelLanguage();
 
       const onClose = () => {
         if (!submitting.value) emit('close');
       };
 
+      const checkResubmitToCommunityLibrary = async () => {
+        if (mode.value !== PublishModes.LIVE) {
+          return;
+        }
+
+        try {
+          const response = await CommunityLibrarySubmission.fetchCollection({
+            channel: currentChannel.value.id,
+            max_results: 1,
+          });
+
+          const submissions = response?.results || [];
+
+          if (submissions.length > 0) {
+            const latestSubmission = submissions[0];
+            emit('showResubmitCommunityLibraryModal', {
+              channel: { ...currentChannel.value },
+              latestSubmissionVersion: latestSubmission.channel_version,
+            });
+          }
+        } catch (error) {
+          // Log the error but do not block the publish flow
+          logging.error(error);
+        }
+      };
+
       const submit = async () => {
-        // Validate form before submission
-        if (!validate()) {
+        // Should not get here if the form is invalid, but just in case
+        if (!isFormValid.value) {
           return;
         }
 
@@ -318,92 +357,50 @@
             await Channel.publishDraft(currentChannel.value.id, { use_staging_tree: false });
             emit('close');
           } else {
-            if (
-              language.value &&
-              language.value.value &&
-              language.value.value !== currentChannel.value?.language
-            ) {
+            // `newChannelLanguage.value` is a KSelect option { value, label }, so we need to
+            // extract its `value` to get the language code
+            if (newChannelLanguage.value.value !== currentChannel.value.language) {
               await store.dispatch('channel/updateChannel', {
                 id: currentChannel.value.id,
-                language: language.value.value,
+                language: newChannelLanguage.value.value,
               });
             }
 
             await Channel.publish(currentChannel.value.id, version_notes.value);
 
-            if (mode.value === PublishModes.LIVE) {
-              try {
-                const response = await CommunityLibrarySubmission.fetchCollection({
-                  channel: currentChannel.value.id,
-                  max_results: 1,
-                });
-
-                const submissions = response?.results || [];
-
-                if (submissions.length > 0) {
-                  const latestSubmission = submissions[0];
-                  emit('showResubmitCommunityLibraryModal', {
-                    channel: { ...currentChannel.value },
-                    latestSubmissionVersion: latestSubmission.channel_version,
-                  });
-                }
-              } catch (error) {
-                logging.error(error);
-              }
-            }
+            await checkResubmitToCommunityLibrary();
 
             emit('close');
           }
         } catch (error) {
-          store.dispatch('shared/handleAxiosError', error);
+          store.dispatch('errors/handleAxiosError', error);
         } finally {
           submitting.value = false;
         }
       };
 
-      const getPanelTitle = () => {
-        return publishChannel$();
-      };
-
-      const onLanguageChange = () => {
-        showLanguageInvalidText.value = !isLanguageValid.value;
-        validateSelectedLanguage(); // Ensure language is always valid
-      };
-
-      const onVersionNotesBlur = () => {
-        showVersionNotesInvalidText.value = !isVersionNotesValid.value;
-      };
-
-      const validate = () => {
-        if (mode.value === PublishModes.DRAFT) {
-          // For draft mode, no validation is required
-          return true;
-        } else {
-          // For live mode, validate version notes and language
-          showVersionNotesInvalidText.value = !isVersionNotesValid.value;
-          showLanguageInvalidText.value = !isLanguageValid.value;
-          return !showVersionNotesInvalidText.value && !showLanguageInvalidText.value;
-        }
-      };
-
       return {
+        isChannelLanguageLoading,
         PublishModes,
         mode,
         version_notes,
         submitting,
-        language,
-        showLanguageInvalidText,
-        showVersionNotesInvalidText,
+        languageOptions,
+        newChannelLanguage,
+        isVersionNotesBlurred,
+        isLanguageSelectBlurred,
 
         currentChannel,
         incompleteResourcesCount,
         showLanguageDropdown,
-        languages,
         isFormValid,
+        isNewLanguageValid,
+        isVersionNotesValid,
         submitText,
 
         modeLive$,
         modeDraft$,
+        publishChannel$,
         versionNotesLabel$,
         modeLiveDescription$,
         modeDraftDescription$,
@@ -415,12 +412,10 @@
         cancelAction$,
         languageLabel$,
         languageRequiredMessage$,
+        versionNotesRequiredMessage$,
 
         onClose,
         submit,
-        getPanelTitle,
-        onLanguageChange,
-        onVersionNotesBlur,
       };
     },
 
diff --git a/contentcuration/contentcuration/frontend/channelEdit/components/sidePanels/__tests__/PublishSidePanel.spec.js b/contentcuration/contentcuration/frontend/channelEdit/components/sidePanels/__tests__/PublishSidePanel.spec.js
new file mode 100644
index 0000000000..0d95fff1ea
--- /dev/null
+++ b/contentcuration/contentcuration/frontend/channelEdit/components/sidePanels/__tests__/PublishSidePanel.spec.js
@@ -0,0 +1,394 @@
+import { render, fireEvent, waitFor, screen } from '@testing-library/vue';
+import { createLocalVue } from '@vue/test-utils';
+import Vuex from 'vuex';
+import VueRouter from 'vue-router';
+import KThemePlugin from 'kolibri-design-system/lib/KThemePlugin';
+import { factory } from '../../../store';
+import PublishSidePanel from '../PublishSidePanel.vue';
+import { Channel, CommunityLibrarySubmission } from 'shared/data/resources';
+import { forceServerSync } from 'shared/data/serverSync';
+import { communityChannelsStrings } from 'shared/strings/communityChannelsStrings';
+
+const localVue = createLocalVue();
+localVue.use(Vuex);
+localVue.use(VueRouter);
+localVue.use(KThemePlugin);
+
+jest.mock('shared/data/resources', () => ({
+  Channel: jest.fn(),
+  CommunityLibrarySubmission: jest.fn(),
+}));
+
+jest.mock('shared/data/serverSync', () => ({
+  forceServerSync: jest.fn(),
+}));
+
+jest.mock('shared/logging', () => ({
+  error: jest.fn(),
+}));
+
+let store;
+const renderComponent = (props = {}) => {
+  const currentChannel = {
+    id: 'channel-id',
+    version: 1,
+    language: 'en',
+    public: false,
+    ricecooker_version: null,
+    root_id: 'root-id',
+    ...props.currentChannel,
+  };
+  const rootNode = {
+    id: 'root-id',
+    error_count: props.errorCount || 0,
+  };
+
+  // Set up vuex store state
+  window.CHANNEL_EDIT_GLOBAL.channel_id = currentChannel.id;
+
+  store = factory();
+
+  store.commit('channel/ADD_CHANNEL', currentChannel);
+  store.commit('contentNode/ADD_CONTENTNODE', rootNode);
+  store.commit('SET_UNSAVED_CHANGES', props.areAllChangesSaved === false);
+
+  const router = new VueRouter();
+
+  return render(PublishSidePanel, {
+    localVue,
+    store,
+    router,
+  });
+};
+
+describe('PublishSidePanel', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    // Default mocks
+    Channel.publish = jest.fn();
+    Channel.publishDraft = jest.fn();
+    Channel.update = jest.fn();
+    Channel.languageExistsInResources = jest.fn(() => true);
+    Channel.languagesInResources = jest.fn(() => []);
+    CommunityLibrarySubmission.fetchCollection = jest.fn();
+    forceServerSync.mockResolvedValue({});
+  });
+
+  it('renders correctly in default LIVE mode', async () => {
+    renderComponent();
+
+    // Headers and default texts
+    expect(screen.getByText(communityChannelsStrings.publishChannel$())).toBeVisible();
+    expect(screen.getByText(communityChannelsStrings.modeLive$())).toBeVisible();
+
+    expect(
+      screen.getByText(communityChannelsStrings.publishingInfo$({ version: 2 })),
+    ).toBeVisible();
+
+    // Default button text
+    expect(screen.getByText(communityChannelsStrings.publishAction$())).toBeVisible();
+
+    // Live mode selected by default
+    const liveRadio = screen.getByRole('radio', { name: /Live/ });
+    expect(liveRadio).toBeChecked();
+  });
+
+  it('validates version notes in LIVE mode', async () => {
+    renderComponent();
+
+    const publishBtn = screen.getByText(communityChannelsStrings.publishAction$());
+
+    const notesInput = screen.getByLabelText(communityChannelsStrings.versionDescriptionLabel$());
+
+    // Initially button disabled because notes empty
+    expect(publishBtn).toBeDisabled();
+
+    // Touch field to trigger validation visible
+    await fireEvent.blur(notesInput);
+    expect(screen.getByText('Version notes are required')).toBeVisible();
+
+    // Type notes
+    await fireEvent.update(notesInput, 'My version notes');
+    await fireEvent.blur(notesInput);
+
+    // Validation error should disappear
+    await waitFor(() =>
+      expect(screen.queryByText('Version notes are required')).not.toBeInTheDocument(),
+    );
+    await waitFor(() => expect(publishBtn).toBeEnabled());
+  });
+
+  describe('Language dropdown', () => {
+    it('shows language dropdown and validates language when conditions met (Live Mode)', async () => {
+      // Condition: resources have different languages, or not set
+      Channel.languageExistsInResources.mockResolvedValue(false);
+      Channel.languagesInResources.mockResolvedValue(['de']);
+
+      renderComponent({
+        currentChannel: { language: 'en' }, // Channel is en, but resource is de
+      });
+
+      // Wait for onMounted actions
+      await waitFor(() => expect(Channel.languageExistsInResources).toHaveBeenCalled());
+      await waitFor(() => expect(Channel.languagesInResources).toHaveBeenCalled());
+
+      // Check dropdown visibility via label (found as text since KSelect uses div)
+      expect(screen.getByText(communityChannelsStrings.languageLabel$())).toBeVisible();
+
+      // Load 'Deutsch' text presence in the DOM (it might be hidden in dropdown)
+      await waitFor(() => expect(screen.getAllByText(/Deutsch/i).length).toBeGreaterThan(0));
+
+      // Check validation of publish button
+      const publishBtn = screen.getByText(communityChannelsStrings.publishAction$());
+      expect(publishBtn).toBeDisabled();
+
+      // Select Deutsch
+      // Use getAllByText and take first or iterate? Just click one.
+      await fireEvent.click(screen.getAllByText(/Deutsch/i)[0]);
+
+      // Add notes logic (required for Live)
+      const notesInput = screen.getByLabelText(communityChannelsStrings.versionDescriptionLabel$());
+      await fireEvent.update(notesInput, 'Notes');
+
+      await waitFor(() => expect(publishBtn).toBeEnabled());
+    });
+
+    it('shows language dropdown if first time publishing a private channel, even if channel language exists in resources', async () => {
+      Channel.languageExistsInResources.mockResolvedValue(true);
+      renderComponent({
+        currentChannel: { version: 0, language: 'en' },
+      });
+      await waitFor(() => expect(Channel.languageExistsInResources).toHaveBeenCalled());
+      await waitFor(() =>
+        expect(screen.getByText(communityChannelsStrings.languageLabel$())).toBeVisible(),
+      );
+    });
+
+    it('shows language dropdown if first time publishing a ricecooker channel, even if channel language exists in resources', async () => {
+      Channel.languageExistsInResources.mockResolvedValue(true);
+      Channel.languagesInResources.mockResolvedValue(['de']);
+
+      renderComponent({
+        currentChannel: { ricecooker_version: 'v1', version: 0, language: 'en' },
+      });
+      await waitFor(() => expect(Channel.languageExistsInResources).toHaveBeenCalled());
+
+      waitFor(() =>
+        expect(screen.getByText(communityChannelsStrings.languageLabel$())).toBeVisible(),
+      );
+    });
+
+    it('does not show language dropdown if not first time publishing and channel language exists in resources', async () => {
+      Channel.languageExistsInResources.mockResolvedValue(true);
+      renderComponent({
+        currentChannel: { version: 1, language: 'en' },
+      });
+      await waitFor(() => expect(Channel.languageExistsInResources).toHaveBeenCalled());
+      expect(screen.queryByText(communityChannelsStrings.languageLabel$())).not.toBeInTheDocument();
+    });
+
+    it('shows only channel language as only option if first time publishing and channel language exists in resources', async () => {
+      Channel.languageExistsInResources.mockResolvedValue(true);
+      renderComponent({
+        currentChannel: { version: 0, language: 'en' },
+      });
+      await waitFor(() => expect(Channel.languageExistsInResources).toHaveBeenCalled());
+
+      await waitFor(() =>
+        expect(screen.getByText(communityChannelsStrings.languageLabel$())).toBeVisible(),
+      );
+      // Only English should be present
+      // To be greater than 0 because KSelect duplicates this value twice
+      await waitFor(() => expect(screen.getAllByText(/English/i).length).toBeGreaterThan(0));
+      expect(screen.queryByText(/Deutsch/i)).not.toBeInTheDocument();
+      expect(screen.queryByText(/Italiano/i)).not.toBeInTheDocument();
+    });
+
+    it('shows all resources languages as language options if channel language does not exist in resources', async () => {
+      Channel.languageExistsInResources.mockResolvedValue(false);
+      Channel.languagesInResources.mockResolvedValue(['de', 'it']);
+
+      renderComponent({ currentChannel: { language: 'en', version: 1 } });
+      await waitFor(() => expect(Channel.languagesInResources).toHaveBeenCalled());
+      expect(screen.getByText(communityChannelsStrings.languageLabel$())).toBeVisible();
+
+      await waitFor(() => expect(screen.getAllByText(/Deutsch/i).length).toBeGreaterThan(0));
+      expect(screen.getAllByText(/Italiano/i).length).toBeGreaterThan(0);
+      expect(screen.queryByText(/English/i)).not.toBeInTheDocument();
+    });
+
+    it('does not show current channel language as option if channel language does not exist in resources', async () => {
+      Channel.languageExistsInResources.mockResolvedValue(false);
+      Channel.languagesInResources.mockResolvedValue(['de']);
+
+      renderComponent({ currentChannel: { language: 'en' } });
+      await waitFor(() => expect(Channel.languagesInResources).toHaveBeenCalled());
+      await waitFor(() => expect(screen.getAllByText(/Deutsch/i).length).toBeGreaterThan(0));
+      expect(screen.queryByText(/English/i)).not.toBeInTheDocument();
+    });
+
+    it('shows only channel language as only option if no resources languages exist and channel language does not exist in resources', async () => {
+      Channel.languageExistsInResources.mockResolvedValue(false);
+      Channel.languagesInResources.mockResolvedValue([]);
+
+      renderComponent({ currentChannel: { language: 'en' } });
+      await waitFor(() => expect(Channel.languagesInResources).toHaveBeenCalled());
+
+      expect(screen.getByText(communityChannelsStrings.languageLabel$())).toBeVisible();
+      await waitFor(() => expect(screen.getAllByText(/English/i).length).toBeGreaterThan(0));
+      expect(screen.queryByText(/Deutsch/i)).not.toBeInTheDocument();
+    });
+  });
+
+  it('does not validate in DRAFT mode', async () => {
+    renderComponent();
+
+    // Switch to Draft
+    const draftRadio = screen.getByRole('radio', { name: /Draft/i });
+    await fireEvent.click(draftRadio);
+
+    const saveDraftBtn = screen.getByText(communityChannelsStrings.saveDraft$());
+
+    // Should be enabled even without notes
+    expect(saveDraftBtn).toBeEnabled();
+  });
+
+  it('shows warning if incomplete resources exist', async () => {
+    renderComponent({ errorCount: 5 });
+
+    // Warning text: "5 incomplete resources"
+    expect(
+      screen.getByText(communityChannelsStrings.incompleteResourcesWarning$({ count: 5 })),
+    ).toBeVisible();
+  });
+
+  it('submits DRAFT properly', async () => {
+    renderComponent();
+
+    // Switch to Draft
+    const draftRadio = screen.getByRole('radio', { name: /Draft/i });
+    await fireEvent.click(draftRadio);
+
+    // Submit
+    const saveBtn = screen.getByText(communityChannelsStrings.saveDraft$());
+    await fireEvent.click(saveBtn);
+
+    expect(Channel.publishDraft).toHaveBeenCalled();
+  });
+
+  it('calls forceServerSync when changes are not saved', async () => {
+    renderComponent({ areAllChangesSaved: false });
+
+    // Draft mode to submit quickly
+    const draftRadio = screen.getByRole('radio', { name: /Draft/i });
+    await fireEvent.click(draftRadio);
+
+    const saveBtn = screen.getByText(communityChannelsStrings.saveDraft$());
+    await fireEvent.click(saveBtn);
+
+    expect(forceServerSync).toHaveBeenCalled();
+  });
+
+  it('submits LIVE properly', async () => {
+    renderComponent();
+
+    // Fill notes
+    const notesInput = screen.getByLabelText(communityChannelsStrings.versionDescriptionLabel$());
+    await fireEvent.update(notesInput, 'Ready to publish');
+
+    // Submit
+    const publishBtn = screen.getByText(communityChannelsStrings.publishAction$());
+    await fireEvent.click(publishBtn);
+
+    expect(Channel.publish).toHaveBeenCalledWith('channel-id', 'Ready to publish');
+  });
+
+  it('emits close on successful submission', async () => {
+    const { emitted } = renderComponent();
+
+    const notesInput = screen.getByLabelText(communityChannelsStrings.versionDescriptionLabel$());
+    await fireEvent.update(notesInput, 'Ready to publish');
+
+    const publishBtn = screen.getByText(communityChannelsStrings.publishAction$());
+    await fireEvent.click(publishBtn);
+
+    await waitFor(() => expect(emitted().close).toBeTruthy());
+  });
+
+  it('handles community library submission logic (Resubmit Modal)', async () => {
+    CommunityLibrarySubmission.fetchCollection.mockResolvedValue({
+      results: [{ channel_version: 5 }],
+    });
+
+    const { emitted } = renderComponent();
+
+    const notesInput = screen.getByLabelText(communityChannelsStrings.versionDescriptionLabel$());
+    await fireEvent.update(notesInput, 'Notes');
+
+    const publishBtn = screen.getByText(communityChannelsStrings.publishAction$());
+    await fireEvent.click(publishBtn);
+
+    await waitFor(() => expect(CommunityLibrarySubmission.fetchCollection).toHaveBeenCalled());
+    expect(emitted().showResubmitCommunityLibraryModal).toBeTruthy();
+    expect(emitted().showResubmitCommunityLibraryModal[0][0]).toEqual({
+      channel: expect.objectContaining({ id: 'channel-id' }),
+      latestSubmissionVersion: 5,
+    });
+  });
+
+  it('updates channel language if changed during submit', async () => {
+    Channel.languageExistsInResources.mockResolvedValue(false);
+    Channel.languagesInResources.mockResolvedValue(['de']);
+
+    renderComponent({
+      currentChannel: { language: 'en' },
+    });
+
+    await waitFor(() => expect(Channel.languagesInResources).toHaveBeenCalled());
+
+    await waitFor(() => expect(screen.getAllByText(/Deutsch/i).length).toBeGreaterThan(0));
+
+    // Select Deutsch
+    await fireEvent.click(screen.getAllByText(/Deutsch/i)[0]);
+
+    const notesInput = screen.getByLabelText(communityChannelsStrings.versionDescriptionLabel$());
+    await fireEvent.update(notesInput, 'Notes');
+
+    const publishBtn = screen.getByText(communityChannelsStrings.publishAction$());
+    await fireEvent.click(publishBtn);
+
+    // Check that current channel in the store was updated with new language
+    await waitFor(() => {
+      const updatedChannel = store.getters['currentChannel/currentChannel'];
+      expect(updatedChannel.language).toBe('de');
+    });
+    await waitFor(() => {
+      expect(Channel.publish).toHaveBeenCalled();
+    });
+  });
+
+  it('handles error during submit', async () => {
+    Channel.publish.mockRejectedValue({ response: { status: 500 } });
+
+    renderComponent();
+
+    const notesInput = screen.getByLabelText(communityChannelsStrings.versionDescriptionLabel$());
+    await fireEvent.update(notesInput, 'Notes');
+
+    const publishBtn = screen.getByText(communityChannelsStrings.publishAction$());
+    await fireEvent.click(publishBtn);
+
+    // Wait for fullPageError to be set in the store, it is in store.state.errors.fullPageError
+    await waitFor(() => {
+      const fullPageError = store.state.errors.fullPageError;
+      expect(fullPageError).toBeTruthy();
+    });
+  });
+
+  it('closes panel when cancel is clicked', async () => {
+    const { emitted } = renderComponent();
+    const cancelBtn = screen.getByText(communityChannelsStrings.cancelAction$());
+    await fireEvent.click(cancelBtn);
+    expect(emitted().close).toBeTruthy();
+  });
+});
diff --git a/contentcuration/contentcuration/frontend/shared/strings/communityChannelsStrings.js b/contentcuration/contentcuration/frontend/shared/strings/communityChannelsStrings.js
index ffee0a8433..c116a76a82 100644
--- a/contentcuration/contentcuration/frontend/shared/strings/communityChannelsStrings.js
+++ b/contentcuration/contentcuration/frontend/shared/strings/communityChannelsStrings.js
@@ -69,9 +69,13 @@ export const communityChannelsStrings = createTranslator('CommunityChannelsStrin
     message: 'Language',
     context: 'Label for the language selection dropdown',
   },
+  versionNotesRequiredMessage: {
+    message: 'Version notes are required',
+    context: 'Error message when version notes are required but not provided',
+  },
   languageRequiredMessage: {
     message: 'Language is required',
-    context: 'Error message when language selection is required',
+    context: 'Error message when language selection is required but not provided',
   },
   pendingStatus: {
     message: 'Submitted',