diff --git a/src/frontend/apps/e2e/__tests__/app-impress/presenter-mode.spec.ts b/src/frontend/apps/e2e/__tests__/app-impress/presenter-mode.spec.ts
index a194f5b2e0..7c9dead1e6 100644
--- a/src/frontend/apps/e2e/__tests__/app-impress/presenter-mode.spec.ts
+++ b/src/frontend/apps/e2e/__tests__/app-impress/presenter-mode.spec.ts
@@ -1,7 +1,19 @@
-import { Page, expect, test } from '@playwright/test';
-
-import { createDoc, goToGridDoc, mockedDocument } from './utils-common';
-import { openSuggestionMenu, writeInEditor } from './utils-editor';
+import path from 'path';
+
+import { Locator, Page, expect, test } from '@playwright/test';
+import { PDFParse } from 'pdf-parse';
+
+import {
+  createDoc,
+  goToGridDoc,
+  mockedDocument,
+  saveContent,
+} from './utils-common';
+import {
+  openSuggestionMenu,
+  tryFocusEditorContent,
+  writeInEditor,
+} from './utils-editor';
 
 const openPresenter = async (page: Page) => {
   await page.getByLabel('Open the document options').click();
@@ -17,6 +29,37 @@ const insertDivider = async (page: Page) => {
   await suggestionMenu.getByText('Divider', { exact: true }).click();
 };
 
+const insertImageInCurrentBlock = async (page: Page) => {
+  const fileChooserPromise = page.waitForEvent('filechooser');
+
+  await tryFocusEditorContent({ page });
+  await page.keyboard.type('/');
+  await page
+    .locator('.bn-suggestion-menu')
+    .getByText('Resizable image with caption', { exact: true })
+    .click();
+  await page.getByText('Upload image').click();
+
+  const fileChooser = await fileChooserPromise;
+  await fileChooser.setFiles(
+    path.join(__dirname, 'assets/logo-suite-numerique.png'),
+  );
+
+  const image = page
+    .locator('.--docs--editor-container img.bn-visual-media')
+    .first();
+  await expect(image).toBeVisible({ timeout: 10000 });
+  return image;
+};
+
+const getDocIdFromUrl = (page: Page) => {
+  const id = /\/docs\/([^/?]+)/.exec(page.url())?.[1];
+  if (!id) {
+    throw new Error(`Could not extract doc id from URL: ${page.url()}`);
+  }
+  return id;
+};
+
 const writeMultiSlideDoc = async (page: Page) => {
   const editor = await writeInEditor({ page, text: 'Slide one' });
   await editor.press('Enter');
@@ -29,11 +72,49 @@ const writeMultiSlideDoc = async (page: Page) => {
   await writeInEditor({ page, text: 'Slide three' });
 };
 
+const stubPrintDialog = async (page: Page) => {
+  await page.evaluate(() => {
+    window.print = () => undefined;
+  });
+};
+
+const finishStubbedPrintDialog = async (page: Page) => {
+  await page.evaluate(() => {
+    window.dispatchEvent(new Event('afterprint'));
+  });
+};
+
+const openPresenterActions = async (page: Page, overlay: Locator) => {
+  await overlay.getByRole('button', { name: 'More options' }).click();
+  await expect(
+    page.getByRole('menuitem', { name: 'Copy link to slide' }),
+  ).toBeVisible();
+  await expect(
+    page.getByRole('menuitem', { name: 'Download PDF' }),
+  ).toBeVisible();
+};
+
+const copyCurrentPresenterSlideLink = async (page: Page, overlay: Locator) => {
+  await openPresenterActions(page, overlay);
+  await page.getByRole('menuitem', { name: 'Copy link to slide' }).click();
+};
+
+const exportPresenterPdf = async (page: Page, overlay: Locator) => {
+  await openPresenterActions(page, overlay);
+  await page.getByRole('menuitem', { name: 'Download PDF' }).click();
+};
+
 test.beforeEach(async ({ page }) => {
   await page.goto('/');
 });
 
 test.describe('Presenter Mode', () => {
+  // Step out of the suite-wide fullyParallel mode: these tests create and edit
+  // docs that race the editor/persistence layer under heavy parallelism. Run
+  // them sequentially within the file (each test is still fully independent —
+  // no shared state — so this is `default`, not `serial`).
+  test.describe.configure({ mode: 'default' });
+
   test('opens the presenter overlay from the doc options menu and closes with Escape', async ({
     page,
     browserName,
@@ -46,6 +127,13 @@ test.describe('Presenter Mode', () => {
     await expect(
       overlay.getByRole('toolbar', { name: 'Presenter controls' }),
     ).toBeVisible();
+    await expect(overlay.getByText(/presenter-open/)).toBeVisible();
+    await expect(
+      overlay.getByText(
+        'You can use the divider to tell Docs where to split your slides',
+      ),
+    ).toBeVisible();
+    await overlay.getByRole('button', { name: 'Next slide' }).click();
     await expect(overlay.getByText('Hello presenter')).toBeVisible();
 
     // The presenter calls requestFullscreen on open. usePresenterShortcuts
@@ -92,19 +180,19 @@ test.describe('Presenter Mode', () => {
 
     const overlay = await openPresenter(page);
 
-    // The visible "1 / 3" counter is decorative (aria-hidden); the position is
+    // The visible "1 / 4" counter is decorative (aria-hidden); the position is
     // announced through a polite live region for screen readers instead.
     // react-aria/live-announcer creates a global role="log" div on document.body
     // (outside the dialog), so we query from `page`, not `overlay`.
     const liveRegion = page.locator(
       '[data-live-announcer="true"] [aria-live="polite"]',
     );
-    // The announcement includes the slide title extracted from the first
-    // text block (getSlideTitle), so assert the full message.
-    await expect(liveRegion).toContainText('Slide 1 of 3: Slide one');
+    // The title slide uses the document title, then content slides use the
+    // first text block (getSlideTitle).
+    await expect(liveRegion).toContainText('Slide 1 of 4:');
 
     await overlay.getByRole('button', { name: 'Next slide' }).click();
-    await expect(liveRegion).toContainText('Slide 2 of 3: Slide two');
+    await expect(liveRegion).toContainText('Slide 2 of 4: Slide one');
 
     // Each slide advertises a localized role description for screen readers.
     await expect(overlay.getByRole('group').first()).toHaveAttribute(
@@ -113,7 +201,7 @@ test.describe('Presenter Mode', () => {
     );
   });
 
-  test('renders a single-slide doc with counter 1/1 and disabled nav buttons', async ({
+  test('renders a content-only doc after the generated title slide', async ({
     page,
     browserName,
   }) => {
@@ -122,19 +210,58 @@ test.describe('Presenter Mode', () => {
 
     const overlay = await openPresenter(page);
 
-    await expect(overlay.getByText('1 / 1')).toBeVisible();
+    await expect(overlay.getByText('1 / 2')).toBeVisible();
     await expect(
       overlay.getByRole('button', { name: 'Previous slide' }),
     ).toBeDisabled();
     await expect(
       overlay.getByRole('button', { name: 'Next slide' }),
-    ).toBeDisabled();
+    ).toBeEnabled();
+
+    await overlay.getByRole('button', { name: 'Next slide' }).click();
+    await expect(overlay.getByText('2 / 2')).toBeVisible();
     await expect(overlay.getByText('Slide A')).toBeVisible();
+    await expect(
+      overlay.getByRole('button', { name: 'Next slide' }),
+    ).toBeDisabled();
 
     await overlay.getByRole('button', { name: 'Close presenter' }).click();
     await expect(overlay).toBeHidden();
   });
 
+  test('does not show selected-node chrome when the first slide block is an image', async ({
+    page,
+    browserName,
+  }) => {
+    await createDoc(page, 'presenter-image-first', browserName, 1);
+    await insertImageInCurrentBlock(page);
+
+    const overlay = await openPresenter(page);
+    await overlay.getByRole('button', { name: 'Next slide' }).click();
+    const presenterImage = overlay.locator('img.bn-visual-media').first();
+    await expect(presenterImage).toBeAttached({ timeout: 10000 });
+
+    const outline = await presenterImage.evaluate((img) => {
+      const blockContent = img.closest('.bn-block-content');
+      blockContent?.classList.add('ProseMirror-selectednode');
+
+      const outlinedElement =
+        (blockContent?.firstElementChild as HTMLElement | null) ??
+        (img as HTMLElement);
+      const style = getComputedStyle(outlinedElement);
+
+      return {
+        outlineStyle: style.outlineStyle,
+        outlineWidth: style.outlineWidth,
+      };
+    });
+
+    expect(outline).toEqual({
+      outlineStyle: 'none',
+      outlineWidth: '0px',
+    });
+  });
+
   test('navigates between slides via the floating bar buttons', async ({
     page,
     browserName,
@@ -147,23 +274,27 @@ test.describe('Presenter Mode', () => {
     const prev = overlay.getByRole('button', { name: 'Previous slide' });
     const next = overlay.getByRole('button', { name: 'Next slide' });
 
-    await expect(overlay.getByText('1 / 3')).toBeVisible();
-    await expect(overlay.getByText('Slide one')).toBeVisible();
+    await expect(overlay.getByText('1 / 4')).toBeVisible();
+    await expect(overlay.getByText(/presenter-nav-bar/)).toBeVisible();
     await expect(prev).toBeDisabled();
     await expect(next).toBeEnabled();
 
     await next.click();
-    await expect(overlay.getByText('2 / 3')).toBeVisible();
+    await expect(overlay.getByText('2 / 4')).toBeVisible();
+    await expect(overlay.getByText('Slide one')).toBeVisible();
+
+    await next.click();
+    await expect(overlay.getByText('3 / 4')).toBeVisible();
     await expect(overlay.getByText('Slide two')).toBeVisible();
 
     await next.click();
-    await expect(overlay.getByText('3 / 3')).toBeVisible();
+    await expect(overlay.getByText('4 / 4')).toBeVisible();
     await expect(overlay.getByText('Slide three')).toBeVisible();
     await expect(next).toBeDisabled();
     await expect(prev).toBeEnabled();
 
     await prev.click();
-    await expect(overlay.getByText('2 / 3')).toBeVisible();
+    await expect(overlay.getByText('3 / 4')).toBeVisible();
     await expect(overlay.getByText('Slide two')).toBeVisible();
   });
 
@@ -176,20 +307,20 @@ test.describe('Presenter Mode', () => {
 
     const overlay = await openPresenter(page);
 
-    await expect(overlay.getByText('1 / 3')).toBeVisible();
+    await expect(overlay.getByText('1 / 4')).toBeVisible();
 
     await page.keyboard.press('ArrowRight');
-    await expect(overlay.getByText('2 / 3')).toBeVisible();
+    await expect(overlay.getByText('2 / 4')).toBeVisible();
 
     await page.keyboard.press('End');
-    await expect(overlay.getByText('3 / 3')).toBeVisible();
+    await expect(overlay.getByText('4 / 4')).toBeVisible();
 
     await page.keyboard.press('Home');
-    await expect(overlay.getByText('1 / 3')).toBeVisible();
+    await expect(overlay.getByText('1 / 4')).toBeVisible();
 
-    // ArrowLeft on the first slide is clamped — counter stays at 1 / 3.
+    // ArrowLeft on the first slide is clamped — counter stays at 1 / 4.
     await page.keyboard.press('ArrowLeft');
-    await expect(overlay.getByText('1 / 3')).toBeVisible();
+    await expect(overlay.getByText('1 / 4')).toBeVisible();
   });
 
   test('scales each slide to fit the viewport (outer width = 900 × scale)', async ({
@@ -251,7 +382,11 @@ test.describe('Presenter Mode', () => {
     }
 
     const overlay = await openPresenter(page);
-    const slide = overlay.getByRole('group').filter({ hasNotText: '' }).first();
+    await overlay.getByRole('button', { name: 'Next slide' }).click();
+    const slide = overlay
+      .getByRole('group')
+      .filter({ hasText: 'TOP MARKER' })
+      .first();
     await expect(slide).toBeVisible();
 
     // The first block ('TOP MARKER') must be at y=0 of the slide wrapper
@@ -278,9 +413,326 @@ test.describe('Presenter Mode', () => {
       topVisible.clientHeight ?? 0,
     );
   });
+
+  test('opens the presenter at the targeted slide from a block side menu', async ({
+    page,
+    browserName,
+  }) => {
+    await createDoc(page, 'presenter-side-menu', browserName, 1);
+    await writeMultiSlideDoc(page);
+
+    // Reveal the block side menu for the "Slide two" paragraph, then trigger its
+    // drag-handle "Present" action.
+    await page
+      .locator('.bn-block-outer')
+      .filter({ hasText: 'Slide two' })
+      .first()
+      .hover();
+    await page.locator('.bn-side-menu > button').last().click();
+    await page.getByRole('menuitem', { name: 'Present' }).click();
+
+    // "Slide two" is the 2nd content slide; with the generated title slide
+    // first that is slide 3 of 4.
+    const overlay = page.getByRole('dialog', { name: 'Presenter mode' });
+    await expect(overlay).toBeVisible();
+    await expect(overlay.getByText('3 / 4')).toBeVisible();
+    await expect(overlay.getByText('Slide two')).toBeVisible();
+  });
+
+  test('deep-link ?view=present&slide=3 opens the presenter at content slide 2', async ({
+    page,
+    browserName,
+  }) => {
+    const [docTitle] = await createDoc(
+      page,
+      'presenter-deeplink',
+      browserName,
+      1,
+    );
+    await writeMultiSlideDoc(page);
+    const docId = getDocIdFromUrl(page);
+
+    // Ensure the typed content is persisted (awaits the PATCH /content/) before
+    // we reload the page through the deep-link, instead of a fixed sleep.
+    await saveContent(page, docTitle);
+    await page.goto(`/docs/${docId}/?view=present&slide=3`);
+
+    const overlay = page.getByRole('dialog', { name: 'Presenter mode' });
+    await expect(overlay).toBeVisible({ timeout: 15000 });
+    await expect(overlay.getByText('3 / 4')).toBeVisible();
+    await expect(overlay.getByText('Slide two')).toBeVisible();
+  });
+
+  test('deep-link with an out-of-range slide clamps to the last slide and rewrites the URL', async ({
+    page,
+    browserName,
+  }) => {
+    const [docTitle] = await createDoc(
+      page,
+      'presenter-deeplink-oob',
+      browserName,
+      1,
+    );
+    await writeMultiSlideDoc(page);
+    const docId = getDocIdFromUrl(page);
+
+    await saveContent(page, docTitle);
+    await page.goto(`/docs/${docId}/?view=present&slide=99`);
+
+    const overlay = page.getByRole('dialog', { name: 'Presenter mode' });
+    await expect(overlay).toBeVisible({ timeout: 15000 });
+    await expect(overlay.getByText('4 / 4')).toBeVisible();
+    // The address bar self-corrects to the real slide.
+    await expect.poll(() => page.url()).toContain('slide=4');
+  });
+
+  test('deep-link with an invalid slide param falls back to the first slide', async ({
+    page,
+    browserName,
+  }) => {
+    const [docTitle] = await createDoc(
+      page,
+      'presenter-deeplink-invalid',
+      browserName,
+      1,
+    );
+    await writeMultiSlideDoc(page);
+    const docId = getDocIdFromUrl(page);
+
+    await saveContent(page, docTitle);
+    await page.goto(`/docs/${docId}/?view=present&slide=abc`);
+
+    const overlay = page.getByRole('dialog', { name: 'Presenter mode' });
+    await expect(overlay).toBeVisible({ timeout: 15000 });
+    await expect(overlay.getByText('1 / 4')).toBeVisible();
+  });
+
+  test('shows a confirmation toast when copying the current-slide link', async ({
+    page,
+    browserName,
+  }) => {
+    await createDoc(page, 'presenter-copy-link', browserName, 1);
+    await writeMultiSlideDoc(page);
+
+    const overlay = await openPresenter(page);
+    await overlay.getByRole('button', { name: 'Next slide' }).click();
+    await expect(overlay.getByText('2 / 4')).toBeVisible();
+
+    await copyCurrentPresenterSlideLink(page, overlay);
+    await expect(page.getByText('Link Copied !')).toBeVisible();
+  });
+
+  test('copies a deep-link pointing to the current slide', async ({
+    page,
+    browserName,
+    context,
+  }) => {
+    // Clipboard read-back is only reliable on Chromium with granted permissions.
+    test.skip(
+      browserName !== 'chromium',
+      'Clipboard read-back is Chromium-only',
+    );
+    await context.grantPermissions(['clipboard-read', 'clipboard-write']);
+
+    await createDoc(page, 'presenter-copy-link-content', browserName, 1);
+    await writeMultiSlideDoc(page);
+    const docId = getDocIdFromUrl(page);
+
+    const overlay = await openPresenter(page);
+    await overlay.getByRole('button', { name: 'Next slide' }).click();
+    await expect(overlay.getByText('2 / 4')).toBeVisible();
+
+    await copyCurrentPresenterSlideLink(page, overlay);
+    await expect(page.getByText('Link Copied !')).toBeVisible();
+
+    const clipboard = await page.evaluate(() => navigator.clipboard.readText());
+    expect(clipboard).toContain(`/docs/${docId}/?view=present&slide=2`);
+  });
+
+  test('syncs the slide to the URL while navigating', async ({
+    page,
+    browserName,
+  }) => {
+    await createDoc(page, 'presenter-url-sync', browserName, 1);
+    await writeMultiSlideDoc(page);
+
+    const overlay = await openPresenter(page);
+    // Opening writes slide=1 to the address bar.
+    await expect.poll(() => page.url()).toContain('view=present');
+    await expect.poll(() => page.url()).toContain('slide=1');
+
+    await overlay.getByRole('button', { name: 'Next slide' }).click();
+    await expect(overlay.getByText('2 / 4')).toBeVisible();
+    await expect.poll(() => page.url()).toContain('slide=2');
+  });
+
+  test('strips the present query params when closing', async ({
+    page,
+    browserName,
+  }) => {
+    await createDoc(page, 'presenter-url-strip', browserName, 1);
+    await writeInEditor({ page, text: 'Slide A' });
+
+    const overlay = await openPresenter(page);
+    await expect.poll(() => page.url()).toContain('view=present');
+
+    await overlay.getByRole('button', { name: 'Close presenter' }).click();
+    await expect(overlay).toBeHidden();
+    await expect.poll(() => page.url()).not.toContain('view=present');
+    await expect.poll(() => page.url()).not.toContain('slide=');
+    // The editor is still mounted (shallow routing, no full reload).
+    await expect(page.locator('.--docs--editor-container')).toBeVisible();
+  });
+
+  test('exports every presenter slide through browser print as landscape PDF pages', async ({
+    page,
+    browserName,
+  }) => {
+    test.skip(
+      browserName !== 'chromium',
+      'page.pdf() is only available on Chromium',
+    );
+
+    await createDoc(page, 'presenter-print-pdf', browserName, 1);
+    await writeMultiSlideDoc(page);
+
+    const overlay = await openPresenter(page);
+    await stubPrintDialog(page);
+
+    await exportPresenterPdf(page, overlay);
+
+    await expect(page.locator('#presenter-print-styles')).toBeAttached();
+    await expect(page.locator('[data-presenter-print-page]')).toHaveCount(4);
+
+    await page.emulateMedia({ media: 'print' });
+    const pdfBuffer = await page.pdf({
+      printBackground: true,
+      preferCSSPageSize: true,
+      scale: 1,
+    });
+    await page.emulateMedia({ media: 'screen' });
+
+    const pdfParse = new PDFParse({ data: pdfBuffer });
+    const pdfInfo = await pdfParse.getInfo({ parsePageInfo: true });
+    const pdfText = await pdfParse.getText();
+    await pdfParse.destroy();
+
+    expect(pdfInfo.total).toBe(4);
+    expect(pdfInfo.pages).toHaveLength(4);
+    pdfInfo.pages.forEach((pdfPage) => {
+      expect(pdfPage.width).toBeGreaterThan(pdfPage.height);
+    });
+    expect(pdfText.text).toContain('Slide one');
+    expect(pdfText.text).toContain('Slide two');
+    expect(pdfText.text).toContain('Slide three');
+
+    await finishStubbedPrintDialog(page);
+    await expect(page.locator('#presenter-print-styles')).not.toBeAttached({
+      timeout: 5000,
+    });
+  });
+
+  test('renders file blocks as printable links in presenter export', async ({
+    page,
+    browserName,
+  }) => {
+    await createDoc(page, 'presenter-print-file-link', browserName, 1);
+    await writeInEditor({ page, text: 'Slide with a file' });
+
+    const fileChooserPromise = page.waitForEvent('filechooser');
+    const responseCheckPromise = page.waitForResponse(
+      (response) =>
+        response.url().includes('media-check') && response.status() === 200,
+    );
+
+    await openSuggestionMenu({
+      page,
+      suggestion: 'Embedded file',
+    });
+    await page.getByText('Upload file').click();
+
+    const fileChooser = await fileChooserPromise;
+    await fileChooser.setFiles(path.join(__dirname, 'assets/test.html'));
+    await responseCheckPromise;
+
+    await expect(
+      page.locator('.bn-block-content[data-name="test.html"]'),
+    ).toBeVisible();
+
+    const overlay = await openPresenter(page);
+    await stubPrintDialog(page);
+
+    await exportPresenterPdf(page, overlay);
+
+    const printFileBlock = page.locator(
+      '#presenter-print-root [data-content-type="file"][data-name="test.html"]',
+    );
+    await expect(printFileBlock).toBeAttached();
+
+    const printLinkText = await printFileBlock.evaluate((el) => {
+      const shadowRoot = el.firstElementChild?.shadowRoot;
+      return shadowRoot?.textContent ?? '';
+    });
+
+    expect(printLinkText).toContain('test.html');
+
+    await finishStubbedPrintDialog(page);
+    await expect(page.locator('#presenter-print-styles')).not.toBeAttached({
+      timeout: 5000,
+    });
+  });
+
+  test('clips a tall content slide to a single printed page after the title page', async ({
+    page,
+    browserName,
+  }) => {
+    test.skip(
+      browserName !== 'chromium',
+      'page.pdf() is only available on Chromium',
+    );
+
+    await createDoc(page, 'presenter-print-tall', browserName, 1);
+
+    const editor = await writeInEditor({ page, text: 'TOP PRINT MARKER' });
+    for (let i = 0; i < 45; i += 1) {
+      await editor.press('Enter');
+      await editor.pressSequentially(`Printed filler line ${i}`);
+    }
+
+    const overlay = await openPresenter(page);
+    await stubPrintDialog(page);
+
+    await exportPresenterPdf(page, overlay);
+
+    await expect(page.locator('#presenter-print-styles')).toBeAttached();
+    await expect(page.locator('[data-presenter-print-page]')).toHaveCount(2);
+
+    await page.emulateMedia({ media: 'print' });
+    const pdfBuffer = await page.pdf({
+      printBackground: true,
+      preferCSSPageSize: true,
+      scale: 1,
+    });
+    await page.emulateMedia({ media: 'screen' });
+
+    const pdfParse = new PDFParse({ data: pdfBuffer });
+    const pdfInfo = await pdfParse.getInfo({ parsePageInfo: true });
+    const pdfText = await pdfParse.getText();
+    await pdfParse.destroy();
+
+    expect(pdfInfo.total).toBe(2);
+    expect(pdfInfo.pages[0].width).toBeGreaterThan(pdfInfo.pages[0].height);
+    expect(pdfText.text).toContain('TOP PRINT MARKER');
+
+    await finishStubbedPrintDialog(page);
+    await expect(page.locator('#presenter-print-styles')).not.toBeAttached({
+      timeout: 5000,
+    });
+  });
 });
 
 test.describe('Presenter Mode mobile', () => {
+  test.describe.configure({ mode: 'default' });
   test.use({ viewport: { width: 500, height: 1200 } });
 
   test.beforeEach(async ({ page }) => {
@@ -310,4 +762,26 @@ test.describe('Presenter Mode mobile', () => {
     await page.getByLabel('Open the document options').click();
     await expect(page.getByRole('menuitem', { name: 'Present' })).toBeHidden();
   });
+
+  test('ignores a ?view=present deep-link on small mobile viewports', async ({
+    page,
+    browserName,
+  }) => {
+    await createDoc(page, 'presenter-mobile-deeplink', browserName, 1, true);
+    await writeInEditor({ page, text: 'Slide A' });
+    const docId = getDocIdFromUrl(page);
+
+    // No persistence wait needed: this asserts the deep-link is ignored on
+    // mobile, which does not depend on the typed content being saved.
+    await page.goto(`/docs/${docId}/?view=present&slide=1`);
+
+    // The editor loads normally...
+    await expect(page.locator('.--docs--editor-container')).toBeVisible({
+      timeout: 15000,
+    });
+    // ...but the presenter is never auto-opened on mobile.
+    await expect(
+      page.getByRole('dialog', { name: 'Presenter mode' }),
+    ).toBeHidden();
+  });
 });
diff --git a/src/frontend/apps/e2e/__tests__/app-impress/utils-common.ts b/src/frontend/apps/e2e/__tests__/app-impress/utils-common.ts
index 24b2c0b88a..005007e3dc 100644
--- a/src/frontend/apps/e2e/__tests__/app-impress/utils-common.ts
+++ b/src/frontend/apps/e2e/__tests__/app-impress/utils-common.ts
@@ -180,6 +180,12 @@ export const createDoc = async (
     expect(responseUpdateDoc.ok()).toBeTruthy();
   }
 
+  // Wait for the editor to be mounted before handing control back, so callers
+  // that immediately type or open features don't race the editor load.
+  await expect(
+    page.locator('.--docs--editor-container .ProseMirror'),
+  ).toBeVisible({ timeout: 10000 });
+
   return randomDocs;
 };
 
diff --git a/src/frontend/apps/impress/src/features/docs/doc-editor/components/BlockNoteEditor.tsx b/src/frontend/apps/impress/src/features/docs/doc-editor/components/BlockNoteEditor.tsx
index 5c9b2b1e29..e47ea82d4a 100644
--- a/src/frontend/apps/impress/src/features/docs/doc-editor/components/BlockNoteEditor.tsx
+++ b/src/frontend/apps/impress/src/features/docs/doc-editor/components/BlockNoteEditor.tsx
@@ -51,6 +51,7 @@ import { DocsBlockNoteEditor } from '../types';
 import { randomColor, sanitizeColor } from '../utils';
 
 import BlockNoteAI from './AI';
+import { BlockNoteSideMenu } from './BlockNoteSideMenu';
 import { BlockNoteSuggestionMenu } from './BlockNoteSuggestionMenu';
 import { BlockNoteToolbar } from './BlockNoteToolBar/BlockNoteToolbar';
 import { CalloutBlock, PdfBlock, UploadLoaderBlock } from './custom-blocks';
@@ -292,6 +293,7 @@ export const BlockNoteEditor = ({ doc, provider }: BlockNoteEditorProps) => {
         editor={editor}
         formattingToolbar={false}
         slashMenu={false}
+        sideMenu={false}
         theme="light"
         comments={false}
         aria-label={t('Document editor')}
@@ -303,6 +305,7 @@ export const BlockNoteEditor = ({ doc, provider }: BlockNoteEditorProps) => {
         )}
         <BlockNoteSuggestionMenu aiAllowed={aiBlockNoteAllowed} />
         <BlockNoteToolbar aiAllowed={aiBlockNoteAllowed} />
+        <BlockNoteSideMenu />
         {showComments && <FloatingComposerController />}
         {showComments && !isCommentSideBarOpen && <FloatingThreadController />}
         {threadsSidebarTarget &&
diff --git a/src/frontend/apps/impress/src/features/docs/doc-editor/components/BlockNoteSideMenu.tsx b/src/frontend/apps/impress/src/features/docs/doc-editor/components/BlockNoteSideMenu.tsx
new file mode 100644
index 0000000000..ce658b5a4a
--- /dev/null
+++ b/src/frontend/apps/impress/src/features/docs/doc-editor/components/BlockNoteSideMenu.tsx
@@ -0,0 +1,86 @@
+import { SideMenuExtension } from '@blocknote/core/extensions';
+import {
+  BlockColorsItem,
+  RemoveBlockItem,
+  SideMenu,
+  SideMenuController,
+  TableColumnHeaderItem,
+  TableRowHeaderItem,
+  useBlockNoteEditor,
+  useComponentsContext,
+  useDictionary,
+  useExtensionState,
+} from '@blocknote/react';
+import { useTranslation } from 'react-i18next';
+
+import { getContentSlideIndexForBlock } from '@/docs/doc-presenter/hooks/useSlides';
+import { usePresenterStore } from '@/docs/doc-presenter/stores';
+import type { PresenterBlock } from '@/docs/doc-presenter/types';
+import { useResponsiveStore } from '@/stores';
+
+import type { DocsBlockNoteEditor } from '../types';
+
+const PresentBlockItem = () => {
+  const { t } = useTranslation();
+  const Components = useComponentsContext();
+  const editor: DocsBlockNoteEditor = useBlockNoteEditor();
+  const block = useExtensionState(SideMenuExtension, {
+    editor,
+    selector: (state) => state?.block,
+  });
+  const openPresenter = usePresenterStore((state) => state.open);
+  const { isMobile } = useResponsiveStore();
+
+  // Hidden on mobile (no presenter there) and until a block is targeted
+  // (no drag handle hovered yet).
+  if (Components === undefined || block === undefined || isMobile) {
+    return null;
+  }
+
+  return (
+    <Components.Generic.Menu.Item
+      className="bn-menu-item"
+      onClick={() => {
+        const contentSlideIndex = getContentSlideIndexForBlock(
+          editor.document as PresenterBlock[],
+          block.id,
+        );
+
+        // Overlay slide 0 is the generated title slide; content slides start
+        // at index 1, hence the +1 on the 0-based content-slide index.
+        openPresenter(contentSlideIndex + 1);
+      }}
+    >
+      {t('Present')}
+    </Components.Generic.Menu.Item>
+  );
+};
+
+const DocsDragHandleMenu = () => {
+  const Components = useComponentsContext();
+  const dict = useDictionary();
+
+  if (Components === undefined) {
+    return null;
+  }
+
+  return (
+    <Components.Generic.Menu.Dropdown className="bn-menu-dropdown bn-drag-handle-menu">
+      <RemoveBlockItem>{dict.drag_handle.delete_menuitem}</RemoveBlockItem>
+      <PresentBlockItem />
+      <BlockColorsItem>{dict.drag_handle.colors_menuitem}</BlockColorsItem>
+      <TableRowHeaderItem>
+        {dict.drag_handle.header_row_menuitem}
+      </TableRowHeaderItem>
+      <TableColumnHeaderItem>
+        {dict.drag_handle.header_column_menuitem}
+      </TableColumnHeaderItem>
+    </Components.Generic.Menu.Dropdown>
+  );
+};
+
+const DocsSideMenu = () => <SideMenu dragHandleMenu={DocsDragHandleMenu} />;
+
+export const BlockNoteSideMenu = () => (
+  <SideMenuController sideMenu={DocsSideMenu} />
+);
diff --git a/src/frontend/apps/impress/src/features/docs/doc-editor/styles.tsx b/src/frontend/apps/impress/src/features/docs/doc-editor/styles.tsx
index fff7b6a248..858759854a 100644
--- a/src/frontend/apps/impress/src/features/docs/doc-editor/styles.tsx
+++ b/src/frontend/apps/impress/src/features/docs/doc-editor/styles.tsx
@@ -152,14 +152,32 @@ export const DocsEditorStyle = createGlobalStyle`
     /**
     * Divider
     */
-    [data-content-type='divider'] hr {
-      background: #d3d2cf;
-      margin: 1rem 0;
+    .bn-block-content[data-content-type='divider'] {
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      height: 28px;
+      padding: 0;
+    }
+    .bn-block-content[data-content-type='divider'] hr {
+      flex: 1 1 100%;
       width: 100%;
-      border: 1px solid #d3d2cf;
+      height: 1px;
+      margin: 0;
+      border: 0;
+      border-radius: 11px;
+      background: var(--c--contextuals--border--surface--primary);
+    }
+    .bn-block-content[data-content-type='divider'].ProseMirror-selectednode hr {
+      height: 9.5px;
+      outline: 0 !important;
+      box-shadow: none;
+      border: 4px solid
+        var(--c--contextuals--border--semantic--brand--tertiary);
+      background: var(--c--contextuals--border--semantic--brand--secondary);
     }
     .bn-side-menu[data-block-type='divider'] {
-      height: 38px;
+      height: 28px;
     }
 
     /**
diff --git a/src/frontend/apps/impress/src/features/docs/doc-export/__tests__/utilsPrint.test.ts b/src/frontend/apps/impress/src/features/docs/doc-export/__tests__/utilsPrint.test.ts
new file mode 100644
index 0000000000..7421e58af8
--- /dev/null
+++ b/src/frontend/apps/impress/src/features/docs/doc-export/__tests__/utilsPrint.test.ts
@@ -0,0 +1,70 @@
+import { afterEach, describe, expect, test } from 'vitest';
+
+import { wrapInterlinksWithAnchor, wrapMediaWithLink } from '../utils_print';
+
+describe('print DOM helpers', () => {
+  afterEach(() => {
+    document.body.innerHTML = '';
+  });
+
+  test('wraps media links only inside the provided root', () => {
+    document.body.innerHTML = `
+      <main>
+        <div id="outside" data-content-type="video" data-url="https://example.com/outside.mp4" data-name="outside.mp4">
+          <div class="bn-file-block-content-wrapper"></div>
+        </div>
+        <div id="root">
+          <div id="inside" data-content-type="audio" data-url="https://example.com/inside.mp3" data-name="inside.mp3">
+            <div class="bn-file-block-content-wrapper"></div>
+          </div>
+        </div>
+      </main>
+    `;
+
+    const root = document.getElementById('root');
+    if (!root) {
+      throw new Error('missing root');
+    }
+
+    const cleanup = wrapMediaWithLink(root);
+
+    const inside = document.getElementById('inside');
+    const outside = document.getElementById('outside');
+
+    expect(inside?.firstElementChild?.shadowRoot?.textContent).toContain(
+      'inside.mp3',
+    );
+    expect(outside?.firstElementChild?.shadowRoot).toBeNull();
+
+    cleanup();
+
+    expect(inside?.firstElementChild?.shadowRoot).toBeNull();
+  });
+
+  test('wraps interlinks only inside the provided root', () => {
+    document.body.innerHTML = `
+      <main>
+        <span class="--docs--interlinking-link-inline-content" data-href="https://example.com/outside">outside</span>
+        <div id="root">
+          <span class="--docs--interlinking-link-inline-content" data-href="https://example.com/inside">inside</span>
+        </div>
+      </main>
+    `;
+
+    const root = document.getElementById('root');
+    if (!root) {
+      throw new Error('missing root');
+    }
+
+    const cleanup = wrapInterlinksWithAnchor(root);
+
+    expect(root.querySelector('a[data-print-link]')?.textContent).toBe(
+      'inside',
+    );
+    expect(document.querySelectorAll('a[data-print-link]')).toHaveLength(1);
+
+    cleanup();
+
+    expect(document.querySelectorAll('a[data-print-link]')).toHaveLength(0);
+  });
+});
diff --git a/src/frontend/apps/impress/src/features/docs/doc-export/utils_print.ts b/src/frontend/apps/impress/src/features/docs/doc-export/utils_print.ts
index 82a5ef65c4..ccb26d3c74 100644
--- a/src/frontend/apps/impress/src/features/docs/doc-export/utils_print.ts
+++ b/src/frontend/apps/impress/src/features/docs/doc-export/utils_print.ts
@@ -175,7 +175,7 @@ function appendPrintOnlyStyles() {
 /**
  * Wraps media elements with links to their source URLs for printing.
  */
-function wrapMediaWithLink() {
+export function wrapMediaWithLink(root: ParentNode = document) {
   const createdShadowWrapper: HTMLElement[] = [];
 
   const prependLink = (
@@ -222,7 +222,7 @@ function wrapMediaWithLink() {
     createdShadowWrapper.push(shadowWrapper);
   };
 
-  document
+  root
     .querySelectorAll(
       '[data-content-type="pdf"], [data-content-type="file"], [data-content-type="audio"], [data-content-type="video"]',
     )
@@ -251,14 +251,14 @@ function wrapMediaWithLink() {
  * Wraps interlink inline content with anchor tags for printing,
  * so they appear as clickable links in the printed PDF.
  */
-function wrapInterlinksWithAnchor() {
+export function wrapInterlinksWithAnchor(root: ParentNode = document) {
   const wrappedElements: Array<{
     el: Element;
     anchor: HTMLAnchorElement;
     parent: Node;
   }> = [];
 
-  document
+  root
     .querySelectorAll('.--docs--interlinking-link-inline-content[data-href]')
     .forEach((el) => {
       const href = el.getAttribute('data-href');
diff --git a/src/frontend/apps/impress/src/features/docs/doc-header/components/DocToolBox.tsx b/src/frontend/apps/impress/src/features/docs/doc-header/components/DocToolBox.tsx
index d052dcb101..8ad47dda48 100644
--- a/src/frontend/apps/impress/src/features/docs/doc-header/components/DocToolBox.tsx
+++ b/src/frontend/apps/impress/src/features/docs/doc-header/components/DocToolBox.tsx
@@ -32,6 +32,7 @@ import {
   useDocUtils,
   useDuplicateDoc,
 } from '@/docs/doc-management';
+import { usePresenterStore } from '@/docs/doc-presenter/stores';
 import { useAuth } from '@/features/auth';
 import { useFocusStore, useResponsiveStore } from '@/stores';
 
@@ -82,14 +83,6 @@ const ModalExport =
       )
     : null;
 
-const PresenterOverlay = dynamic(
-  () =>
-    import('@/docs/doc-presenter').then((mod) => ({
-      default: mod.PresenterOverlay,
-    })),
-  { ssr: false },
-);
-
 interface DocToolBoxProps {
   doc: Doc;
 }
@@ -108,11 +101,13 @@ export const DocToolBox = ({ doc }: DocToolBoxProps) => {
   const [isModalShareOpen, setIsModalShareOpen] = useState(false);
   const [isModalHistoryOpen, setIsModalHistoryOpen] = useState(false);
   const [isModalLeaveOpen, setIsModalLeaveOpen] = useState(false);
-  const [isPresenterOpen, setIsPresenterOpen] = useState(false);
 
   const { restoreFocus, addLastFocus } = useFocusStore();
   const { isMobile } = useResponsiveStore();
   const copyDocLink = useCopyDocLink(doc.id);
+  // Deep-link (#2397) and slide/URL sync live in PresenterRoot; here we only
+  // trigger the manual "Present" action.
+  const openPresenter = usePresenterStore((state) => state.open);
   const { mutate: duplicateDoc } = useDuplicateDoc({
     onSuccess: (data) => {
       void router.push(`/docs/${data.id}`);
@@ -148,9 +143,7 @@ export const DocToolBox = ({ doc }: DocToolBoxProps) => {
       label: t('Present'),
       icon: <Present width={24} height={24} aria-hidden="true" />,
       callback: () => {
-        requestAnimationFrame(() => {
-          setIsPresenterOpen(true);
-        });
+        openPresenter(0);
       },
       isHidden: Boolean(doc.deleted_at) || isMobile,
       testId: `docs-actions-present-${doc.id}`,
@@ -315,14 +308,6 @@ export const DocToolBox = ({ doc }: DocToolBoxProps) => {
           doc={doc}
         />
       )}
-      {isPresenterOpen && (
-        <PresenterOverlay
-          doc={doc}
-          onClose={() => {
-            setIsPresenterOpen(false);
-          }}
-        />
-      )}
     </>
   );
 };
diff --git a/src/frontend/apps/impress/src/features/docs/doc-presenter/__tests__/PresenterFloatingBar.spec.tsx b/src/frontend/apps/impress/src/features/docs/doc-presenter/__tests__/PresenterFloatingBar.spec.tsx
new file mode 100644
index 0000000000..fddd37021d
--- /dev/null
+++ b/src/frontend/apps/impress/src/features/docs/doc-presenter/__tests__/PresenterFloatingBar.spec.tsx
@@ -0,0 +1,41 @@
+import { render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { describe, expect, test, vi } from 'vitest';
+
+import { PresenterFloatingBar } from '../components/PresenterFloatingBar';
+
+vi.mock('react-i18next', () => ({
+  useTranslation: () => ({
+    t: (key: string) => key,
+  }),
+}));
+
+const noop = () => undefined;
+
+describe('PresenterFloatingBar', () => {
+  test('opens the grouped actions dropdown from the toolbar button', async () => {
+    render(
+      <PresenterFloatingBar
+        index={0}
+        total={3}
+        isFullscreen={false}
+        isExportingPdf={false}
+        onPrev={noop}
+        onNext={noop}
+        onCopyLink={noop}
+        onExportPdf={noop}
+        onToggleFullscreen={noop}
+        onClose={noop}
+      />,
+    );
+
+    await userEvent.click(screen.getByRole('button', { name: 'More options' }));
+
+    expect(
+      screen.getByRole('menuitem', { name: 'Copy link to slide' }),
+    ).toBeVisible();
+    expect(
+      screen.getByRole('menuitem', { name: 'Download PDF' }),
+    ).toBeVisible();
+  });
+});
diff --git a/src/frontend/apps/impress/src/features/docs/doc-presenter/__tests__/PresenterPrintDocument.spec.tsx b/src/frontend/apps/impress/src/features/docs/doc-presenter/__tests__/PresenterPrintDocument.spec.tsx
new file mode 100644
index 0000000000..5b360db86a
--- /dev/null
+++ b/src/frontend/apps/impress/src/features/docs/doc-presenter/__tests__/PresenterPrintDocument.spec.tsx
@@ -0,0 +1,77 @@
+import { render } from '@testing-library/react';
+import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest';
+
+import {
+  PRESENTER_PRINT_CONTENT_CLASS,
+  PRESENTER_PRINT_CSS,
+  PRESENTER_PRINT_LOGO_CLASS,
+  PRESENTER_PRINT_PAGE_CLASS,
+  PRESENTER_PRINT_PAGE_SELECTOR,
+  PRESENTER_PRINT_TITLE_CLASS,
+  PresenterPrintDocument,
+} from '../components/PresenterPrintDocument';
+
+type TestBlock = {
+  type: string;
+  content?: { type: 'text'; text: string; styles: Record<string, never> }[];
+};
+
+const para = (text: string): TestBlock => ({
+  type: 'paragraph',
+  content: [{ type: 'text', text, styles: {} }],
+});
+
+describe('PresenterPrintDocument', () => {
+  beforeEach(() => {
+    Object.defineProperty(window, 'matchMedia', {
+      configurable: true,
+      writable: true,
+      value: vi.fn().mockImplementation((query: string) => ({
+        addEventListener: vi.fn(),
+        addListener: vi.fn(),
+        dispatchEvent: vi.fn(),
+        matches: false,
+        media: query,
+        onchange: null,
+        removeEventListener: vi.fn(),
+        removeListener: vi.fn(),
+      })),
+    });
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  test('renders one print page per slide', () => {
+    const { container } = render(
+      <PresenterPrintDocument
+        slides={[
+          { kind: 'title', title: 'Deck title', showDividerHint: false },
+          { kind: 'content', blocks: [para('Slide one')] },
+          { kind: 'content', blocks: [para('Slide two')] },
+          { kind: 'content', blocks: [] },
+        ]}
+      />,
+    );
+
+    expect(
+      container.querySelectorAll(PRESENTER_PRINT_PAGE_SELECTOR),
+    ).toHaveLength(4);
+    expect(
+      container.querySelector(`.${PRESENTER_PRINT_TITLE_CLASS}`),
+    ).toHaveTextContent('Deck title');
+    expect(
+      container.querySelectorAll(`.${PRESENTER_PRINT_LOGO_CLASS}`),
+    ).toHaveLength(4);
+  });
+
+  test('centers short slide content vertically in print pages', () => {
+    expect(PRESENTER_PRINT_CSS).toContain(`.${PRESENTER_PRINT_PAGE_CLASS} {`);
+    expect(PRESENTER_PRINT_CSS).toContain('justify-content: safe center;');
+    expect(PRESENTER_PRINT_CSS).toContain(
+      `.${PRESENTER_PRINT_CONTENT_CLASS} {`,
+    );
+    expect(PRESENTER_PRINT_CSS).toContain('max-height: 100%;');
+  });
+});
diff --git a/src/frontend/apps/impress/src/features/docs/doc-presenter/__tests__/useSlides.spec.ts b/src/frontend/apps/impress/src/features/docs/doc-presenter/__tests__/useSlides.spec.ts
index 7409aa7870..198da3123f 100644
--- a/src/frontend/apps/impress/src/features/docs/doc-presenter/__tests__/useSlides.spec.ts
+++ b/src/frontend/apps/impress/src/features/docs/doc-presenter/__tests__/useSlides.spec.ts
@@ -1,13 +1,39 @@
 import { describe, expect, test } from 'vitest';
 
-import { getSlideTitle, splitBlocksIntoSlides } from '../hooks/useSlides';
+import {
+  getContentSlideIndexForBlock,
+  getSlideTitle,
+  hasDividerBlock,
+  splitBlocksIntoSlides,
+} from '../hooks/useSlides';
 
-const para = (text = 'hello') => ({
+type TestBlock = {
+  id?: string;
+  type: string;
+  content?: { type: 'text'; text: string }[];
+  props?: { url: string };
+  children?: TestBlock[];
+};
+
+const para = (text = 'hello', id?: string): TestBlock => ({
+  ...(id ? { id } : {}),
   type: 'paragraph',
   content: text === '' ? [] : [{ type: 'text', text }],
 });
-const divider = () => ({ type: 'divider' });
-const image = () => ({ type: 'image', props: { url: 'x' } });
+const divider = (children?: TestBlock[], id?: string): TestBlock => ({
+  ...(id ? { id } : {}),
+  type: 'divider',
+  ...(children ? { children } : {}),
+});
+const image = (id?: string): TestBlock => ({
+  ...(id ? { id } : {}),
+  type: 'image',
+  props: { url: 'x' },
+});
+const quote = (text: string): TestBlock => ({
+  type: 'quote',
+  content: [{ type: 'text', text }],
+});
 
 describe('splitBlocksIntoSlides', () => {
   test('no divider yields one slide', () => {
@@ -56,19 +82,84 @@ describe('splitBlocksIntoSlides', () => {
     expect(result[0]).toHaveLength(0);
   });
 
-  test('empty paragraphs are preserved as intentional spacing', () => {
+  test('leading empty paragraphs after dividers are removed', () => {
     const result = splitBlocksIntoSlides([
       para('a'),
       divider(),
       para(''),
       para('   '),
+      para('b'),
+    ]);
+    expect(result).toHaveLength(2);
+    expect(result[0][0]).toMatchObject({ content: [{ text: 'a' }] });
+    expect(result[1]).toHaveLength(1);
+    expect(result[1][0]).toMatchObject({ content: [{ text: 'b' }] });
+  });
+
+  test('empty paragraphs after content are preserved as intentional spacing', () => {
+    const result = splitBlocksIntoSlides([
+      para('a'),
       divider(),
       para('b'),
+      para(''),
+      para('   '),
     ]);
-    expect(result).toHaveLength(3);
+    expect(result).toHaveLength(2);
+    expect(result[1]).toHaveLength(3);
+    expect(result[1][0]).toMatchObject({ content: [{ text: 'b' }] });
+  });
+
+  test('trailing empty paragraphs before dividers are removed', () => {
+    const result = splitBlocksIntoSlides([
+      para('a'),
+      para(''),
+      para('   '),
+      divider(),
+      para('b'),
+    ]);
+    expect(result).toHaveLength(2);
+    expect(result[0]).toHaveLength(1);
     expect(result[0][0]).toMatchObject({ content: [{ text: 'a' }] });
-    expect(result[1]).toHaveLength(2);
-    expect(result[2][0]).toMatchObject({ content: [{ text: 'b' }] });
+    expect(result[1][0]).toMatchObject({ content: [{ text: 'b' }] });
+  });
+
+  test('empty paragraphs between content blocks before a divider are preserved', () => {
+    const result = splitBlocksIntoSlides([
+      para('a'),
+      para(''),
+      para('b'),
+      divider(),
+      para('c'),
+    ]);
+    expect(result).toHaveLength(2);
+    expect(result[0]).toHaveLength(3);
+    expect(result[0][0]).toMatchObject({ content: [{ text: 'a' }] });
+    expect(result[0][2]).toMatchObject({ content: [{ text: 'b' }] });
+  });
+
+  test('leading empty children under structural dividers are removed', () => {
+    const result = splitBlocksIntoSlides([
+      para('a'),
+      divider([para(''), para('   '), para('b')]),
+    ]);
+    expect(result).toHaveLength(2);
+    expect(result[1]).toMatchObject([
+      { type: 'divider', children: [{ content: [{ text: 'b' }] }] },
+    ]);
+  });
+
+  test('trailing empty children under structural dividers are removed before dividers', () => {
+    const result = splitBlocksIntoSlides([
+      para('a'),
+      divider([para('b'), para(''), para('   ')]),
+      divider(),
+      para('c'),
+    ]);
+    expect(result).toHaveLength(3);
+    expect(result[1]).toMatchObject([
+      { type: 'divider', children: [{ content: [{ text: 'b' }] }] },
+    ]);
+    expect(result[2][0]).toMatchObject({ content: [{ text: 'c' }] });
   });
 
   test('blocks within a group are kept verbatim, empty or not', () => {
@@ -83,6 +174,174 @@ describe('splitBlocksIntoSlides', () => {
     expect(result).toHaveLength(2);
     expect(result[1]).toHaveLength(1);
   });
+
+  test('children nested under dividers keep their nesting in the following slides', () => {
+    const hello = para('Hello');
+    const test2 = para('Test 2');
+    const after = quote('dfsqdqsdqs');
+    const firstDivider = divider([hello]);
+    const secondDivider = divider([test2]);
+    const result = splitBlocksIntoSlides([
+      para('Test 1'),
+      firstDivider,
+      secondDivider,
+      after,
+      para('fsdf'),
+    ]);
+
+    expect(result).toHaveLength(3);
+    expect(result[0]).toMatchObject([{ content: [{ text: 'Test 1' }] }]);
+    expect(result[1]).toEqual([firstDivider]);
+    expect(result[2]).toMatchObject([
+      { type: 'divider', children: [{ content: [{ text: 'Test 2' }] }] },
+      { type: 'quote', content: [{ text: 'dfsqdqsdqs' }] },
+      { content: [{ text: 'fsdf' }] },
+    ]);
+  });
+});
+
+describe('hasDividerBlock', () => {
+  test('returns false when no divider is present', () => {
+    expect(hasDividerBlock([para('a'), para('b')])).toBe(false);
+  });
+
+  test('returns true when a divider is present', () => {
+    expect(hasDividerBlock([para('a'), divider(), para('b')])).toBe(true);
+  });
+
+  test('returns true when a divider is nested', () => {
+    expect(
+      hasDividerBlock([quote('intro'), para('a'), divider([para('b')])]),
+    ).toBe(true);
+  });
+});
+
+describe('getContentSlideIndexForBlock', () => {
+  test('returns the slide containing a regular block', () => {
+    expect(
+      getContentSlideIndexForBlock(
+        [para('a', 'a'), divider(), para('b', 'b'), para('c', 'c')],
+        'c',
+      ),
+    ).toBe(1);
+  });
+
+  test('returns the following slide for a divider', () => {
+    expect(
+      getContentSlideIndexForBlock(
+        [para('a', 'a'), divider(undefined, 'divider'), para('b', 'b')],
+        'divider',
+      ),
+    ).toBe(1);
+  });
+
+  test('returns the first non-empty following slide for consecutive dividers', () => {
+    expect(
+      getContentSlideIndexForBlock(
+        [
+          para('a', 'a'),
+          divider(undefined, 'first-divider'),
+          divider(undefined, 'second-divider'),
+          para('b', 'b'),
+        ],
+        'first-divider',
+      ),
+    ).toBe(1);
+  });
+
+  test('skips empty-only slides after dividers when mapping divider links', () => {
+    expect(
+      getContentSlideIndexForBlock(
+        [
+          para('a', 'a'),
+          divider(undefined, 'first-divider'),
+          para('', 'empty-after-divider'),
+          divider(undefined, 'second-divider'),
+          para('b', 'b'),
+        ],
+        'first-divider',
+      ),
+    ).toBe(1);
+  });
+
+  test('maps a stripped empty block after a divider to the following content slide', () => {
+    expect(
+      getContentSlideIndexForBlock(
+        [
+          para('a', 'a'),
+          divider(undefined, 'divider'),
+          para('', 'empty-after-divider'),
+          para('b', 'b'),
+        ],
+        'empty-after-divider',
+      ),
+    ).toBe(1);
+  });
+
+  test('maps a stripped empty block before a divider to the previous content slide', () => {
+    expect(
+      getContentSlideIndexForBlock(
+        [
+          para('a', 'a'),
+          para('', 'empty-before-divider'),
+          divider(undefined, 'divider'),
+          para('b', 'b'),
+        ],
+        'empty-before-divider',
+      ),
+    ).toBe(0);
+  });
+
+  test('maps a stripped empty-only slide to the next rendered content slide', () => {
+    expect(
+      getContentSlideIndexForBlock(
+        [
+          para('a', 'a'),
+          divider(undefined, 'first-divider'),
+          para('', 'empty-between-dividers'),
+          divider(undefined, 'second-divider'),
+          para('b', 'b'),
+        ],
+        'empty-between-dividers',
+      ),
+    ).toBe(1);
+  });
+
+  test('maps a leading divider to the first content slide', () => {
+    expect(
+      getContentSlideIndexForBlock(
+        [divider(undefined, 'divider'), para('a', 'a')],
+        'divider',
+      ),
+    ).toBe(0);
+  });
+
+  test('maps a trailing divider to the last rendered content slide', () => {
+    expect(
+      getContentSlideIndexForBlock(
+        [para('a', 'a'), divider(undefined, 'divider')],
+        'divider',
+      ),
+    ).toBe(0);
+  });
+
+  test('finds blocks nested under a structural divider', () => {
+    expect(
+      getContentSlideIndexForBlock(
+        [para('a', 'a'), divider([para('nested', 'nested')], 'divider')],
+        'nested',
+      ),
+    ).toBe(1);
+  });
+
+  test('returns the first content slide when the block is missing', () => {
+    expect(
+      getContentSlideIndexForBlock(
+        [para('a', 'a'), divider(), para('b', 'b')],
+        'x',
+      ),
+    ).toBe(0);
+  });
 });
 
 const heading = (text: string) => ({
@@ -136,6 +395,10 @@ describe('getSlideTitle', () => {
     expect(getSlideTitle([{ type: 'divider' }, para('after')])).toBe('after');
   });
 
+  test('extracts text from blocks nested under structural dividers', () => {
+    expect(getSlideTitle([divider([para('nested text')])])).toBe('nested text');
+  });
+
   test('trims leading and trailing whitespace', () => {
     expect(getSlideTitle([para('  spaced  ')])).toBe('spaced');
   });
diff --git a/src/frontend/apps/impress/src/features/docs/doc-presenter/assets/logo-docs-mono.svg b/src/frontend/apps/impress/src/features/docs/doc-presenter/assets/logo-docs-mono.svg
new file mode 100644
index 0000000000..0fbf6c8d1f
--- /dev/null
+++ b/src/frontend/apps/impress/src/features/docs/doc-presenter/assets/logo-docs-mono.svg
@@ -0,0 +1,10 @@
+<svg width="80" height="32" viewBox="0 0 80 32" fill="none" xmlns="http://www.w3.org/2000/svg">
+<g opacity="0.2">
+<path d="M20.504 26.2648C21.4382 26.0029 22.3329 25.5248 22.92 24.6801C23.4995 23.8529 23.6627 22.8036 23.6627 21.7939V7.00065C23.6627 6.73872 23.6485 6.47631 23.6169 6.21704C24.0809 6.39955 24.4385 6.70112 24.6897 7.12176C24.9861 7.60005 25.1343 8.22991 25.1343 9.01133V24.037C25.1343 25.0946 24.875 25.8861 24.3563 26.4116C23.8376 26.937 23.0561 27.1997 22.012 27.1997H16.3363C16.4708 27.1762 16.6055 27.152 16.7406 27.127C17.925 26.9154 19.1767 26.6282 20.4944 26.2675L20.504 26.2648Z" fill="#222631"/>
+<path fill-rule="evenodd" clip-rule="evenodd" d="M6.86523 23.7239V8.67802C6.86523 7.76186 7.11111 7.06801 7.60287 6.59646C8.10137 6.12491 8.76154 5.86555 9.58339 5.8184C10.7959 5.7443 11.9445 5.64325 13.0291 5.51526C14.1136 5.38053 15.1511 5.22559 16.1413 5.05044C17.1383 4.8753 18.1084 4.67994 19.0515 4.46437C20.0215 4.23533 20.7659 4.34985 21.2846 4.80793C21.8033 5.26601 22.0626 5.99691 22.0626 7.00064V21.7939C22.0626 22.6763 21.9111 23.3331 21.6079 23.7643C21.3048 24.2021 20.7928 24.5221 20.072 24.7242C18.7921 25.0745 17.5863 25.3507 16.4546 25.5528C15.3228 25.7616 14.2181 25.9199 13.1402 26.0277C12.0624 26.1355 10.9576 26.2197 9.8259 26.2803C8.88953 26.3342 8.162 26.1389 7.64329 25.6943C7.12459 25.2564 6.86523 24.5996 6.86523 23.7239ZM10.5665 11.4098C12.0504 11.3154 13.4101 11.1703 14.6456 10.9745C14.9454 10.9256 15.2447 10.8747 15.5429 10.8219C15.8549 10.7667 16.0806 10.4947 16.0806 10.1785C16.0806 9.76909 15.71 9.46073 15.3076 9.52937C15.0764 9.5688 14.844 9.60712 14.6104 9.64435C13.3873 9.83924 12.0358 9.98384 10.5558 10.078C10.3342 10.0923 10.1578 10.1614 10.0445 10.299C9.93728 10.4291 9.88477 10.5857 9.88477 10.7641C9.88477 10.9455 9.94598 11.1035 10.0682 11.2333L10.0699 11.235C10.2023 11.3674 10.3706 11.4247 10.5665 11.4098ZM10.566 14.7647C12.0501 14.6702 13.41 14.5252 14.6456 14.3293C15.8866 14.127 17.1145 13.8909 18.3286 13.6211C18.5749 13.5664 18.7595 13.4801 18.8518 13.3462C18.9425 13.2175 18.9874 13.07 18.9874 12.9064C18.9874 12.722 18.9171 12.5631 18.7804 12.434C18.6332 12.2949 18.4275 12.2626 18.1839 12.3127L18.1824 12.3131C17.0255 12.5754 15.8348 12.8041 14.6104 12.9992C13.3873 13.1941 12.0358 13.3387 10.5558 13.4329C10.3342 13.4472 10.1578 13.5162 10.0445 13.6538C9.93782 13.7833 9.88477 13.9363 9.88477 14.1089C9.88477 14.2961 9.94528 14.4577 10.0681 14.5882L10.0716 14.5915C10.2036 14.7157 10.3701 14.7723 10.564 14.7648L10.566 14.7647ZM10.5664 18.1194C12.0503 18.0182 13.4101 17.8698 14.6456 17.674C15.8867 17.4784 17.1144 17.2457 18.3286 16.9758C18.5755 16.921 18.7602 16.8311 18.8524 16.69C18.9423 16.5622 18.9874 16.4185 18.9874 16.2612C18.9874 16.0767 18.9171 15.9178 18.7804 15.7887C18.6332 15.6497 18.4275 15.6173 18.1839 15.6675L18.1828 15.6677C17.0258 15.9233 15.835 16.1487 14.6104 16.3438C13.3872 16.5387 12.0356 16.6867 10.5556 16.7876C10.334 16.8019 10.1578 16.871 10.0445 17.0086C9.93782 17.1381 9.88477 17.291 9.88477 17.4636C9.88477 17.6508 9.94528 17.8125 10.0681 17.9429L10.0716 17.9463C10.2036 18.0705 10.3701 18.127 10.564 18.1196L10.5664 18.1194ZM14.6456 21.0055C13.4101 21.2013 12.0504 21.3463 10.5665 21.4408C10.3706 21.4557 10.2023 21.3984 10.0699 21.266L10.0682 21.2642C9.94601 21.1344 9.88477 20.9765 9.88477 20.7951C9.88477 20.6167 9.93728 20.4601 10.0445 20.33C10.1578 20.1923 10.3342 20.1233 10.5559 20.109C12.0358 20.0148 13.3873 19.8702 14.6104 19.6753C14.844 19.6381 15.0764 19.5998 15.3076 19.5603C15.71 19.4917 16.0806 19.8001 16.0806 20.2095C16.0806 20.5257 15.8549 20.7976 15.5429 20.8529C15.2447 20.9057 14.9454 20.9566 14.6456 21.0055Z" fill="#222631"/>
+<path d="M32.9608 22.3601C32.8724 22.3601 32.8008 22.2885 32.8008 22.2001V9.7601C32.8008 9.67173 32.8724 9.6001 32.9608 9.6001H37.7772C38.7858 9.6001 39.7033 9.77023 40.5297 10.1105C41.3561 10.4508 42.067 10.9186 42.6624 11.5141C43.2701 12.0974 43.7318 12.7719 44.0478 13.5375C44.3759 14.3031 44.54 15.1173 44.54 15.9801C44.54 16.8429 44.3759 17.6571 44.0478 18.4227C43.7318 19.1883 43.2701 19.8689 42.6624 20.4643C42.067 21.0476 41.3561 21.5094 40.5297 21.8497C39.7033 22.19 38.7858 22.3601 37.7772 22.3601H32.9608ZM37.7954 11.6235H35.2029C35.1145 11.6235 35.0429 11.6951 35.0429 11.7835V20.1767C35.0429 20.2651 35.1145 20.3367 35.2029 20.3367H37.7954C38.4395 20.3367 39.0289 20.2274 39.5636 20.0086C40.1104 19.7777 40.5783 19.4618 40.9672 19.0607C41.3682 18.6597 41.6781 18.1979 41.8968 17.6754C42.1156 17.1528 42.225 16.5877 42.225 15.9801C42.225 15.3725 42.1156 14.8074 41.8968 14.2848C41.6781 13.7501 41.3682 13.2883 40.9672 12.8995C40.5783 12.4984 40.1104 12.1886 39.5636 11.9698C39.0289 11.7389 38.4395 11.6235 37.7954 11.6235Z" fill="#222631"/>
+<path d="M50.7159 20.4826C51.1291 20.4826 51.5119 20.4036 51.8643 20.2456C52.2167 20.0755 52.5205 19.8507 52.7757 19.5712C53.0431 19.2917 53.2497 18.9696 53.3955 18.6051C53.5413 18.2283 53.6143 17.8273 53.6143 17.402C53.6143 16.8187 53.4867 16.2961 53.2315 15.8343C52.9762 15.3725 52.6299 15.008 52.1924 14.7406C51.7549 14.4611 51.2628 14.3214 50.7159 14.3214C50.2906 14.3214 49.8956 14.4003 49.5311 14.5583C49.1786 14.7163 48.8687 14.935 48.6014 15.2146C48.3462 15.4941 48.1457 15.8222 47.9999 16.1989C47.854 16.5756 47.7811 16.9766 47.7811 17.402C47.7811 17.9731 47.9087 18.4957 48.1639 18.9696C48.4191 19.4314 48.7654 19.8021 49.2029 20.0816C49.6526 20.3489 50.1569 20.4826 50.7159 20.4826ZM50.6977 12.4438C51.439 12.4438 52.1134 12.5714 52.721 12.8266C53.3408 13.0818 53.8694 13.4403 54.3069 13.9021C54.7566 14.3517 55.0968 14.8804 55.3277 15.488C55.5708 16.0834 55.6923 16.7214 55.6923 17.402C55.6923 18.0825 55.5708 18.7266 55.3277 19.3342C55.0968 19.9297 54.7566 20.4583 54.3069 20.9201C53.8694 21.3697 53.3408 21.7222 52.721 21.9774C52.1134 22.2326 51.439 22.3602 50.6977 22.3602C49.9564 22.3602 49.2759 22.2326 48.6561 21.9774C48.0485 21.7222 47.5198 21.3697 47.0702 20.9201C46.6206 20.4583 46.2742 19.9297 46.0312 19.3342C45.8003 18.7266 45.6848 18.0825 45.6848 17.402C45.6848 16.7214 45.8003 16.0834 46.0312 15.488C46.2742 14.8804 46.6206 14.3517 47.0702 13.9021C47.5198 13.4403 48.0485 13.0818 48.6561 12.8266C49.2759 12.5714 49.9564 12.4438 50.6977 12.4438Z" fill="#222631"/>
+<path d="M61.8289 12.4438C62.6674 12.4438 63.4148 12.6139 64.071 12.9542C64.6897 13.2579 65.2042 13.6657 65.6146 14.1776C65.6696 14.2461 65.6552 14.3459 65.5853 14.399L64.2623 15.4026C64.1885 15.4586 64.0829 15.44 64.0268 15.3662C63.8074 15.0774 63.5244 14.8385 63.1778 14.6495C62.789 14.4307 62.3332 14.3214 61.8107 14.3214C61.3854 14.3214 60.9904 14.4003 60.6258 14.5583C60.2734 14.7163 59.9696 14.935 59.7144 15.2146C59.4592 15.4941 59.2587 15.8222 59.1129 16.1989C58.967 16.5635 58.8941 16.9645 58.8941 17.402C58.8941 17.9853 59.0217 18.5139 59.2769 18.9879C59.5321 19.4497 59.8785 19.8142 60.316 20.0816C60.7534 20.3489 61.2638 20.4826 61.8472 20.4826C62.3454 20.4826 62.789 20.3732 63.1778 20.1545C63.5244 19.9655 63.8074 19.7266 64.0268 19.4378C64.0829 19.364 64.1885 19.3453 64.2623 19.4014L65.584 20.404C65.6544 20.4575 65.6684 20.5582 65.6124 20.6266C65.2023 21.1277 64.6885 21.5354 64.071 21.8498C63.4148 22.19 62.6674 22.3602 61.8289 22.3602C60.796 22.3602 59.9028 22.1353 59.1493 21.6857C58.3959 21.2239 57.8126 20.6163 57.3994 19.8628C56.9984 19.1094 56.7978 18.2891 56.7978 17.402C56.7978 16.7336 56.9133 16.1017 57.1442 15.5062C57.3751 14.9107 57.7093 14.3821 58.1468 13.9203C58.5842 13.4585 59.1129 13.1 59.7326 12.8448C60.3524 12.5775 61.0512 12.4438 61.8289 12.4438Z" fill="#222631"/>
+<path d="M68.7348 15.1234C68.7348 15.4151 68.8381 15.6581 69.0447 15.8526C69.2634 16.0348 69.5429 16.1928 69.8832 16.3265C70.2234 16.4602 70.5819 16.606 70.9587 16.764C71.3475 16.9098 71.7121 17.0921 72.0524 17.3108C72.3926 17.5174 72.6661 17.7969 72.8727 18.1494C73.0914 18.4896 73.2008 18.921 73.2008 19.4436C73.2008 20.0634 73.0489 20.592 72.7451 21.0295C72.4534 21.4548 72.0645 21.7829 71.5784 22.0138C71.0923 22.2447 70.5576 22.3602 69.9743 22.3602C69.1844 22.3602 68.4978 22.2143 67.9145 21.9227C67.377 21.6427 66.9015 21.2751 66.4878 20.8198C66.4289 20.755 66.4361 20.6549 66.5019 20.597L67.6246 19.609C67.6931 19.5487 67.7979 19.5581 67.8576 19.6273C68.1218 19.9337 68.4142 20.1884 68.7348 20.3915C69.0994 20.6224 69.5065 20.7378 69.9561 20.7378C70.3814 20.7378 70.7035 20.6284 70.9222 20.4097C71.1531 20.1788 71.2686 19.8993 71.2686 19.5712C71.2686 19.2674 71.1592 19.0243 70.9404 18.842C70.7338 18.6598 70.4604 18.5018 70.1202 18.3681C69.7799 18.2344 69.4153 18.0947 69.0264 17.9488C68.6497 17.7909 68.2912 17.6025 67.951 17.3838C67.6107 17.165 67.3312 16.8855 67.1124 16.5452C66.9058 16.1928 66.8026 15.7432 66.8026 15.1963C66.8026 14.6859 66.9362 14.2241 67.2036 13.811C67.4709 13.3856 67.8416 13.0514 68.3155 12.8084C68.8016 12.5653 69.3546 12.4438 69.9743 12.4438C70.6427 12.4438 71.2625 12.5896 71.8336 12.8813C72.3653 13.1471 72.7909 13.4785 73.1106 13.8756C73.163 13.9407 73.1516 14.0352 73.088 14.0895L71.9649 15.0479C71.8941 15.1083 71.787 15.0955 71.7283 15.0232C71.5209 14.7678 71.2826 14.5521 71.0134 14.376C70.6974 14.1694 70.351 14.0662 69.9743 14.0662C69.707 14.0662 69.4761 14.1148 69.2816 14.212C69.0994 14.3092 68.9596 14.4368 68.8624 14.5948C68.7773 14.7528 68.7348 14.929 68.7348 15.1234Z" fill="#222631"/>
+</g>
+</svg>
diff --git a/src/frontend/apps/impress/src/features/docs/doc-presenter/components/PresenterDividerHint.tsx b/src/frontend/apps/impress/src/features/docs/doc-presenter/components/PresenterDividerHint.tsx
new file mode 100644
index 0000000000..352f9730ee
--- /dev/null
+++ b/src/frontend/apps/impress/src/features/docs/doc-presenter/components/PresenterDividerHint.tsx
@@ -0,0 +1,271 @@
+import { Button } from '@gouvfr-lasuite/cunningham-react';
+import {
+  Divider as DividerIcon,
+  Info,
+  XMark,
+} from '@gouvfr-lasuite/ui-kit/icons';
+import { useTranslation } from 'react-i18next';
+import { css } from 'styled-components';
+
+import { Box, Text } from '@/components';
+
+interface PresenterDividerHintProps {
+  onDismiss: () => void;
+}
+
+// Shared by every text node in the hint (the line-height/flex/etc. differ and
+// stay per-element).
+const marianneFontCss = css`
+  font-family: Marianne, var(--c--globals--font--families--base);
+`;
+
+const hintCss = css`
+  position: relative;
+  flex-direction: column !important;
+  align-items: flex-start;
+  width: 309px;
+  height: 196px;
+  box-sizing: border-box;
+  overflow: hidden;
+  border: 1px solid var(--c--contextuals--border--surface--primary, #dfe2ea);
+  border-radius: 8px;
+  background: var(--c--contextuals--background--surface--primary, #fff);
+  box-shadow: 0 2px 4px 0 rgba(0, 0, 0, 0.05);
+`;
+
+const hintHeaderCss = css`
+  position: relative;
+  flex-direction: row !important;
+  align-items: center;
+  gap: 12px;
+  width: 100%;
+  height: 60px;
+  box-sizing: border-box;
+  flex-shrink: 0;
+  overflow: hidden;
+  padding: 12px 32px 12px 12px;
+  border-bottom: 1px solid
+    var(--c--contextuals--border--surface--primary, #dfe2ea);
+  background: var(--c--contextuals--background--surface--tertiary, #f6f8f9);
+  color: var(--c--contextuals--content--semantic--neutral--tertiary, #626a80);
+
+  & > svg {
+    width: 24px;
+    height: 24px;
+    flex-shrink: 0;
+  }
+`;
+
+const closeButtonCss = css`
+  position: absolute;
+  top: 4px;
+  right: 4px;
+
+  .c__button {
+    width: 24px;
+    min-width: 24px;
+    height: 24px;
+    min-height: 24px;
+    padding: 4px;
+    border-radius: 4px;
+  }
+
+  .c__button svg {
+    width: 16px;
+    height: 16px;
+  }
+`;
+
+const hintBodyCss = css`
+  position: relative;
+  width: 100%;
+  height: 136px;
+  flex-shrink: 0;
+  overflow: hidden;
+`;
+
+const commandCss = css`
+  position: absolute;
+  top: 24px;
+  left: 60px;
+  flex-direction: row !important;
+  align-items: center;
+  justify-content: center;
+  gap: 2px;
+  height: 24px;
+  padding-right: 2px;
+  border-radius: 2px;
+  color: var(--c--contextuals--content--semantic--neutral--primary, #222631);
+  font-family: Inter, var(--c--globals--font--families--base);
+
+  &::before {
+    position: absolute;
+    inset: -2px -2px -2px -3px;
+    border-radius: 4px;
+    background: var(
+      --c--contextuals--background--semantic--overlay--primary,
+      rgba(24, 27, 36, 0.05)
+    );
+    content: '';
+  }
+`;
+
+const filteredMenuCss = css`
+  position: absolute;
+  top: 53px;
+  left: 55px;
+  width: 200px;
+  overflow: hidden;
+  border: 1px solid var(--c--contextuals--border--surface--primary, #dfe2ea);
+  border-radius: 8px;
+  background: var(--c--contextuals--background--surface--primary, #fff);
+  box-shadow: 0 2px 4px 0 rgba(0, 0, 0, 0.05);
+`;
+
+const filteredTitleSectionCss = css`
+  flex-direction: row !important;
+  align-items: center;
+  justify-content: center;
+  width: 100%;
+  box-sizing: border-box;
+  padding: 8px 8px 2px;
+`;
+
+const filteredItemCss = css`
+  flex-direction: row !important;
+  align-items: center;
+  gap: 6px;
+  width: 100%;
+  height: 32px;
+  box-sizing: border-box;
+  padding: 8px;
+  background: var(
+    --c--contextuals--background--semantic--overlay--primary,
+    rgba(24, 27, 36, 0.05)
+  );
+
+  svg {
+    width: 16px;
+    height: 16px;
+    flex-shrink: 0;
+  }
+`;
+
+export const PresenterDividerHint = ({
+  onDismiss,
+}: PresenterDividerHintProps) => {
+  const { t } = useTranslation();
+  return (
+    <Box $css={hintCss}>
+      <Box $css={hintHeaderCss}>
+        <Info
+          aria-hidden="true"
+          color="var(--c--contextuals--content--semantic--neutral--tertiary)"
+        />
+        <Text
+          as="p"
+          $color="var(--c--contextuals--content--semantic--neutral--tertiary)"
+          $size="14px"
+          $weight="500"
+          $margin={{ all: '0' }}
+          $css={css`
+            flex: 1;
+            min-width: 0;
+            ${marianneFontCss}
+            line-height: 18px;
+            word-break: break-word;
+          `}
+        >
+          {t('You can use the divider to tell Docs where to split your slides')}
+        </Text>
+        <Box $css={closeButtonCss}>
+          <Button
+            size="nano"
+            color="neutral"
+            variant="tertiary"
+            aria-label={t('Close')}
+            icon={<XMark aria-hidden="true" />}
+            onClick={onDismiss}
+          />
+        </Box>
+      </Box>
+      <Box $css={hintBodyCss}>
+        <Box $css={commandCss} aria-hidden="true">
+          <Text
+            as="span"
+            $size="16px"
+            $css={css`
+              position: relative;
+              line-height: 24px;
+            `}
+          >
+            /
+          </Text>
+          <Text
+            as="span"
+            $size="16px"
+            $css={css`
+              position: relative;
+              line-height: 24px;
+            `}
+          >
+            Divider|
+          </Text>
+        </Box>
+        <Box $css={filteredMenuCss} aria-hidden="true">
+          <Box $css={filteredTitleSectionCss}>
+            <Text
+              as="span"
+              $size="12px"
+              $weight="700"
+              $color="var(--c--contextuals--content--semantic--neutral--tertiary, #626a80)"
+              $css={css`
+                flex: 1;
+                min-width: 0;
+                ${marianneFontCss}
+                line-height: 16px;
+                word-break: break-word;
+              `}
+            >
+              {t('Filtered results')}
+            </Text>
+          </Box>
+          <Box $css={filteredItemCss}>
+            <DividerIcon aria-hidden="true" />
+            <Text
+              as="span"
+              $size="12px"
+              $weight="500"
+              $css={css`
+                flex: 1;
+                min-width: 0;
+                overflow: hidden;
+                ${marianneFontCss}
+                line-height: 16px;
+                text-overflow: ellipsis;
+                white-space: nowrap;
+              `}
+            >
+              {t('Divider')}
+            </Text>
+            <Text
+              as="span"
+              $size="12px"
+              $color="var(--c--contextuals--content--semantic--neutral--tertiary, #626a80)"
+              $css={css`
+                overflow: hidden;
+                ${marianneFontCss}
+                line-height: 16px;
+                text-align: right;
+                text-overflow: ellipsis;
+                white-space: nowrap;
+              `}
+            >
+              ---
+            </Text>
+          </Box>
+        </Box>
+      </Box>
+    </Box>
+  );
+};
diff --git a/src/frontend/apps/impress/src/features/docs/doc-presenter/components/PresenterDocsLogo.tsx b/src/frontend/apps/impress/src/features/docs/doc-presenter/components/PresenterDocsLogo.tsx
new file mode 100644
index 0000000000..f690c8abe8
--- /dev/null
+++ b/src/frontend/apps/impress/src/features/docs/doc-presenter/components/PresenterDocsLogo.tsx
@@ -0,0 +1,23 @@
+import { css } from 'styled-components';
+
+import { Box } from '@/components';
+
+import LogoDocsMonoSVG from '../assets/logo-docs-mono.svg';
+
+const logoCss = css`
+  width: 80px;
+  height: 32px;
+  pointer-events: none;
+
+  svg {
+    display: block;
+    width: 80px;
+    height: 32px;
+  }
+`;
+
+export const PresenterDocsLogo = () => (
+  <Box $css={logoCss} aria-hidden="true">
+    <LogoDocsMonoSVG />
+  </Box>
+);
diff --git a/src/frontend/apps/impress/src/features/docs/doc-presenter/components/PresenterFloatingBar.tsx b/src/frontend/apps/impress/src/features/docs/doc-presenter/components/PresenterFloatingBar.tsx
index 5544a01b22..817b7ed3f2 100644
--- a/src/frontend/apps/impress/src/features/docs/doc-presenter/components/PresenterFloatingBar.tsx
+++ b/src/frontend/apps/impress/src/features/docs/doc-presenter/components/PresenterFloatingBar.tsx
@@ -1,14 +1,18 @@
 import { Button } from '@gouvfr-lasuite/cunningham-react';
+import { DropdownMenu, DropdownMenuItem } from '@gouvfr-lasuite/ui-kit';
 import {
   ChevronLeft,
   ChevronRight,
+  Download,
+  Link,
   Maximize,
   Minimize,
+  Share,
   XMark,
 } from '@gouvfr-lasuite/ui-kit/icons';
-import { useEffect, useRef } from 'react';
+import { MouseEvent, useEffect, useMemo, useRef, useState } from 'react';
 import { useTranslation } from 'react-i18next';
-import { css } from 'styled-components';
+import { createGlobalStyle, css } from 'styled-components';
 
 import { Box, Text } from '@/components';
 
@@ -18,13 +22,17 @@ interface PresenterFloatingBarProps {
   isFullscreen: boolean;
   onPrev: () => void;
   onNext: () => void;
+  onCopyLink: () => void;
+  onExportPdf: () => void;
   onToggleFullscreen: () => void;
   onClose: () => void;
+  isExportingPdf: boolean;
 }
 
 const barCss = css`
+  height: 32px;
   position: fixed;
-  bottom: 1.5rem;
+  bottom: 16px;
   left: 50%;
   transform: translateX(-50%);
   z-index: 1;
@@ -39,13 +47,48 @@ const barCss = css`
   border: 1px solid var(--c--contextuals--border--surface--primary);
   background: var(--c--contextuals--background--surface--primary);
   box-shadow: 0 2px 4px 0 rgba(0, 0, 0, 0.05);
+
+  button {
+    width: 24px;
+    min-width: 24px;
+    height: 24px;
+    min-height: 24px;
+    padding: 0;
+    border-radius: 4px;
+  }
+
+  button svg {
+    width: 16px;
+    height: 16px;
+  }
 `;
 
 const separatorCss = css`
   width: 1px;
   height: 1.25rem;
   background: var(--c--theme--colors--greyscale-200, #e5e5e5);
-  margin: 0 0.25rem;
+`;
+
+// The ui-kit DropdownMenu renders its popover in a React Aria portal at the
+// document root, outside the presenter overlay's stacking context — so its
+// z-index (and width) can only be raised above the overlay via a global style.
+// Mounted only while the menu is open (see render below).
+const presenterDropdownLayerZIndex = 1002;
+
+const PresenterDropdownLayerStyle = createGlobalStyle`
+  .react-aria-Popover {
+    z-index: ${presenterDropdownLayerZIndex};
+  }
+
+  .react-aria-Popover .c__dropdown-menu--tiny {
+    width: 150px;
+    min-width: 150px;
+  }
+
+  .react-aria-Popover .c__dropdown-menu--tiny .c__dropdown-menu-item {
+    box-sizing: border-box;
+    height: 32px;
+  }
 `;
 
 export const PresenterFloatingBar = ({
@@ -54,12 +97,16 @@ export const PresenterFloatingBar = ({
   isFullscreen,
   onPrev,
   onNext,
+  onCopyLink,
+  onExportPdf,
   onToggleFullscreen,
   onClose,
+  isExportingPdf,
 }: PresenterFloatingBarProps) => {
   const { t } = useTranslation();
   const isFirst = index <= 0;
   const isLast = index >= total - 1;
+  const [isActionsOpen, setIsActionsOpen] = useState(false);
 
   // Move focus into the dialog on open so keyboard users land on the
   // controls (an ARIA dialog must move focus inside itself; here on the
@@ -76,53 +123,101 @@ export const PresenterFloatingBar = ({
     return () => cancelAnimationFrame(id);
   }, []);
 
+  // The DropdownMenu is controlled (isOpen/onOpenChange); stop the click from
+  // also reaching the overlay so the menu toggles cleanly.
+  const toggleActions = (event: MouseEvent<HTMLElement>) => {
+    event.stopPropagation();
+    event.preventDefault();
+    setIsActionsOpen((isOpen) => !isOpen);
+  };
+
+  const actionOptions = useMemo<DropdownMenuItem[]>(
+    () => [
+      {
+        label: t('Copy link to slide'),
+        icon: <Link aria-hidden="true" width="16" height="16" />,
+        callback: onCopyLink,
+      },
+      {
+        label: t('Download PDF'),
+        icon: <Download aria-hidden="true" width="16" height="16" />,
+        callback: onExportPdf,
+        isDisabled: isExportingPdf,
+      },
+    ],
+    [isExportingPdf, onCopyLink, onExportPdf, t],
+  );
+
   return (
-    <Box
-      ref={barRef}
-      $direction="row"
-      $align="center"
-      $css={barCss}
-      role="toolbar"
-      aria-label={t('Presenter controls')}
-    >
-      <Button
-        size="small"
-        color="neutral"
-        variant="tertiary"
-        disabled={isFirst}
-        onClick={onPrev}
-        aria-label={t('Previous slide')}
-        icon={<ChevronLeft />}
-      />
-      <Text as="span" $size="sm" $color="neutral" aria-hidden="true">
-        {index + 1} / {total}
-      </Text>
-      <Button
-        size="small"
-        color="neutral"
-        variant="tertiary"
-        disabled={isLast}
-        onClick={onNext}
-        aria-label={t('Next slide')}
-        icon={<ChevronRight />}
-      />
-      <Box $css={separatorCss} aria-hidden />
-      <Button
-        size="small"
-        color="neutral"
-        variant="tertiary"
-        onClick={onToggleFullscreen}
-        aria-label={isFullscreen ? t('Exit fullscreen') : t('Enter fullscreen')}
-        icon={isFullscreen ? <Minimize /> : <Maximize />}
-      />
-      <Button
-        size="small"
-        color="neutral"
-        variant="tertiary"
-        onClick={onClose}
-        aria-label={t('Close presenter')}
-        icon={<XMark />}
-      />
-    </Box>
+    <>
+      {isActionsOpen && <PresenterDropdownLayerStyle />}
+      <Box
+        ref={barRef}
+        $direction="row"
+        $align="center"
+        $css={barCss}
+        role="toolbar"
+        aria-label={t('Presenter controls')}
+      >
+        <Button
+          size="nano"
+          color="neutral"
+          variant="tertiary"
+          disabled={isFirst}
+          onClick={onPrev}
+          aria-label={t('Previous slide')}
+          icon={<ChevronLeft />}
+        />
+        <Text as="span" $size="sm" $color="neutral" aria-hidden="true">
+          {index + 1} / {total}
+        </Text>
+        <Button
+          size="nano"
+          color="neutral"
+          variant="tertiary"
+          disabled={isLast}
+          onClick={onNext}
+          aria-label={t('Next slide')}
+          icon={<ChevronRight />}
+        />
+        <Box $css={separatorCss} aria-hidden />
+        <DropdownMenu
+          options={actionOptions}
+          isOpen={isActionsOpen}
+          onOpenChange={setIsActionsOpen}
+          shouldCloseOnInteractOutside={() => true}
+          variant="tiny"
+        >
+          <Button
+            size="nano"
+            color="neutral"
+            variant="tertiary"
+            onClick={toggleActions}
+            aria-label={t('More options')}
+            aria-expanded={isActionsOpen}
+            aria-haspopup="menu"
+            icon={<Share />}
+          />
+        </DropdownMenu>
+        <Button
+          size="nano"
+          color="neutral"
+          variant="tertiary"
+          onClick={onToggleFullscreen}
+          aria-label={
+            isFullscreen ? t('Exit fullscreen') : t('Enter fullscreen')
+          }
+          icon={isFullscreen ? <Minimize /> : <Maximize />}
+        />
+        <Button
+          size="nano"
+          color="neutral"
+          variant="tertiary"
+          onClick={onClose}
+          aria-label={t('Close presenter')}
+          icon={<XMark />}
+        />
+      </Box>
+    </>
   );
 };
diff --git a/src/frontend/apps/impress/src/features/docs/doc-presenter/components/PresenterOverlay.tsx b/src/frontend/apps/impress/src/features/docs/doc-presenter/components/PresenterOverlay.tsx
index b8fb62f5db..02691546ed 100644
--- a/src/frontend/apps/impress/src/features/docs/doc-presenter/components/PresenterOverlay.tsx
+++ b/src/frontend/apps/impress/src/features/docs/doc-presenter/components/PresenterOverlay.tsx
@@ -7,19 +7,28 @@ import { css } from 'styled-components';
 
 import { Box } from '@/components';
 import { useEditorStore } from '@/docs/doc-editor/stores';
-import { Doc } from '@/docs/doc-management';
+import { Doc, getEmojiAndTitle } from '@/docs/doc-management';
 
 import { PRESENTER_WINDOW_RADIUS } from '../constants';
 import { useBrowserFullscreen } from '../hooks/useBrowserFullscreen';
+import { useCopyPresenterLink } from '../hooks/useCopyPresenterLink';
 import { usePresenterShortcuts } from '../hooks/usePresenterShortcuts';
-import { getSlideTitle, useSlides } from '../hooks/useSlides';
+import { getSlideTitle, hasDividerBlock, useSlides } from '../hooks/useSlides';
+import { PresenterBlock, PresenterSlideData } from '../types';
+import { printPresenterSlides } from '../utils_print';
 
+import { PresenterDividerHint } from './PresenterDividerHint';
+import { PresenterDocsLogo } from './PresenterDocsLogo';
 import { PresenterFloatingBar } from './PresenterFloatingBar';
 import { PresenterSlide } from './PresenterSlide';
 
 interface PresenterOverlayProps {
   doc: Doc;
   onClose: () => void;
+  /** 0-based slide to start on (e.g. from a `?slide=` deep-link). */
+  initialIndex?: number;
+  /** Notified whenever the current slide changes (used to sync the URL). */
+  onIndexChange?: (index: number) => void;
 }
 
 const overlayCss = css`
@@ -38,12 +47,29 @@ const slideAreaCss = css`
   background: white;
 `;
 
+const docsLogoCss = css`
+  position: fixed;
+  bottom: 1rem;
+  left: 1rem;
+  z-index: 1;
+`;
+
+const dividerHintCss = css`
+  position: fixed;
+  top: 2rem;
+  left: 2rem;
+  z-index: 1;
+`;
+
 export const PresenterOverlay = ({
-  doc: _doc,
+  doc,
   onClose,
+  initialIndex = 0,
+  onIndexChange,
 }: PresenterOverlayProps) => {
   const { t } = useTranslation();
   const editor = useEditorStore((state) => state.editor);
+  const copyPresenterLink = useCopyPresenterLink(doc.id);
 
   // Snapshot the editor's blocks once at mount. Subsequent collaborator
   // edits do not affect the ongoing presentation (by design).
@@ -53,8 +79,30 @@ export const PresenterOverlay = ({
   }
   const snapshotBlocks = snapshotRef.current;
 
-  const slides = useSlides(snapshotBlocks as { type: string }[]);
-  const [currentIndex, setCurrentIndex] = useState(0);
+  const contentSlides = useSlides(snapshotBlocks as PresenterBlock[]);
+  const hasDividers = useMemo(
+    () => hasDividerBlock(snapshotBlocks as PresenterBlock[]),
+    [snapshotBlocks],
+  );
+  const title = useMemo(() => {
+    const { titleWithoutEmoji } = getEmojiAndTitle(doc.title ?? '');
+    return titleWithoutEmoji.trim() || t('Untitled document');
+  }, [doc.title, t]);
+  const slides = useMemo<PresenterSlideData[]>(
+    () => [
+      { kind: 'title', title, showDividerHint: !hasDividers },
+      ...contentSlides.map((blocks) => ({ kind: 'content' as const, blocks })),
+    ],
+    [contentSlides, hasDividers, title],
+  );
+  // Clamp to a valid slide already at init (not only via the effect below), so
+  // an out-of-range deep-link (e.g. `slide=99`) never emits a transient
+  // out-of-range `slide=` to the URL before being snapped back.
+  const [currentIndex, setCurrentIndex] = useState(() =>
+    Math.min(Math.max(0, initialIndex), slides.length - 1),
+  );
+  const [isExportingPdf, setIsExportingPdf] = useState(false);
+  const [isDividerHintDismissed, setIsDividerHintDismissed] = useState(false);
 
   const total = slides.length;
   const clamp = useCallback(
@@ -62,6 +110,25 @@ export const PresenterOverlay = ({
     [total],
   );
 
+  // `total` is only known after slides are computed, so a deep-link with an
+  // out-of-range slide (e.g. `slide=99`) is snapped to the last slide here.
+  useEffect(() => {
+    setCurrentIndex((i) => clamp(i));
+  }, [clamp]);
+
+  // Keep the URL (or any consumer) in sync with the displayed slide. Also fires
+  // on mount, so opening manually writes `slide=1` to the address bar. The ref
+  // guard ensures we only notify on a real slide change: `onIndexChange` may
+  // change identity when the consumer rewrites the URL, and re-emitting the
+  // same index would loop.
+  const lastEmittedRef = useRef<number | null>(null);
+  useEffect(() => {
+    if (lastEmittedRef.current !== currentIndex) {
+      lastEmittedRef.current = currentIndex;
+      onIndexChange?.(currentIndex);
+    }
+  }, [currentIndex, onIndexChange]);
+
   const goPrev = useCallback(
     () => setCurrentIndex((i) => clamp(i - 1)),
     [clamp],
@@ -75,6 +142,18 @@ export const PresenterOverlay = ({
     () => setCurrentIndex(clamp(total - 1)),
     [clamp, total],
   );
+  const exportPdf = useCallback(async () => {
+    if (isExportingPdf) {
+      return;
+    }
+
+    setIsExportingPdf(true);
+    try {
+      await printPresenterSlides(slides);
+    } finally {
+      setIsExportingPdf(false);
+    }
+  }, [isExportingPdf, slides]);
 
   const { isFullscreen, enter, exitIfOwned, toggle } = useBrowserFullscreen();
 
@@ -98,22 +177,27 @@ export const PresenterOverlay = ({
   const mountedIndices = useMemo(() => {
     const from = Math.max(0, currentIndex - PRESENTER_WINDOW_RADIUS);
     const to = Math.min(total - 1, currentIndex + PRESENTER_WINDOW_RADIUS);
-    const indices: number[] = [];
-    for (let i = from; i <= to; i += 1) {
-      indices.push(i);
-    }
-    return indices;
+    return Array.from({ length: to - from + 1 }, (_, k) => from + k);
   }, [currentIndex, total]);
 
   const frameRef = useRef<HTMLDivElement>(null);
+  const shouldShowDividerHint =
+    currentIndex === 0 &&
+    !isDividerHintDismissed &&
+    slides[0]?.kind === 'title' &&
+    slides[0].showDividerHint;
 
   useEffect(() => {
-    const title = getSlideTitle(slides[currentIndex] ?? []);
-    const message = title
+    const currentSlide = slides[currentIndex];
+    const slideTitle =
+      currentSlide?.kind === 'title'
+        ? currentSlide.title
+        : getSlideTitle((currentSlide?.blocks ?? []) as PresenterBlock[]);
+    const message = slideTitle
       ? t('Slide {{current}} of {{total}}: {{title}}', {
           current: currentIndex + 1,
           total,
-          title,
+          title: slideTitle,
         })
       : t('Slide {{current}} of {{total}}', {
           current: currentIndex + 1,
@@ -128,7 +212,10 @@ export const PresenterOverlay = ({
   }
 
   return createPortal(
-    <FocusScope contain autoFocus restoreFocus>
+    // The ui-kit DropdownMenu renders its popover in a React Aria portal.
+    // Keeping the FocusScope contained here prevents that portalled menu from
+    // receiving focus, which makes the dropdown close as soon as it opens.
+    <FocusScope autoFocus restoreFocus>
       <Box
         $css={overlayCss}
         role="dialog"
@@ -139,9 +226,9 @@ export const PresenterOverlay = ({
           {mountedIndices.map((i) => (
             <PresenterSlide
               key={i}
-              blocks={slides[i] as unknown[]}
               frameRef={frameRef}
               isCurrent={i === currentIndex}
+              slide={slides[i]}
               ariaLabel={t('Slide {{current}} of {{total}}', {
                 current: i + 1,
                 total,
@@ -150,12 +237,27 @@ export const PresenterOverlay = ({
           ))}
         </Box>
 
+        {shouldShowDividerHint && (
+          <Box $css={dividerHintCss}>
+            <PresenterDividerHint
+              onDismiss={() => setIsDividerHintDismissed(true)}
+            />
+          </Box>
+        )}
+
+        <Box $css={docsLogoCss}>
+          <PresenterDocsLogo />
+        </Box>
+
         <PresenterFloatingBar
           index={currentIndex}
           total={total}
           isFullscreen={isFullscreen}
           onPrev={goPrev}
           onNext={goNext}
+          onCopyLink={() => copyPresenterLink(currentIndex)}
+          onExportPdf={() => void exportPdf()}
+          isExportingPdf={isExportingPdf}
           onToggleFullscreen={() => void toggle()}
           onClose={onClose}
         />
diff --git a/src/frontend/apps/impress/src/features/docs/doc-presenter/components/PresenterPrintDocument.tsx b/src/frontend/apps/impress/src/features/docs/doc-presenter/components/PresenterPrintDocument.tsx
new file mode 100644
index 0000000000..3899e86ba3
--- /dev/null
+++ b/src/frontend/apps/impress/src/features/docs/doc-presenter/components/PresenterPrintDocument.tsx
@@ -0,0 +1,169 @@
+import { PRESENTER_SLIDE_DESIGN_WIDTH } from '../constants';
+import { PresenterSlideData } from '../types';
+
+import { PresenterDocsLogo } from './PresenterDocsLogo';
+import { PresenterSlideContent } from './PresenterSlideContent';
+
+interface PresenterPrintDocumentProps {
+  slides: PresenterSlideData[];
+}
+
+export const PRESENTER_PRINT_ROOT_ID = 'presenter-print-root';
+export const PRESENTER_PRINT_STYLES_ID = 'presenter-print-styles';
+export const PRESENTER_PRINT_PAGE_SELECTOR = '[data-presenter-print-page]';
+export const PRESENTER_PRINT_PAGE_CLASS = '--docs--presenter-print-page';
+export const PRESENTER_PRINT_CONTENT_CLASS = '--docs--presenter-print-content';
+export const PRESENTER_PRINT_LOGO_CLASS = '--docs--presenter-print-logo';
+export const PRESENTER_PRINT_TITLE_CLASS = '--docs--presenter-print-title';
+
+export const PRESENTER_PRINT_CSS = `
+@media screen {
+  #${PRESENTER_PRINT_ROOT_ID} {
+    position: fixed;
+    top: 0;
+    left: -100000px;
+    width: 297mm;
+    min-height: 210mm;
+    overflow: hidden;
+    opacity: 0;
+    pointer-events: none;
+  }
+}
+
+@media print {
+  @page {
+    size: A4 landscape;
+    margin: 0;
+  }
+
+  html,
+  body {
+    width: auto !important;
+    height: auto !important;
+    min-height: 0 !important;
+    margin: 0 !important;
+    padding: 0 !important;
+    overflow: visible !important;
+    background: white !important;
+  }
+
+  body > *:not(#${PRESENTER_PRINT_ROOT_ID}) {
+    display: none !important;
+  }
+
+  #${PRESENTER_PRINT_ROOT_ID} {
+    display: block !important;
+    position: static !important;
+    width: auto !important;
+    min-height: 0 !important;
+    opacity: 1 !important;
+    overflow: visible !important;
+    pointer-events: auto !important;
+    background: white !important;
+  }
+
+  .${PRESENTER_PRINT_PAGE_CLASS} {
+    position: relative;
+    width: 297mm;
+    height: 210mm;
+    box-sizing: border-box;
+    padding: 18mm 24mm;
+    display: flex;
+    flex-direction: column;
+    justify-content: safe center;
+    overflow: hidden !important;
+    background: white !important;
+    break-after: page;
+    page-break-after: always;
+    break-inside: avoid;
+    page-break-inside: avoid;
+    -webkit-print-color-adjust: exact !important;
+    print-color-adjust: exact !important;
+  }
+
+  .${PRESENTER_PRINT_PAGE_CLASS}:last-child {
+    break-after: auto;
+    page-break-after: auto;
+  }
+
+  .${PRESENTER_PRINT_CONTENT_CLASS} {
+    width: ${PRESENTER_SLIDE_DESIGN_WIDTH}px;
+    max-width: 100%;
+    max-height: 100%;
+    margin: 0 auto;
+    overflow: hidden !important;
+  }
+
+  .${PRESENTER_PRINT_CONTENT_CLASS} .bn-editor,
+  .${PRESENTER_PRINT_CONTENT_CLASS} .bn-root,
+  .${PRESENTER_PRINT_CONTENT_CLASS} .ProseMirror {
+    min-height: 0 !important;
+  }
+
+  .${PRESENTER_PRINT_CONTENT_CLASS} .bn-editor {
+    padding: 0 !important;
+  }
+
+  .${PRESENTER_PRINT_CONTENT_CLASS} [data-content-type="file"] .bn-file-block-content-wrapper,
+  .${PRESENTER_PRINT_CONTENT_CLASS} [data-content-type="pdf"] .bn-file-block-content-wrapper,
+  .${PRESENTER_PRINT_CONTENT_CLASS} [data-content-type="audio"] .bn-file-block-content-wrapper,
+  .${PRESENTER_PRINT_CONTENT_CLASS} [data-content-type="video"] .bn-file-block-content-wrapper {
+    display: none !important;
+  }
+
+  .${PRESENTER_PRINT_CONTENT_CLASS} .print-url-label {
+    text-decoration: none !important;
+  }
+
+  .${PRESENTER_PRINT_CONTENT_CLASS} * {
+    -webkit-print-color-adjust: exact !important;
+    print-color-adjust: exact !important;
+  }
+
+  .${PRESENTER_PRINT_LOGO_CLASS} {
+    position: absolute;
+    bottom: 16px;
+    left: 16px;
+    width: 80px;
+    height: 32px;
+  }
+
+  .${PRESENTER_PRINT_TITLE_CLASS} {
+    width: ${PRESENTER_SLIDE_DESIGN_WIDTH}px;
+    max-width: 100%;
+    margin: 0 auto;
+    color: var(--c--contextuals--content--semantic--neutral--primary, #222631);
+    font-size: 40px;
+    font-weight: 700;
+    line-height: 48px;
+    text-align: center;
+    overflow-wrap: anywhere;
+  }
+}
+`;
+
+export const PresenterPrintDocument = ({
+  slides,
+}: PresenterPrintDocumentProps) => (
+  <div aria-hidden="true">
+    {slides.map((slide, index) => (
+      <section
+        key={index}
+        className={PRESENTER_PRINT_PAGE_CLASS}
+        data-presenter-print-page
+      >
+        {slide.kind === 'title' ? (
+          <h1 className={PRESENTER_PRINT_TITLE_CLASS}>{slide.title}</h1>
+        ) : (
+          <PresenterSlideContent
+            blocks={slide.blocks}
+            className={PRESENTER_PRINT_CONTENT_CLASS}
+          />
+        )}
+        <div className={PRESENTER_PRINT_LOGO_CLASS}>
+          <PresenterDocsLogo />
+        </div>
+      </section>
+    ))}
+  </div>
+);
diff --git a/src/frontend/apps/impress/src/features/docs/doc-presenter/components/PresenterRoot.tsx b/src/frontend/apps/impress/src/features/docs/doc-presenter/components/PresenterRoot.tsx
new file mode 100644
index 0000000000..7dc46889a0
--- /dev/null
+++ b/src/frontend/apps/impress/src/features/docs/doc-presenter/components/PresenterRoot.tsx
@@ -0,0 +1,126 @@
+import dynamic from 'next/dynamic';
+import { useRouter } from 'next/router';
+import { useCallback, useEffect } from 'react';
+import { createPortal } from 'react-dom';
+import { css } from 'styled-components';
+
+import { Box, Loading } from '@/components';
+import { useEditorStore } from '@/docs/doc-editor/stores';
+import { useDocStore } from '@/docs/doc-management';
+import { useResponsiveStore } from '@/stores';
+
+import { usePresenterStore } from '../stores';
+
+const coverCss = css`
+  position: fixed;
+  inset: 0;
+  z-index: 1000;
+  background: white;
+`;
+
+/**
+ * Full-screen white cover shown while the editor boots, so a `?view=present`
+ * deep-link never reveals the layout → skeleton → editor cascade underneath.
+ * Same background and z-index as the presenter overlay, so the swap to slides
+ * is seamless.
+ */
+const PresenterBootCover = () => {
+  if (typeof document === 'undefined') {
+    return null;
+  }
+  return createPortal(
+    <Box $css={coverCss}>
+      <Loading />
+    </Box>,
+    document.body,
+  );
+};
+
+const PresenterOverlay = dynamic(
+  () =>
+    import('./PresenterOverlay').then((mod) => ({
+      default: mod.PresenterOverlay,
+    })),
+  { ssr: false, loading: () => <PresenterBootCover /> },
+);
+
+/**
+ * Single mount point for the presenter, rendered high in the tree (doc page).
+ * Drives both the manual "Present" action (via `usePresenterStore`) and the
+ * `?view=present[&slide=N]` deep-link (via the URL), painting a boot cover
+ * until the editor snapshot is available.
+ */
+export const PresenterRoot = () => {
+  const router = useRouter();
+  const { isMobile } = useResponsiveStore();
+  const editor = useEditorStore((state) => state.editor);
+  const { currentDoc } = useDocStore();
+  const { isOpen, initialIndex, close } = usePresenterStore();
+
+  const wantsPresent = router.query.view === 'present';
+  const slideParam = Number(router.query.slide);
+  const urlInitialIndex =
+    Number.isFinite(slideParam) && slideParam >= 1 ? slideParam - 1 : 0;
+
+  const syncSlideToUrl = useCallback(
+    (index: number) => {
+      void router.replace(
+        {
+          pathname: router.pathname,
+          query: { ...router.query, view: 'present', slide: index + 1 },
+        },
+        undefined,
+        { shallow: true },
+      );
+    },
+    [router],
+  );
+
+  const handleClose = useCallback(() => {
+    close();
+    const { view: _view, slide: _slide, ...rest } = router.query;
+    void router.replace({ pathname: router.pathname, query: rest }, undefined, {
+      shallow: true,
+    });
+  }, [close, router]);
+
+  // The presenter is active from a manual open OR a deep-link; deriving it from
+  // `wantsPresent` lets the cover paint on the very first render, before the
+  // layout cascade shows.
+  const active = !isMobile && (isOpen || wantsPresent);
+  const isBooting = active && (!editor || !currentDoc);
+
+  // Let users escape the boot cover if the editor never finishes loading.
+  useEffect(() => {
+    if (!isBooting) {
+      return;
+    }
+    const onKeyDown = (event: KeyboardEvent) => {
+      if (event.key === 'Escape') {
+        handleClose();
+      }
+    };
+    window.addEventListener('keydown', onKeyDown);
+    return () => window.removeEventListener('keydown', onKeyDown);
+  }, [isBooting, handleClose]);
+
+  if (!active) {
+    return null;
+  }
+
+  if (!editor || !currentDoc) {
+    return <PresenterBootCover />;
+  }
+
+  // A manual open carries its own start slide; a deep-link reads it from the URL.
+  const startIndex = isOpen ? initialIndex : urlInitialIndex;
+
+  return (
+    <PresenterOverlay
+      doc={currentDoc}
+      initialIndex={startIndex}
+      onIndexChange={syncSlideToUrl}
+      onClose={handleClose}
+    />
+  );
+};
diff --git a/src/frontend/apps/impress/src/features/docs/doc-presenter/components/PresenterSlide.tsx b/src/frontend/apps/impress/src/features/docs/doc-presenter/components/PresenterSlide.tsx
index df550f4d2a..aa61e072ae 100644
--- a/src/frontend/apps/impress/src/features/docs/doc-presenter/components/PresenterSlide.tsx
+++ b/src/frontend/apps/impress/src/features/docs/doc-presenter/components/PresenterSlide.tsx
@@ -1,11 +1,8 @@
-import { BlockNoteView } from '@blocknote/mantine';
-import { useCreateBlockNote } from '@blocknote/react';
-import { RefObject, useEffect, useRef } from 'react';
+import { RefObject, useRef } from 'react';
 import { useTranslation } from 'react-i18next';
 import { css } from 'styled-components';
 
 import { Box } from '@/components';
-import { blockNoteSchema } from '@/docs/doc-editor/components/BlockNoteEditor';
 
 import {
   PRESENTER_FRAME_PADDING_Y,
@@ -13,11 +10,15 @@ import {
   PRESENTER_SLIDE_FADE_MS,
 } from '../constants';
 import { useFitScale } from '../hooks/useFitScale';
+import { PresenterSlideData } from '../types';
+
+import { PresenterSlideContent } from './PresenterSlideContent';
+import { PresenterTitleSlide } from './PresenterTitleSlide';
 
 interface PresenterSlideProps {
-  blocks: unknown[];
   frameRef: RefObject<HTMLDivElement | null>;
   isCurrent: boolean;
+  slide: PresenterSlideData;
   ariaLabel?: string;
 }
 
@@ -47,12 +48,6 @@ const outerCss = css`
   overflow-x: hidden;
   background: white;
   transition: opacity ${PRESENTER_SLIDE_FADE_MS}ms ease;
-  /* Hide editor chrome that may leak through despite editable={false} */
-  .bn-side-menu,
-  .bn-formatting-toolbar,
-  .bn-slash-menu {
-    display: none !important;
-  }
 `;
 
 // The stage absorbs the un-scaled inner's layout box. Its explicit height
@@ -78,35 +73,13 @@ const innerCss = css`
 `;
 
 export const PresenterSlide = ({
-  blocks,
   frameRef,
   isCurrent,
+  slide,
   ariaLabel,
 }: PresenterSlideProps) => {
   const { t } = useTranslation();
   const innerRef = useRef<HTMLDivElement>(null);
-  const editor = useCreateBlockNote({
-    initialContent:
-      // BlockNote rejects an empty initialContent array — fall back to one empty paragraph.
-      blocks.length > 0
-        ? (blocks as NonNullable<
-            Parameters<typeof useCreateBlockNote>[0]
-          >['initialContent'])
-        : undefined,
-    schema: blockNoteSchema,
-  });
-
-  // ProseMirror adds role="textbox" and contenteditable on its root even
-  // when editable=false, making the SR announce "editing, autocomplete" on
-  // focus. Strip those attributes so the slide reads as plain content.
-  useEffect(() => {
-    const pm = innerRef.current?.querySelector('.ProseMirror');
-    if (pm) {
-      pm.removeAttribute('role');
-      pm.removeAttribute('contenteditable');
-      pm.setAttribute('tabindex', '-1');
-    }
-  }, []);
 
   const fit = useFitScale(innerRef, frameRef);
 
@@ -136,14 +109,11 @@ export const PresenterSlide = ({
     >
       <Box $css={stageCss} style={stageStyle}>
         <Box ref={innerRef} $css={innerCss} style={innerStyle}>
-          <BlockNoteView
-            editor={editor}
-            editable={false}
-            theme="light"
-            formattingToolbar={false}
-            slashMenu={false}
-            comments={false}
-          />
+          {slide.kind === 'title' ? (
+            <PresenterTitleSlide title={slide.title} />
+          ) : (
+            <PresenterSlideContent blocks={slide.blocks} />
+          )}
         </Box>
       </Box>
     </Box>
diff --git a/src/frontend/apps/impress/src/features/docs/doc-presenter/components/PresenterSlideContent.tsx b/src/frontend/apps/impress/src/features/docs/doc-presenter/components/PresenterSlideContent.tsx
new file mode 100644
index 0000000000..33121916b3
--- /dev/null
+++ b/src/frontend/apps/impress/src/features/docs/doc-presenter/components/PresenterSlideContent.tsx
@@ -0,0 +1,103 @@
+import { BlockNoteView } from '@blocknote/mantine';
+import { useCreateBlockNote } from '@blocknote/react';
+import { CSSProperties, Ref, useEffect, useRef } from 'react';
+import { css } from 'styled-components';
+
+import { Box } from '@/components';
+import { blockNoteSchema } from '@/docs/doc-editor/components/BlockNoteEditor';
+
+interface PresenterSlideContentProps {
+  blocks: unknown[];
+  className?: string;
+  innerRef?: Ref<HTMLDivElement>;
+  style?: CSSProperties;
+}
+
+const slideContentCss = css`
+  .bn-side-menu,
+  .bn-formatting-toolbar,
+  .bn-slash-menu {
+    display: none !important;
+  }
+
+  .bn-block-content.ProseMirror-selectednode > *,
+  .ProseMirror-selectednode > .bn-block-content > *,
+  .ProseMirror-selectednode {
+    outline: 0 !important;
+  }
+
+  .bn-block-content[data-content-type='divider'] {
+    display: none;
+  }
+`;
+
+const setRefValue = (
+  ref: Ref<HTMLDivElement> | undefined,
+  node: HTMLDivElement | null,
+) => {
+  if (!ref) {
+    return;
+  }
+
+  if (typeof ref === 'function') {
+    ref(node);
+    return;
+  }
+
+  (ref as { current: HTMLDivElement | null }).current = node;
+};
+
+export const PresenterSlideContent = ({
+  blocks,
+  className,
+  innerRef,
+  style,
+}: PresenterSlideContentProps) => {
+  const contentRef = useRef<HTMLDivElement | null>(null);
+  const editor = useCreateBlockNote({
+    initialContent:
+      // BlockNote rejects an empty initialContent array — fall back to one empty paragraph.
+      blocks.length > 0
+        ? (blocks as NonNullable<
+            Parameters<typeof useCreateBlockNote>[0]
+          >['initialContent'])
+        : undefined,
+    schema: blockNoteSchema,
+  });
+
+  // Even with `editable={false}`, BlockNote/ProseMirror currently still renders
+  // the editor node with `role="textbox"` and `contenteditable`. For presenter
+  // slides that is wrong — the content is presentation, not an editable field —
+  // and it pollutes the accessibility tree and tab order. Strip those and take
+  // the node out of the tab sequence. (Observed BlockNote behaviour, not a
+  // guarantee; revisit on upgrades.)
+  useEffect(() => {
+    const pm = contentRef.current?.querySelector('.ProseMirror');
+    if (pm) {
+      pm.removeAttribute('role');
+      pm.removeAttribute('contenteditable');
+      pm.setAttribute('tabindex', '-1');
+    }
+  }, []);
+
+  return (
+    <Box
+      ref={(node: HTMLDivElement | null) => {
+        contentRef.current = node;
+        setRefValue(innerRef, node);
+      }}
+      className={className}
+      $css={slideContentCss}
+      style={style}
+    >
+      <BlockNoteView
+        editor={editor}
+        editable={false}
+        theme="light"
+        formattingToolbar={false}
+        slashMenu={false}
+        comments={false}
+      />
+    </Box>
+  );
+};
diff --git a/src/frontend/apps/impress/src/features/docs/doc-presenter/components/PresenterTitleSlide.tsx b/src/frontend/apps/impress/src/features/docs/doc-presenter/components/PresenterTitleSlide.tsx
new file mode 100644
index 0000000000..c13fe0b23f
--- /dev/null
+++ b/src/frontend/apps/impress/src/features/docs/doc-presenter/components/PresenterTitleSlide.tsx
@@ -0,0 +1,36 @@
+import { css } from 'styled-components';
+
+import { Box, Text } from '@/components';
+
+interface PresenterTitleSlideProps {
+  title: string;
+}
+
+const titleSlideCss = css`
+  position: relative;
+  width: 100%;
+  min-height: 520px;
+  box-sizing: border-box;
+  align-items: center;
+  justify-content: center;
+  padding: 96px 32px;
+`;
+
+const titleCss = css`
+  max-width: 720px;
+  margin: 0;
+  color: var(--c--contextuals--content--semantic--neutral--primary, #222631);
+  font-size: 40px;
+  font-weight: 700;
+  line-height: 48px;
+  text-align: center;
+  overflow-wrap: anywhere;
+`;
+
+export const PresenterTitleSlide = ({ title }: PresenterTitleSlideProps) => (
+  <Box $css={titleSlideCss}>
+    <Text as="h1" $css={titleCss}>
+      {title}
+    </Text>
+  </Box>
+);
diff --git a/src/frontend/apps/impress/src/features/docs/doc-presenter/hooks/useCopyPresenterLink.tsx b/src/frontend/apps/impress/src/features/docs/doc-presenter/hooks/useCopyPresenterLink.tsx
new file mode 100644
index 0000000000..20d53f31cf
--- /dev/null
+++ b/src/frontend/apps/impress/src/features/docs/doc-presenter/hooks/useCopyPresenterLink.tsx
@@ -0,0 +1,26 @@
+import { useCallback } from 'react';
+import { useTranslation } from 'react-i18next';
+
+import { Doc } from '@/docs/doc-management';
+import { useClipboard } from '@/hooks';
+
+/**
+ * Builds and copies a deep-link that reopens the document in presenter mode at
+ * a given slide. `index` is the 0-based slide index; the URL uses a 1-based
+ * `slide` param (see issue #2397).
+ */
+export const useCopyPresenterLink = (docId: Doc['id']) => {
+  const { t } = useTranslation();
+  const copyToClipboard = useClipboard();
+
+  return useCallback(
+    (index: number) => {
+      copyToClipboard(
+        `${window.location.origin}/docs/${docId}/?view=present&slide=${index + 1}`,
+        t('Link Copied !'),
+        t('Failed to copy link'),
+      );
+    },
+    [copyToClipboard, docId, t],
+  );
+};
diff --git a/src/frontend/apps/impress/src/features/docs/doc-presenter/hooks/useSlides.ts b/src/frontend/apps/impress/src/features/docs/doc-presenter/hooks/useSlides.ts
index 8e2ef6724f..84e2d8671b 100644
--- a/src/frontend/apps/impress/src/features/docs/doc-presenter/hooks/useSlides.ts
+++ b/src/frontend/apps/impress/src/features/docs/doc-presenter/hooks/useSlides.ts
@@ -1,44 +1,11 @@
 import { useMemo } from 'react';
 
-type Block = {
-  type: string;
-  content?: unknown;
-  children?: Block[];
-};
-
-/**
- * Split a flat list of top-level blocks into slide groups.
- *
- * - Each `divider` block separates two slides; the divider itself is dropped.
- * - Blocks are otherwise preserved verbatim — including empty paragraphs
- *   (intentional spacing) and custom blocks (interlinks, embeds, ...). The
- *   presenter renders whatever the editor holds; it does not second-guess
- *   the author's content.
- * - Groups with no blocks at all are removed (handles leading, trailing or
- *   consecutive dividers).
- * - The returned array is never empty: an empty doc yields one empty group.
- */
-export const splitBlocksIntoSlides = <T extends Block>(blocks: T[]): T[][] => {
-  const groups: T[][] = [];
-  let current: T[] = [];
-
-  for (const block of blocks) {
-    if (block.type === 'divider') {
-      groups.push(current);
-      current = [];
-      continue;
-    }
-    current.push(block);
-  }
-  groups.push(current);
-
-  const nonEmpty = groups.filter((group) => group.length > 0);
-
-  return nonEmpty.length > 0 ? nonEmpty : [[]];
-};
+import { PresenterBlock } from '../types';
 
-export const useSlides = <T extends Block>(blocks: T[]): T[][] => {
-  return useMemo(() => splitBlocksIntoSlides(blocks), [blocks]);
+type SlideGroup<T extends PresenterBlock> = {
+  blocks: T[];
+  dividerId?: string;
+  startsAfterDivider?: boolean;
 };
 
 // Extract text from a node's inline content for summarization or accessibility.
@@ -68,14 +35,262 @@ const extractInlineText = (content: unknown): string => {
     .join('');
 };
 
+const isEmptyParagraphBlock = (block: PresenterBlock): boolean =>
+  block.type === 'paragraph' &&
+  extractInlineText(block.content).trim().length === 0 &&
+  (block.children ?? []).length === 0;
+
+type TrimSide = 'leading' | 'trailing';
+
+// Drop empty paragraph blocks from one end of the list. The opposite end and
+// any non-empty block (content paragraphs, headings, custom blocks) are left
+// untouched.
+const trimEmptyParagraphs = <T extends PresenterBlock>(
+  blocks: T[],
+  side: TrimSide,
+): T[] => {
+  if (side === 'leading') {
+    const firstContentIndex = blocks.findIndex(
+      (block) => !isEmptyParagraphBlock(block),
+    );
+
+    return firstContentIndex === -1 ? [] : blocks.slice(firstContentIndex);
+  }
+
+  const reversedLastContentIndex = [...blocks]
+    .reverse()
+    .findIndex((block) => !isEmptyParagraphBlock(block));
+
+  return reversedLastContentIndex === -1
+    ? []
+    : blocks.slice(0, blocks.length - reversedLastContentIndex);
+};
+
+// A divider carrying children is kept as the structural parent of the
+// following slide; trim the empty paragraphs from the relevant end of its
+// children. Returns null when nothing renderable remains, and the block
+// unchanged when it is not such a structural divider or needs no trimming.
+const trimStructuralDividerBoundary = <T extends PresenterBlock>(
+  block: T,
+  side: TrimSide,
+): T | null => {
+  if (block.type !== 'divider' || !Array.isArray(block.children)) {
+    return block;
+  }
+
+  const children = trimEmptyParagraphs(block.children, side);
+  if (children.length === 0) {
+    return null;
+  }
+
+  if (children.length === block.children.length) {
+    return block;
+  }
+
+  return { ...block, children };
+};
+
+const stripLeadingEmptyParagraphsAfterDivider = <T extends PresenterBlock>(
+  group: SlideGroup<T>,
+): SlideGroup<T> => {
+  if (!group.startsAfterDivider) {
+    return group;
+  }
+
+  const [firstBlock, ...remainingBlocks] = group.blocks;
+  const firstRenderableBlock = firstBlock
+    ? trimStructuralDividerBoundary(firstBlock, 'leading')
+    : null;
+  const blocks = firstRenderableBlock
+    ? [firstRenderableBlock, ...remainingBlocks]
+    : remainingBlocks;
+
+  return {
+    ...group,
+    blocks: trimEmptyParagraphs(blocks, 'leading'),
+  };
+};
+
+const stripTrailingEmptyParagraphsBeforeDivider = <T extends PresenterBlock>(
+  blocks: T[],
+): T[] => {
+  const lastBlock = blocks[blocks.length - 1];
+  const lastRenderableBlock = lastBlock
+    ? trimStructuralDividerBoundary(lastBlock, 'trailing')
+    : null;
+  const trimmedBlocks = lastRenderableBlock
+    ? [...blocks.slice(0, -1), lastRenderableBlock]
+    : blocks.slice(0, -1);
+
+  return trimEmptyParagraphs(trimmedBlocks, 'trailing');
+};
+
+const getRawSlideGroups = <T extends PresenterBlock>(
+  blocks: T[],
+  options: { stripBeforeDividers?: boolean } = {},
+): SlideGroup<T>[] => {
+  const groups: SlideGroup<T>[] = [{ blocks: [] }];
+  let current = groups[0];
+
+  for (const block of blocks) {
+    if (block.type === 'divider') {
+      if (options.stripBeforeDividers) {
+        current.blocks = stripTrailingEmptyParagraphsBeforeDivider(
+          current.blocks,
+        );
+      }
+      current = {
+        blocks:
+          Array.isArray(block.children) && block.children.length > 0
+            ? [block]
+            : [],
+        dividerId: block.id,
+        startsAfterDivider: true,
+      };
+      groups.push(current);
+      continue;
+    }
+
+    current.blocks.push(block);
+  }
+
+  return groups;
+};
+
+const getRenderedSlideGroups = <T extends PresenterBlock>(
+  blocks: T[],
+): SlideGroup<T>[] =>
+  getRawSlideGroups(blocks, { stripBeforeDividers: true }).map(
+    stripLeadingEmptyParagraphsAfterDivider,
+  );
+
+const hasBlockId = (blocks: PresenterBlock[], blockId: string): boolean =>
+  blocks.some(
+    (block) =>
+      block.id === blockId || hasBlockId(block.children ?? [], blockId),
+  );
+
+/**
+ * Split a flat list of top-level blocks into slide groups.
+ *
+ * - Each `divider` block separates two slides. Dividers without children are
+ *   dropped.
+ * - A divider with children is kept as a structural parent in the following
+ *   slide so BlockNote can preserve the visual indentation line. The presenter
+ *   hides the divider's own horizontal rule when rendering the slide.
+ * - Empty paragraphs immediately before or after a divider are dropped so
+ *   habitual spacing around slide breaks does not offset the slides. Empty
+ *   paragraphs elsewhere are preserved as intentional spacing, and custom
+ *   blocks (interlinks, embeds, ...) are kept verbatim.
+ * - Groups with no blocks at all are removed (handles leading, trailing or
+ *   consecutive dividers).
+ * - The returned array is never empty: an empty doc yields one empty group.
+ */
+export const splitBlocksIntoSlides = <T extends PresenterBlock>(
+  blocks: T[],
+): T[][] => {
+  const nonEmpty = getRenderedSlideGroups(blocks)
+    .map((group) => group.blocks)
+    .filter((group) => group.length > 0);
+
+  return nonEmpty.length > 0 ? nonEmpty : [[]];
+};
+
+/**
+ * Map a block id to the index of the rendered (non-empty) content slide it
+ * belongs to. Accepts a regular block id, a block nested under a divider, or a
+ * divider's own id. When the matching group is dropped at render time (e.g. an
+ * empty slide), falls back to the closest rendered slide: the one directly
+ * containing the block, else the following content slide, else the previous
+ * one. Returns 0 when the block is absent (and as the ultimate fallback).
+ */
+export const getContentSlideIndexForBlock = <T extends PresenterBlock>(
+  blocks: T[],
+  blockId: string,
+): number => {
+  const rawGroups = getRawSlideGroups(blocks);
+  const renderedGroups = getRenderedSlideGroups(blocks);
+  const nonEmptyGroups = renderedGroups
+    .map((group, index) => ({ group, index }))
+    .filter(({ group }) => group.blocks.length > 0);
+
+  const getClosestRenderedSlideIndex = (groupIndex: number) => {
+    const directSlideIndex = nonEmptyGroups.findIndex(
+      ({ index }) => index === groupIndex,
+    );
+
+    if (directSlideIndex !== -1) {
+      return directSlideIndex;
+    }
+
+    const followingSlideIndex = nonEmptyGroups.findIndex(
+      ({ index }) => index > groupIndex,
+    );
+
+    if (followingSlideIndex !== -1) {
+      return followingSlideIndex;
+    }
+
+    const previousSlideIndex = nonEmptyGroups.findLastIndex(
+      ({ index }) => index < groupIndex,
+    );
+
+    return previousSlideIndex !== -1 ? previousSlideIndex : 0;
+  };
+
+  const directGroupIndex = rawGroups.findIndex((group) =>
+    hasBlockId(group.blocks, blockId),
+  );
+
+  if (directGroupIndex !== -1) {
+    return getClosestRenderedSlideIndex(directGroupIndex);
+  }
+
+  const dividerGroupIndex = rawGroups.findIndex(
+    (group) => group.dividerId === blockId,
+  );
+
+  if (dividerGroupIndex === -1) {
+    return 0;
+  }
+
+  return getClosestRenderedSlideIndex(dividerGroupIndex);
+};
+
+/** Memoized {@link splitBlocksIntoSlides} for use during render. */
+export const useSlides = <T extends PresenterBlock>(blocks: T[]): T[][] => {
+  return useMemo(() => splitBlocksIntoSlides(blocks), [blocks]);
+};
+
+/** Whether the block tree contains at least one divider (at any depth). */
+export const hasDividerBlock = <T extends PresenterBlock>(
+  blocks: T[],
+): boolean =>
+  blocks.some(
+    (block) =>
+      block.type === 'divider' || hasDividerBlock(block.children ?? []),
+  );
+
+const getBlocksInReadingOrder = <T extends PresenterBlock>(
+  blocks: T[],
+): PresenterBlock[] => {
+  return blocks.flatMap((block) => [
+    block,
+    ...getBlocksInReadingOrder(block.children ?? []),
+  ]);
+};
+
 /** First heading text, or first block with text, for SR announcements. */
-export const getSlideTitle = (
-  blocks: { type: string; content?: unknown }[],
-): string => {
-  const heading = blocks.find((block) => block.type === 'heading');
+export const getSlideTitle = (blocks: PresenterBlock[]): string => {
+  const blocksInReadingOrder = getBlocksInReadingOrder(blocks);
+  const heading = blocksInReadingOrder.find(
+    (block) => block.type === 'heading',
+  );
   const source =
     heading ??
-    blocks.find((block) => extractInlineText(block.content).trim().length > 0);
+    blocksInReadingOrder.find(
+      (block) => extractInlineText(block.content).trim().length > 0,
+    );
 
   return source ? extractInlineText(source.content).trim() : '';
 };
diff --git a/src/frontend/apps/impress/src/features/docs/doc-presenter/index.ts b/src/frontend/apps/impress/src/features/docs/doc-presenter/index.ts
index 0ad4b13a32..412953aade 100644
--- a/src/frontend/apps/impress/src/features/docs/doc-presenter/index.ts
+++ b/src/frontend/apps/impress/src/features/docs/doc-presenter/index.ts
@@ -1 +1,4 @@
-export { PresenterOverlay } from './components/PresenterOverlay';
+// PresenterOverlay is an internal detail (lazy-loaded by PresenterRoot); only
+// the mount point and the store are part of the feature's public surface.
+export { PresenterRoot } from './components/PresenterRoot';
+export * from './stores';
diff --git a/src/frontend/apps/impress/src/features/docs/doc-presenter/stores/index.ts b/src/frontend/apps/impress/src/features/docs/doc-presenter/stores/index.ts
new file mode 100644
index 0000000000..4bcaa1bd4a
--- /dev/null
+++ b/src/frontend/apps/impress/src/features/docs/doc-presenter/stores/index.ts
@@ -0,0 +1 @@
+export * from './usePresenterStore';
diff --git a/src/frontend/apps/impress/src/features/docs/doc-presenter/stores/usePresenterStore.tsx b/src/frontend/apps/impress/src/features/docs/doc-presenter/stores/usePresenterStore.tsx
new file mode 100644
index 0000000000..155c3809b8
--- /dev/null
+++ b/src/frontend/apps/impress/src/features/docs/doc-presenter/stores/usePresenterStore.tsx
@@ -0,0 +1,20 @@
+import { create } from 'zustand';
+
+export interface PresenterState {
+  isOpen: boolean;
+  /** 0-based slide to start the presentation on. */
+  initialIndex: number;
+  open: (index?: number) => void;
+  close: () => void;
+}
+
+export const usePresenterStore = create<PresenterState>((set) => ({
+  isOpen: false,
+  initialIndex: 0,
+  open: (index = 0) => {
+    set({ isOpen: true, initialIndex: Math.max(0, index) });
+  },
+  close: () => {
+    set({ isOpen: false });
+  },
+}));
diff --git a/src/frontend/apps/impress/src/features/docs/doc-presenter/types.ts b/src/frontend/apps/impress/src/features/docs/doc-presenter/types.ts
new file mode 100644
index 0000000000..d16847152a
--- /dev/null
+++ b/src/frontend/apps/impress/src/features/docs/doc-presenter/types.ts
@@ -0,0 +1,20 @@
+/** Minimal shape of a BlockNote block as consumed by the presenter. */
+export type PresenterBlock = {
+  id?: string;
+  type: string;
+  content?: unknown;
+  children?: PresenterBlock[];
+};
+
+export type PresenterTitleSlide = {
+  kind: 'title';
+  showDividerHint: boolean;
+  title: string;
+};
+
+export type PresenterContentSlide = {
+  blocks: unknown[];
+  kind: 'content';
+};
+
+export type PresenterSlideData = PresenterTitleSlide | PresenterContentSlide;
diff --git a/src/frontend/apps/impress/src/features/docs/doc-presenter/utils_print.tsx b/src/frontend/apps/impress/src/features/docs/doc-presenter/utils_print.tsx
new file mode 100644
index 0000000000..a84dcc493e
--- /dev/null
+++ b/src/frontend/apps/impress/src/features/docs/doc-presenter/utils_print.tsx
@@ -0,0 +1,150 @@
+import { Root, createRoot } from 'react-dom/client';
+
+import {
+  wrapInterlinksWithAnchor,
+  wrapMediaWithLink,
+} from '@/docs/doc-export/utils_print';
+
+import {
+  PRESENTER_PRINT_CSS,
+  PRESENTER_PRINT_ROOT_ID,
+  PRESENTER_PRINT_STYLES_ID,
+  PresenterPrintDocument,
+} from './components/PresenterPrintDocument';
+import { PresenterSlideData } from './types';
+
+const PRINT_CLEANUP_DELAY_MS = 10000;
+const PRINT_IMAGE_WAIT_TIMEOUT_MS = 2000;
+
+interface PresenterPrintMount {
+  cleanup: () => void;
+  container: HTMLDivElement;
+  root: Root;
+}
+
+const nextFrame = () =>
+  new Promise<void>((resolve) => {
+    requestAnimationFrame(() => resolve());
+  });
+
+const timeout = (ms: number) =>
+  new Promise<void>((resolve) => {
+    window.setTimeout(resolve, ms);
+  });
+
+const removeExistingPrintArtifacts = () => {
+  document.getElementById(PRESENTER_PRINT_ROOT_ID)?.remove();
+  document.getElementById(PRESENTER_PRINT_STYLES_ID)?.remove();
+};
+
+const createPrintStyleElement = () => {
+  const style = document.createElement('style');
+  style.id = PRESENTER_PRINT_STYLES_ID;
+  style.textContent = PRESENTER_PRINT_CSS;
+  return style;
+};
+
+const waitForImages = async (container: HTMLElement) => {
+  const images = Array.from(container.querySelectorAll('img'));
+  if (images.length === 0) {
+    return;
+  }
+
+  const imagePromises = images.map(
+    (image) =>
+      new Promise<void>((resolve) => {
+        if (image.complete) {
+          resolve();
+          return;
+        }
+
+        const done = () => {
+          image.removeEventListener('load', done);
+          image.removeEventListener('error', done);
+          resolve();
+        };
+
+        image.addEventListener('load', done, { once: true });
+        image.addEventListener('error', done, { once: true });
+      }),
+  );
+
+  await Promise.race([
+    Promise.all(imagePromises).then(() => undefined),
+    timeout(PRINT_IMAGE_WAIT_TIMEOUT_MS),
+  ]);
+};
+
+export const mountPresenterPrintSlides = (
+  slides: PresenterSlideData[],
+): PresenterPrintMount => {
+  removeExistingPrintArtifacts();
+
+  const style = createPrintStyleElement();
+  const container = document.createElement('div');
+  container.id = PRESENTER_PRINT_ROOT_ID;
+
+  document.head.appendChild(style);
+  document.body.appendChild(container);
+
+  const root = createRoot(container);
+  root.render(<PresenterPrintDocument slides={slides} />);
+
+  return {
+    container,
+    root,
+    cleanup: () => {
+      root.unmount();
+      container.remove();
+      style.remove();
+    },
+  };
+};
+
+// The slides are mounted off-screen via createRoot, then their content
+// (BlockNote/ProseMirror) lays out asynchronously. We wait two paint frames so
+// React commits the render and the editor settles before measuring images,
+// then one more after images load. Do NOT collapse these into a single frame:
+// printing too early yields blank pages. `printPresenterSlides` adds a final
+// frame after the media/interlink wrapping for the same reason.
+export const waitForPresenterPrintReady = async (container: HTMLElement) => {
+  await nextFrame();
+  await nextFrame();
+  await waitForImages(container);
+  await nextFrame();
+};
+
+export const printPresenterSlides = async (slides: PresenterSlideData[]) => {
+  if (typeof window === 'undefined') {
+    return;
+  }
+
+  const { cleanup, container } = mountPresenterPrintSlides(slides);
+  const scopedCleanups: Array<() => void> = [];
+  let cleaned = false;
+  let fallbackTimer: number | undefined;
+  const cleanupOnce = () => {
+    if (cleaned) {
+      return;
+    }
+    cleaned = true;
+    window.clearTimeout(fallbackTimer);
+    window.removeEventListener('afterprint', cleanupOnce);
+    scopedCleanups.splice(0).forEach((scopedCleanup) => scopedCleanup());
+    cleanup();
+  };
+
+  try {
+    window.addEventListener('afterprint', cleanupOnce, { once: true });
+    await waitForPresenterPrintReady(container);
+    scopedCleanups.push(wrapInterlinksWithAnchor(container));
+    scopedCleanups.push(wrapMediaWithLink(container));
+    await nextFrame();
+    window.print();
+    // Fallback in case `afterprint` never fires (some browsers/headless).
+    fallbackTimer = window.setTimeout(cleanupOnce, PRINT_CLEANUP_DELAY_MS);
+  } catch (error) {
+    cleanupOnce();
+    throw error;
+  }
+};
diff --git a/src/frontend/apps/impress/src/pages/docs/[id]/index.tsx b/src/frontend/apps/impress/src/pages/docs/[id]/index.tsx
index f074f20d9f..3a4ba58e71 100644
--- a/src/frontend/apps/impress/src/pages/docs/[id]/index.tsx
+++ b/src/frontend/apps/impress/src/pages/docs/[id]/index.tsx
@@ -18,6 +18,7 @@ import {
 } from '@/docs/doc-management/';
 import { KEY_AUTH, setAuthUrl, useAuth } from '@/features/auth';
 import { FloatingBar } from '@/features/docs/doc-header/components/FloatingBar';
+import { PresenterRoot } from '@/features/docs/doc-presenter';
 import { getDocChildren, subPageToTree } from '@/features/docs/doc-tree/';
 import { DocEditorSkeleton, useSkeletonStore } from '@/features/skeletons';
 import { MainLayout } from '@/layouts';
@@ -68,6 +69,7 @@ export function DocLayout() {
           <FloatingBar />
           <DocPage id={id} />
         </MainLayout>
+        <PresenterRoot />
       </TreeProvider>
     </>
   );