pmx-canvas 0.9.3 → 0.11.0

package/src/client/nodes/use-iframe-content-height.ts

@@ -22,21 +22,35 @@ export function useIframeContentHeight(
   node: CanvasNodeState,
   iframeRef: { current: HTMLIFrameElement | null },
   frameToken: string,
-): void {
+): () => void {
   useEffect(() => {
     if (!frameToken) return undefined;
     let timer: ReturnType<typeof setTimeout> | null = null;
-    let pendingHeight: number | null = null;
+    let pending: { frame: HTMLIFrameElement; height: number } | null = null;
+    let lastMeasurement: { frame: HTMLIFrameElement; height: number; width: number; chrome: number } | null = null;
     const held = () =>
       grabbingNodeId.value === node.id || otherHumans.value.some((human) => human.grabbingNodeId === node.id);
     function apply() {
       timer = null;
-      if (held() || pendingHeight === null) return;
-      const reported = pendingHeight;
-      pendingHeight = null;
+      if (held() || pending === null) return;
+      const { frame, height: reported } = pending;
+      pending = null;
+      if (frame !== iframeRef.current) return;
       const current = nodes.value.get(node.id);
-      if (!current) return;
-      const target = computeContentGrowHeight(current, reported);
+      const card = frame.closest<HTMLElement>('.canvas-node');
+      if (!current || !card) return;
+      const chrome = card.offsetHeight - frame.clientHeight;
+      // Undo changes the viewport, which makes the reporter resend unchanged
+      // content. A replacement document owns a fresh fit even at the same size.
+      if (
+        lastMeasurement?.frame === frame &&
+        lastMeasurement.height === reported &&
+        lastMeasurement.width === current.size.width &&
+        lastMeasurement.chrome === chrome
+      )
+        return;
+      lastMeasurement = { frame, height: reported, width: current.size.width, chrome };
+      const target = computeContentGrowHeight(current, reported, chrome);
       if (target === null) return;
       const position = contentFitPosition(current, target, Array.from(nodes.value.values()));
       const moved = position.x !== current.position.x || position.y !== current.position.y;
@@ -49,18 +63,19 @@ export function useIframeContentHeight(
     }
     function schedule() {
       if (timer !== null) clearTimeout(timer);
-      timer = pendingHeight !== null && !held() ? setTimeout(apply, 300) : null;
+      timer = pending !== null && !held() ? setTimeout(apply, 300) : null;
     }
     const dispose = effect(() => {
       held();
       schedule();
     });
     function onMessage(event: MessageEvent) {
-      if (event.source !== iframeRef.current?.contentWindow) return;
+      const frame = iframeRef.current;
+      if (!frame || event.source !== frame.contentWindow) return;
       const d = event.data as { source?: string; type?: string; token?: string; height?: unknown } | null;
       if (!d || d.source !== 'pmx-canvas-frame' || d.type !== 'content-height' || d.token !== frameToken) return;
       if (typeof d.height !== 'number' || !Number.isFinite(d.height) || d.height <= 0) return;
-      pendingHeight = d.height;
+      pending = { frame, height: d.height };
       schedule();
     }
     window.addEventListener('message', onMessage);
@@ -70,4 +85,13 @@ export function useIframeContentHeight(
       if (timer !== null) clearTimeout(timer);
     };
   }, [node.id, frameToken]);
+  // Pending documents can report before promotion, when they are deliberately
+  // not the active ref. Ask the promoted document for a fresh measurement.
+  return () => {
+    if (!frameToken) return;
+    iframeRef.current?.contentWindow?.postMessage(
+      { source: 'pmx-canvas-frame', type: 'measure-content', token: frameToken },
+      '*',
+    );
+  };
 }

package/src/client/nodes/use-surface-frame.ts

@@ -1,6 +1,7 @@
 import { useEffect, useState } from 'preact/hooks';
 import { iframeMode } from '../state/iframe-mode';
 import { isHostedWorkbench, workbenchFetch } from '../state/workbench-transport';
+import { VIEWER_LOAD_DEADLINE_MS, type ViewerSource } from './ViewerFrame';
 
 function isSameOriginUrl(url: string): boolean {
   if (isHostedWorkbench()) return url.startsWith('/') && !url.startsWith('//');
@@ -17,34 +18,45 @@ function isSameOriginUrl(url: string): boolean {
  * iframes are blocked by the embedding context (nested-iframe hosts like Amp
  * orb portals). Cross-origin URLs always stay `src` — they cannot be fetched
  * from here. While the probe is pending, same-origin frames stay empty rather
- * than loading a src that may show the broken placeholder; a failed srcdoc
- * fetch falls back to `src` (no worse than before).
+ * than loading a src that may show the broken placeholder. Preparation failures
+ * use the shared host's Retry, never a second load path the embed probe rejected.
  */
-export function useSurfaceFrame(url: string): { src?: string; srcdoc?: string } {
+export function useSurfaceFrame(url: string): ViewerSource {
   const mode = iframeMode.value;
   const [doc, setDoc] = useState<{ url: string; html: string } | null>(null);
+  const [error, setError] = useState(false);
+  const [attempt, setAttempt] = useState(0);
   const sameOrigin = Boolean(url) && isSameOriginUrl(url);
   const wantsSrcdoc = mode === 'srcdoc' && sameOrigin;
 
   useEffect(() => {
+    setError(false);
     if (!wantsSrcdoc) return;
     let cancelled = false;
+    const controller = new AbortController();
+    const deadline = setTimeout(() => controller.abort(), VIEWER_LOAD_DEADLINE_MS);
     // Ask the server to inline bundle assets (the mermaid renderer): hosts
     // that force srcdoc mode block sub-frame subresource requests too.
-    void workbenchFetch(`${url}${url.includes('?') ? '&' : '?'}inline-assets=1`, { credentials: 'same-origin' })
+    void workbenchFetch(`${url}${url.includes('?') ? '&' : '?'}inline-assets=1`, {
+      credentials: 'same-origin',
+      signal: controller.signal,
+    })
       .then((res) => (res.ok ? res.text() : Promise.reject(new Error(`HTTP ${res.status}`))))
       .then((html) => {
         if (!cancelled) setDoc({ url, html });
       })
       .catch((error) => {
-        console.error('[surface-frame] srcdoc fetch failed, falling back to src:', url, error);
-        // Empty html marks the src fallback below.
-        if (!cancelled) setDoc({ url, html: '' });
-      });
+        if (cancelled) return;
+        console.error('[surface-frame] document fetch failed:', url, error);
+        setError(true);
+      })
+      .finally(() => clearTimeout(deadline));
     return () => {
       cancelled = true;
+      clearTimeout(deadline);
+      controller.abort();
     };
-  }, [wantsSrcdoc, url]);
+  }, [wantsSrcdoc, url, attempt]);
 
   if (!url) return {};
   if (!wantsSrcdoc) {
@@ -52,6 +64,5 @@ export function useSurfaceFrame(url: string): { src?: string; srcdoc?: string }
   }
   // Keep the previous document visible while a newer URL is being fetched —
   // same UX as src mode, where the old document stays until the new one loads.
-  if (doc) return doc.html ? { srcdoc: doc.html } : { src: doc.url };
-  return {};
+  return { srcdoc: doc?.html, error, retry: () => setAttempt((value) => value + 1) };
 }

package/src/client/nodes/viewer-runtime-state.ts

@@ -1,13 +1,15 @@
 import { effect } from '@preact/signals';
 import { JSON_VIEWER_STATE_SOURCE } from '../../shared/ax-surface-protocol.js';
 import { canvasInteractionEpoch, nodes } from '../state/canvas-store';
+import type { CanvasNodeState } from '../types';
+import { VIEWER_LOAD_DEADLINE_MS } from './ViewerFrame';
 
 type Snapshot = {
   epoch: number;
   version: unknown;
   documentUrl: unknown;
   state: Record<string, unknown> | null;
-  owners: Array<{ token: string; source: Window; mounted: () => void; ready: () => void; cancel: () => void }>;
+  owners: Array<{ token: string; source: Window }>;
 };
 
 // Tab-local UI state only: never persist form drafts in canvas data or AX. Keep
@@ -18,11 +20,12 @@ const snapshots = new Map<string, Snapshot>();
 let listening = false;
 
 export function restoreViewerRuntimeState(
-  nodeId: string,
+  authored: CanvasNodeState,
   token: string,
   source: Window,
   signal?: AbortSignal,
 ): Promise<boolean | 'cancelled'> {
+  const nodeId = authored.id;
   if (!listening) {
     listening = true;
     effect(() => {
@@ -36,7 +39,6 @@ export function restoreViewerRuntimeState(
           snapshot.version !== node.data.specVersion ||
           snapshot.documentUrl !== node.data.url
         ) {
-          for (const owner of snapshot.owners) owner.cancel();
           snapshots.delete(id);
         }
       }
@@ -54,57 +56,61 @@ export function restoreViewerRuntimeState(
       const ownerIndex =
         snapshot?.owners.findIndex((owner) => owner.token === message.token && owner.source === event.source) ?? -1;
       if (!snapshot || ownerIndex < 0) return;
-      if (message.type === 'mounted') {
-        snapshot.owners[ownerIndex]!.mounted();
-        return;
-      }
-      if (message.type === 'ready') {
-        snapshot.owners[ownerIndex]!.ready();
-        return;
-      }
       if (message.type !== 'snapshot') return;
       if (!message.state || typeof message.state !== 'object' || Array.isArray(message.state)) return;
       const { ax: _ax, ...state } = message.state as Record<string, unknown>;
       snapshot.state = state;
       // Once the replacement emits, the retired document cannot overwrite it.
-      const retired = snapshot.owners.slice(0, ownerIndex);
       snapshot.owners = snapshot.owners.slice(ownerIndex);
-      for (const owner of retired) owner.cancel();
     });
   }
   const node = nodes.value.get(nodeId);
   if (!node || signal?.aborted) return Promise.resolve('cancelled');
-  const snapshot: Snapshot = snapshots.get(nodeId) ?? {
-    epoch: canvasInteractionEpoch.value,
-    version: node.data.specVersion,
-    documentUrl: node.data.url,
-    state: null,
-    owners: [],
-  };
-  snapshots.set(nodeId, snapshot);
+  // A retained document may load after its authored spec was replaced. It can
+  // still acknowledge paint, but cannot own or restore the new spec's drafts.
+  const current = node.data.specVersion === authored.data.specVersion && node.data.url === authored.data.url;
+  const snapshot: Snapshot | undefined = current
+    ? (snapshots.get(nodeId) ?? {
+        epoch: canvasInteractionEpoch.value,
+        version: authored.data.specVersion,
+        documentUrl: authored.data.url,
+        state: null,
+        owners: [],
+      })
+    : undefined;
+  if (snapshot) snapshots.set(nodeId, snapshot);
   const ready = new Promise<boolean | 'cancelled'>((resolve) => {
     const finish = (loaded: boolean | 'cancelled') => {
       clearTimeout(timer);
-      signal?.removeEventListener('abort', owner.cancel);
-      if (loaded !== true) snapshot.owners = snapshot.owners.filter((entry) => entry !== owner);
+      window.removeEventListener('message', receive);
+      signal?.removeEventListener('abort', cancel);
+      if (loaded !== true && snapshot) snapshot.owners = snapshot.owners.filter((entry) => entry !== owner);
       resolve(loaded);
     };
-    const owner = {
-      token,
-      source,
-      mounted: () => clearTimeout(timer),
-      ready: () => finish(true),
-      cancel: () => finish('cancelled'),
+    const cancel = () => finish('cancelled');
+    const receive = (event: MessageEvent) => {
+      if (
+        event.source !== source ||
+        event.data?.source !== JSON_VIEWER_STATE_SOURCE ||
+        event.data?.token !== token ||
+        event.data?.nodeId !== nodeId
+      )
+        return;
+      if (event.data.type === 'mounted') clearTimeout(timer);
+      if (event.data.type === 'ready') finish(true);
     };
+    const owner = { token, source };
     // A missing runtime fails, but a healthy offscreen document can wait for
     // paint indefinitely. Its synchronous mount acknowledgement ends the deadline;
     // only the later frame-gated ready message may promote it.
-    const timer = setTimeout(() => finish(false), 10_000);
-    for (const previous of snapshot.owners.filter((entry) => entry.source === source)) previous.cancel();
-    while (snapshot.owners.length > 1) snapshot.owners[0]!.cancel();
-    snapshot.owners.push(owner);
-    signal?.addEventListener('abort', owner.cancel, { once: true });
+    const timer = setTimeout(() => finish(false), VIEWER_LOAD_DEADLINE_MS);
+    if (snapshot) {
+      snapshot.owners = snapshot.owners.filter((entry) => entry.source !== source).slice(-1);
+      snapshot.owners.push(owner);
+    }
+    window.addEventListener('message', receive);
+    signal?.addEventListener('abort', cancel, { once: true });
   });
-  source.postMessage({ source: JSON_VIEWER_STATE_SOURCE, type: 'restore', token, state: snapshot.state }, '*');
+  source.postMessage({ source: JSON_VIEWER_STATE_SOURCE, type: 'restore', token, state: snapshot?.state ?? null }, '*');
   return ready;
 }

package/src/client/state/canvas-store.ts

@@ -637,18 +637,22 @@ export function resizeNode(id: string, size: { width: number; height: number }):
   updateNode(id, { size });
 }
 
-export function bringToFront(id: string): void {
+export function bringToFront(id: string, persist = true): void {
   const existing = nodes.value.get(id);
   if (!existing) return;
-  batch(() => {
-    updateNode(id, { zIndex: maxZ++ });
-    // A group is a frame: it must never stack above its own children.
-    if (existing.type === 'group' && Array.isArray(existing.data.children)) {
-      for (const childId of existing.data.children) {
-        if (typeof childId === 'string' && nodes.value.has(childId)) updateNode(childId, { zIndex: maxZ++ });
-      }
+  const updates = [{ id, zIndex: maxZ++ }];
+  // A group is a frame: it must never stack above its own children.
+  if (existing.type === 'group' && Array.isArray(existing.data.children)) {
+    for (const childId of existing.data.children) {
+      if (typeof childId === 'string' && nodes.value.has(childId)) updates.push({ id: childId, zIndex: maxZ++ });
     }
+  }
+  batch(() => {
+    for (const update of updates) updateNode(update.id, { zIndex: update.zIndex });
   });
+  // Title-bar gestures commit stacking with geometry at pointer-up. A separate
+  // drag-start write would broadcast an old layout over the in-progress move.
+  if (persist) void pushCanvasUpdate(updates, { recordHistory: false });
   activeNodeId.value = id;
 }
 
@@ -820,14 +824,17 @@ export function cancelViewportAnimation(): void {
 // ── Persistence ───────────────────────────────────────────────
 const STORAGE_KEY = 'pmx-canvas-layout';
 
-export function persistLayout(options: { recordHistory?: boolean } = {}): void {
+export function persistLayout(options: { recordHistory?: boolean; raisedNodeId?: string } = {}): void {
   try {
     const allNodes = Array.from(nodes.value.values());
+    const raised = options.raisedNodeId ? nodes.value.get(options.raisedNodeId) : undefined;
+    const raisedChildren = raised?.type === 'group' && Array.isArray(raised.data.children) ? raised.data.children : [];
     const nodeUpdates = allNodes.map((n) => ({
       id: n.id,
       position: n.position,
       size: n.size,
       collapsed: n.collapsed,
+      ...(n.id === raised?.id || raisedChildren.includes(n.id) ? { zIndex: n.zIndex } : {}),
     }));
     const layout = {
       viewport: viewport.value,
@@ -931,7 +938,7 @@ export function fitAll(containerW: number, containerH: number): void {
 }
 
 // ── Focus node ────────────────────────────────────────────────
-export function focusNode(id: string, options: { recordHistory?: boolean } = {}): void {
+export function focusNode(id: string, options: { recordHistory?: boolean; persistStacking?: boolean } = {}): void {
   const node = nodes.value.get(id);
   if (!node) return;
   const v = viewport.value;
@@ -959,7 +966,7 @@ export function focusNode(id: string, options: { recordHistory?: boolean } = {})
     300,
     options,
   );
-  bringToFront(id);
+  bringToFront(id, options.persistStacking !== false);
 }
 
 // ── Cycle focus ───────────────────────────────────────────────
@@ -969,7 +976,6 @@ export function cycleActiveNode(direction: 1 | -1 = 1): void {
   const currentIdx = activeNodeId.value ? all.indexOf(activeNodeId.value) : -1;
   const nextIdx = (currentIdx + direction + all.length) % all.length;
   const nextId = all[nextIdx];
-  bringToFront(nextId);
   focusNode(nextId);
 }
 

package/src/client/state/intent-bridge.ts

@@ -250,6 +250,7 @@ export async function pushCanvasUpdate(
     position?: { x: number; y: number };
     size?: { width: number; height: number };
     collapsed?: boolean;
+    zIndex?: number;
   }>,
   options: { recordHistory?: boolean } = {},
 ): Promise<void> {

package/src/client/state/presentation.ts

@@ -1,14 +1,23 @@
 import { signal } from '@preact/signals';
-import { interpolateCamera, resolveStop, type TourStop } from '../../shared/tour.js';
+import {
+  interpolateCamera,
+  resolveStop,
+  tourStopSchema,
+  type TourPresenter,
+  type TourStop,
+} from '../../shared/tour.js';
 import { canvasArea } from '../canvas/canvas-area';
 import type { ViewportState } from '../types';
-import { animateCameraPath, nodes, viewport } from './canvas-store';
+import { boardGeneration, catalogEpoch } from './boards-store';
+import { animateCameraPath, cancelViewportAnimation, nodes, viewport } from './canvas-store';
 import { requestBestEffort, requestJson } from './intent-bridge';
 
 export const presenting = signal(false);
 export const recordingCamera = signal(false);
 /** Why the current stop cannot be shown (missing target, no stops, server unreachable). */
 export const presentationError = signal('');
+/** Read-only mirror of the server's shared cursor, never advanced optimistically. */
+export const presentationCursor = signal<{ index: number; total: number } | null>(null);
 
 export function ownsCamera(): boolean {
   return presenting.value || recordingCamera.value;
@@ -24,7 +33,21 @@ function prefersReducedMotion(): boolean {
  */
 export function playStop(stop: TourStop, onDone?: (end: ViewportState) => void): void {
   const area = canvasArea();
-  const target = resolveStop(stop, [...nodes.value.values()], area.width, area.height);
+  let target: ViewportState;
+  if (presenting.value && !recordingCamera.value && !('viewport' in stop.target)) {
+    const padding = stop.padding ?? 40;
+    const controls = document.querySelector('.presentation-controls')?.getBoundingClientRect();
+    const top = Math.max(padding, controls ? controls.bottom - area.top + 12 : 0);
+    target = resolveStop(
+      { ...stop, padding: 0 },
+      [...nodes.value.values()],
+      area.width - 2 * padding,
+      area.height - top - padding,
+    );
+    target = { ...target, x: target.x + padding, y: target.y + top };
+  } else {
+    target = resolveStop(stop, [...nodes.value.values()], area.width, area.height);
+  }
   const from = { ...viewport.value };
   const duration = prefersReducedMotion() ? 0 : (stop.duration ?? 1) * 1000;
   animateCameraPath(
@@ -35,6 +58,7 @@ export function playStop(stop: TourStop, onDone?: (end: ViewportState) => void):
 }
 
 let stepSeq = 0;
+let presentationRun = 0;
 
 /**
  * Show a tour stop, entering presentation if needed. Entering hides the
@@ -58,41 +82,137 @@ export function presentStop(stop: TourStop): void {
   else play();
 }
 
-/**
- * Move the server's shared tour cursor. The `canvas-tour-step` echo does the
- * animating, here and in every other presenting viewer, so a human's keys and
- * an agent's `tour.go` always agree on where the tour is.
- */
-export async function stepTour(to: { stop: number } | { step: 'next' | 'previous' }): Promise<void> {
-  const result = await requestJson<{ ok: boolean; error?: string }>(
+let requestSeq = 0;
+const presenterId = crypto.randomUUID();
+let lastDelivery: { catalogEpoch: string; sequence: number; applied: boolean } | null = null;
+
+function nextPresenter(): TourPresenter | null {
+  if (catalogEpoch === null || boardGeneration === null) {
+    presentationError.value = 'The board is still connecting. Try presenting again when it is ready.';
+    return null;
+  }
+  return { clientId: presenterId, intent: ++requestSeq, catalogEpoch, boardGeneration };
+}
+
+function isCurrentPresenter(presenter: TourPresenter): boolean {
+  return (
+    presenter.intent === requestSeq &&
+    presenter.catalogEpoch === catalogEpoch &&
+    presenter.boardGeneration === boardGeneration
+  );
+}
+
+function acceptDelivery(data: Record<string, unknown>, apply: boolean): boolean {
+  if (
+    typeof data.catalogEpoch !== 'string' ||
+    data.catalogEpoch !== catalogEpoch ||
+    data.boardGeneration !== boardGeneration ||
+    typeof data.sequence !== 'number' ||
+    (lastDelivery?.catalogEpoch === catalogEpoch &&
+      (data.sequence < lastDelivery.sequence ||
+        (data.sequence === lastDelivery.sequence && (!apply || lastDelivery.applied))))
+  )
+    return false;
+  lastDelivery = { catalogEpoch: data.catalogEpoch, sequence: data.sequence, applied: apply };
+  return true;
+}
+
+/** Apply either delivery of the server's shared cursor, without replaying its echo. */
+export function applyTourStep(data: Record<string, unknown>): void {
+  if (recordingCamera.value) return;
+  const stop = tourStopSchema.safeParse(data.stop);
+  const display = presenting.value || data.present === true;
+  // Observe hidden steps too. The same operation's HTTP acknowledgement may
+  // authorize local presentation later, but an older acknowledgement must not.
+  if (!stop.success || !acceptDelivery(data, display) || !display) return;
+  if (typeof data.index === 'number' && typeof data.total === 'number') {
+    presentationCursor.value = { index: data.index, total: data.total };
+  }
+  presentStop(stop.data);
+}
+
+export function applyTourExit(data: Record<string, unknown>): void {
+  if (!recordingCamera.value && acceptDelivery(data, true)) hidePresentation();
+}
+
+/** Move the shared cursor. A successful response also works while events are delayed or disconnected. */
+export async function stepTour(
+  to: { stop: number } | { step: 'next' | 'previous' },
+  presenter = nextPresenter(),
+): Promise<void> {
+  if (!presenter) return;
+  const run = presentationRun;
+  const previous = lastDelivery;
+  const result = await requestJson<
+    | {
+        ok: true;
+        catalogEpoch: string;
+        boardGeneration: number;
+        sequence: number;
+        index: number;
+        total: number;
+        stop: TourStop;
+      }
+    | { ok: true; superseded: true }
+    | { ok: false; error?: string }
+  >(
     'step tour',
     '/api/canvas/tour/go',
     { ok: false, error: 'Could not reach the canvas server.' },
     {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ ...to, present: false }),
+      body: JSON.stringify({ ...to, present: false, presenter }),
     },
   );
-  if (!result.ok) presentationError.value = result.error ?? 'Could not change the tour stop.';
+  // Only a local cancellation invalidates this intent. Remote steps/exits are
+  // ordered by the server stamp, even if an older exit hid the pending restart.
+  if (run !== presentationRun || !isCurrentPresenter(presenter)) return;
+  if (result.ok) {
+    if ('superseded' in result) {
+      if (previous === lastDelivery)
+        presentationError.value = 'The presentation request was superseded. Exit and present again.';
+    } else applyTourStep({ ...result, present: true });
+  } else if (previous === lastDelivery) presentationError.value = result.error ?? 'Could not change the tour stop.';
 }
 
 /** Present from the first stop, or resume where the tour already is (`?present=1`). */
 export async function startPresentation(resume = false): Promise<void> {
+  const run = ++presentationRun;
   presenting.value = true;
   presentationError.value = '';
+  presentationCursor.value = null;
+  // Reserve the gesture before the read: an older resume cannot overtake Next.
+  const presenter = nextPresenter();
+  if (!presenter) return;
   const at = resume
     ? (await requestJson<{ position?: number | null }>('read tour', '/api/canvas/tour', {})).position
     : null;
-  await stepTour({ stop: typeof at === 'number' ? at : 0 });
+  if (run !== presentationRun || !isCurrentPresenter(presenter)) return;
+  await stepTour({ stop: typeof at === 'number' ? at : 0 }, presenter);
 }
 
-export function endPresentation(): void {
+function hidePresentation(): void {
+  stepSeq++;
+  cancelViewportAnimation();
   presenting.value = false;
   presentationError.value = '';
+  presentationCursor.value = null;
+}
+
+/** Local cancellation also fences pending requests from this presentation. */
+export function dismissPresentation(): void {
+  presentationRun++;
+  hidePresentation();
+}
+
+export function endPresentation(): void {
+  dismissPresentation();
+  const presenter = nextPresenter();
+  if (!presenter) return;
   void requestBestEffort('exit tour', '/api/canvas/tour/exit', {
     method: 'POST',
     headers: { 'Content-Type': 'application/json' },
-    body: '{}',
+    body: JSON.stringify({ presenter }),
   });
 }