@agent-native/core 0.161.9 → 0.161.12

package/corpus/templates/slides/app/components/editor/SlideEditor.tsx

@@ -662,9 +662,13 @@ interface SlideEditorProps {
    * reconcile path knows not to replace the deck under an active in-progress
    * edit, even before a `content` update has been flushed.
    */
-  onInlineEditStart?: () => void;
-  /** Called after inline edit mode exits and its draft has been handed off. */
-  onInlineEditEnd?: () => void;
+  onInlineEditStart?: (slideId: string) => void;
+  /** Called after inline edit mode exits and its draft has been handed off.
+   *  Always receives the slide that was actually being edited — the slide
+   *  prop may have already advanced to a new slide by the time this fires
+   *  (see the slide-switch effect), so callers must not substitute their own
+   *  "current slide" state for this argument. */
+  onInlineEditEnd?: (slideId: string) => void;
   /** Other users (besides the current user) currently viewing/editing THIS
    *  slide. Drives the soft same-slide-edit indicator on the canvas so a user
    *  knows before they clobber someone else's last-writer-wins text edit. */
@@ -1183,6 +1187,11 @@ export default function SlideEditor({
     () => getCopiedElementStyle() !== null,
   );
   const contextMenuTargetRef = useRef<HTMLElement | null>(null);
+  const contextMenuTableCellRef = useRef<HTMLTableCellElement | null>(null);
+  const [contextMenuTableInfo, setContextMenuTableInfo] = useState<{
+    rowCount: number;
+    colCount: number;
+  } | null>(null);
   const selectionOverlayMeasurementKey = createSelectionOverlayMeasurementKey({
     slideId: slide.id,
     content,
@@ -1527,6 +1536,13 @@ export default function SlideEditor({
   useEffect(() => {
     onUpdateSlideRef.current = onUpdateSlide;
   }, [onUpdateSlide]);
+  /** Latest onInlineEditEnd in a ref so the unmount cleanup below (which must
+   *  run with a stable, empty dependency array) always calls the current
+   *  version instead of whatever was passed on the very first render. */
+  const onInlineEditEndRef = useRef(onInlineEditEnd);
+  useEffect(() => {
+    onInlineEditEndRef.current = onInlineEditEnd;
+  }, [onInlineEditEnd]);
   const inlineEditDraftRef = useRef<InlineEditContentSnapshot | null>(null);
   const inlineEditInitialContentRef = useRef<InlineEditContentSnapshot | null>(
     null,
@@ -1870,7 +1886,7 @@ export default function SlideEditor({
     ) {
       onUpdateSlideRef.current({ content: html });
     }
-    onInlineEditEnd?.();
+    onInlineEditEnd?.(slide.id);
     inlineEditDraftRef.current = null;
     inlineEditInitialContentRef.current = null;
     const escape = slidesCanvasInteractionCore.escape({
@@ -1910,7 +1926,7 @@ export default function SlideEditor({
       // Mark the deck dirty immediately so SSE/poll refreshes do not replace
       // the deck under an active contentEditable edit, even before the user
       // types and triggers an onUpdateSlide flush.
-      onInlineEditStart?.();
+      onInlineEditStart?.(slide.id);
       // Don't override the selection. The browser's native double-click
       // word-select (or single-click caret) is already on the element from the
       // user's gesture; re-selecting from JS clobbers it. focus() on an
@@ -1953,12 +1969,23 @@ export default function SlideEditor({
       onUpdateSlideRef.current({ content: draft.content }, previousSlideId);
       inlineEditDraftRef.current = null;
     }
-    if (editing || draft) onInlineEditEnd?.();
+    if (editing || draft) onInlineEditEnd?.(previousSlideId);
     inlineEditInitialContentRef.current = null;
 
     previousSlideIdRef.current = slide.id;
   }, [onInlineEditEnd, slide.id]);
 
+  // Editor unmount (navigating away, closing the deck) skips the slide-switch
+  // effect above entirely, so an active edit's "mid-edit" marker would
+  // otherwise never clear and permanently block live sync for that slide.
+  useEffect(() => {
+    return () => {
+      if (editingElRef.current || inlineEditDraftRef.current) {
+        onInlineEditEndRef.current?.(previousSlideIdRef.current);
+      }
+    };
+  }, []);
+
   useEffect(() => {
     if (!editingEl) return;
     const editingSlideId = slide.id;
@@ -2608,6 +2635,107 @@ export default function SlideEditor({
     resolveSelectedElement,
   ]);
 
+  const commitTableMutation = useCallback(() => {
+    const html = readCurrentSlideContentHtml();
+    if (html !== null) onUpdateSlideRef.current({ content: html });
+  }, [readCurrentSlideContentHtml]);
+
+  /** Row/column ops below index cells by position, which only holds for a
+   *  regular grid. `colspan`/`rowspan` are valid on imported tables
+   *  (sanitize-slide-html allows them), so every op bails here rather than
+   *  silently touching the wrong cell. */
+  const tableHasMergedCells = useCallback((table: HTMLTableElement) => {
+    return Array.from(table.rows).some((row) =>
+      Array.from(row.cells).some((c) => c.colSpan > 1 || c.rowSpan > 1),
+    );
+  }, []);
+
+  /** Column ops change cell count per row but not col tracks. A colgroup
+   *  (imported decks can carry one — sanitize-slide-html allows it)
+   *  positionally maps each col element to a column, so an unsynced insert
+   *  or delete leaves too few/many tracks and visually misaligns columns.
+   *  Row ops don't touch columns, so this only guards column ops. */
+  const tableHasColgroup = useCallback((table: HTMLTableElement) => {
+    return table.querySelector("colgroup") !== null;
+  }, []);
+
+  const insertTableRow = useCallback(
+    (cell: HTMLTableCellElement, position: "above" | "below") => {
+      const row = cell.closest("tr");
+      const table = row?.closest("table");
+      if (!row || !table || tableHasMergedCells(table)) return;
+      const newRow = row.cloneNode(true) as HTMLTableRowElement;
+      Array.from(newRow.cells).forEach((c) => {
+        c.innerHTML = "";
+      });
+      row.insertAdjacentElement(
+        position === "above" ? "beforebegin" : "afterend",
+        newRow,
+      );
+      commitTableMutation();
+    },
+    [commitTableMutation, tableHasMergedCells],
+  );
+
+  const deleteTableRow = useCallback(
+    (cell: HTMLTableCellElement) => {
+      const row = cell.closest("tr");
+      const table = row?.closest("table");
+      if (
+        !row ||
+        !table ||
+        table.rows.length <= 1 ||
+        tableHasMergedCells(table)
+      ) {
+        return;
+      }
+      row.remove();
+      commitTableMutation();
+    },
+    [commitTableMutation, tableHasMergedCells],
+  );
+
+  const insertTableColumn = useCallback(
+    (cell: HTMLTableCellElement, position: "left" | "right") => {
+      const table = cell.closest("table");
+      if (!table) return;
+      const columnIndex = cell.cellIndex;
+      Array.from(table.rows).forEach((row) => {
+        const refCell = row.cells[columnIndex];
+        if (!refCell) return;
+        if (tableHasMergedCells(table) || tableHasColgroup(table)) return;
+        const newCell = document.createElement(
+          refCell.tagName,
+        ) as HTMLTableCellElement;
+        newCell.className = refCell.className;
+        const style = refCell.getAttribute("style");
+        if (style) newCell.setAttribute("style", style);
+        refCell.insertAdjacentElement(
+          position === "left" ? "beforebegin" : "afterend",
+          newCell,
+        );
+      });
+      commitTableMutation();
+    },
+    [commitTableMutation, tableHasMergedCells, tableHasColgroup],
+  );
+
+  const deleteTableColumn = useCallback(
+    (cell: HTMLTableCellElement) => {
+      const table = cell.closest("table");
+      if (!table) return;
+      const columnIndex = cell.cellIndex;
+      const firstRow = table.rows[0];
+      if (!firstRow || firstRow.cells.length <= 1) return;
+      Array.from(table.rows).forEach((row) => {
+        if (tableHasMergedCells(table) || tableHasColgroup(table)) return;
+        row.cells[columnIndex]?.remove();
+      });
+      commitTableMutation();
+    },
+    [commitTableMutation, tableHasMergedCells, tableHasColgroup],
+  );
+
   // Delete/Backspace removes the selected slide content (single or
   // multi-select). Only active when something is selected for styling (not
   // while inline-editing text, where Backspace should delete a character) and
@@ -2694,6 +2822,23 @@ export default function SlideEditor({
     [],
   );
 
+  const findTableCell = useCallback(
+    (
+      target: HTMLElement,
+      slideContent: HTMLElement,
+    ): HTMLTableCellElement | null => {
+      let el: HTMLElement | null = target;
+      while (el && slideContent.contains(el) && el !== slideContent) {
+        if (el.tagName === "TD" || el.tagName === "TH") {
+          return el as HTMLTableCellElement;
+        }
+        el = el.parentElement;
+      }
+      return null;
+    },
+    [],
+  );
+
   /** True if the click is on "whitespace" inside the slide (not on any leaf) */
   const isSlideWhitespaceTarget = useCallback(
     (target: HTMLElement, slideContent: HTMLElement): boolean => {
@@ -4525,7 +4670,6 @@ export default function SlideEditor({
 
       applyMultiSelection(hits);
     };
-
     const onUp = () => finish(false);
     const onCancel = () => finish(true);
     window.addEventListener("pointermove", onMove);
@@ -4838,13 +4982,29 @@ export default function SlideEditor({
       const slideContent = getSlideContent();
       if (!slideContent) {
         contextMenuTargetRef.current = null;
+        contextMenuTableCellRef.current = null;
+        setContextMenuTableInfo(null);
         return;
       }
 
+      const tableCell = readOnly ? null : findTableCell(target, slideContent);
+      contextMenuTableCellRef.current = tableCell;
+      const table = tableCell?.closest("table") ?? null;
+      setContextMenuTableInfo(
+        table
+          ? {
+              rowCount: table.rows.length,
+              colCount: tableCell
+                ? (tableCell.parentElement?.childElementCount ?? 0)
+                : 0,
+            }
+          : null,
+      );
+
       const selectable = findSelectableElement(target, slideContent);
       if (!selectable) {
         contextMenuTargetRef.current = null;
-        clearCanvasSelection();
+        if (!tableCell) clearCanvasSelection();
         return;
       }
 
@@ -4866,8 +5026,10 @@ export default function SlideEditor({
       clearCanvasSelection,
       clearMultiSelection,
       findSelectableElement,
+      findTableCell,
       getSlideContent,
       multiSelection,
+      readOnly,
       selectElementForStyling,
     ],
   );
@@ -5251,7 +5413,11 @@ export default function SlideEditor({
                   >
                     <ContextMenu
                       onOpenChange={(open) => {
-                        if (!open) contextMenuTargetRef.current = null;
+                        if (!open) {
+                          contextMenuTargetRef.current = null;
+                          contextMenuTableCellRef.current = null;
+                          setContextMenuTableInfo(null);
+                        }
                       }}
                     >
                       <ContextMenuTrigger asChild disabled={readOnly}>
@@ -5341,6 +5507,62 @@ export default function SlideEditor({
                         </div>
                       </ContextMenuTrigger>
                       <ContextMenuContent>
+                        {contextMenuTableInfo && (
+                          <>
+                            <ContextMenuItem
+                              onSelect={() => {
+                                const cell = contextMenuTableCellRef.current;
+                                if (cell) insertTableRow(cell, "above");
+                              }}
+                            >
+                              {t("styleInspector.insertRowAbove")}
+                            </ContextMenuItem>
+                            <ContextMenuItem
+                              onSelect={() => {
+                                const cell = contextMenuTableCellRef.current;
+                                if (cell) insertTableRow(cell, "below");
+                              }}
+                            >
+                              {t("styleInspector.insertRowBelow")}
+                            </ContextMenuItem>
+                            <ContextMenuItem
+                              disabled={contextMenuTableInfo.rowCount <= 1}
+                              onSelect={() => {
+                                const cell = contextMenuTableCellRef.current;
+                                if (cell) deleteTableRow(cell);
+                              }}
+                            >
+                              {t("styleInspector.deleteRow")}
+                            </ContextMenuItem>
+                            <ContextMenuSeparator />
+                            <ContextMenuItem
+                              onSelect={() => {
+                                const cell = contextMenuTableCellRef.current;
+                                if (cell) insertTableColumn(cell, "left");
+                              }}
+                            >
+                              {t("styleInspector.insertColumnLeft")}
+                            </ContextMenuItem>
+                            <ContextMenuItem
+                              onSelect={() => {
+                                const cell = contextMenuTableCellRef.current;
+                                if (cell) insertTableColumn(cell, "right");
+                              }}
+                            >
+                              {t("styleInspector.insertColumnRight")}
+                            </ContextMenuItem>
+                            <ContextMenuItem
+                              disabled={contextMenuTableInfo.colCount <= 1}
+                              onSelect={() => {
+                                const cell = contextMenuTableCellRef.current;
+                                if (cell) deleteTableColumn(cell);
+                              }}
+                            >
+                              {t("styleInspector.deleteColumn")}
+                            </ContextMenuItem>
+                            <ContextMenuSeparator />
+                          </>
+                        )}
                         <ContextMenuItem
                           disabled={!hasObjectSelection}
                           onSelect={copySelectedObjects}

package/corpus/templates/slides/app/components/layout/AgentWorkIndicator.tsx

@@ -15,7 +15,25 @@ export function isAgentSidebarVisible() {
   if (style.display === "none" || style.visibility === "hidden") return false;
 
   const rect = panel.getBoundingClientRect();
-  return rect.width > 0 && rect.height > 0;
+  if (rect.width <= 0 || rect.height <= 0) return false;
+
+  for (
+    let ancestor = panel.parentElement;
+    ancestor && ancestor !== document.body;
+    ancestor = ancestor.parentElement
+  ) {
+    if (ancestor.getAttribute("aria-hidden") === "true") return false;
+    if (ancestor.inert) return false;
+    const ancestorStyle = window.getComputedStyle(ancestor);
+    if (
+      ancestorStyle.display === "none" ||
+      ancestorStyle.visibility === "hidden"
+    ) {
+      return false;
+    }
+  }
+
+  return true;
 }
 
 function useAgentSidebarVisible() {
@@ -25,20 +43,49 @@ function useAgentSidebarVisible() {
     const update = () => setVisible(isAgentSidebarVisible());
     update();
 
-    const observer = new MutationObserver(update);
-    observer.observe(document.body, {
-      attributes: true,
-      attributeFilter: ["aria-hidden", "class", "inert", "style"],
-      childList: true,
-      subtree: true,
-    });
+    // The panel is a portal and is normally a direct child of body. Discover
+    // portal mount/unmounts with a shallow child-list observer, then watch only
+    // the panel and its immediate parent. Observing every body attribute and
+    // descendant mutation made this tiny indicator run on every editor render.
+    let panelObserver: MutationObserver | null = null;
+    let parentObserver: MutationObserver | null = null;
+
+    const observePanel = () => {
+      panelObserver?.disconnect();
+      parentObserver?.disconnect();
+      const panel = document.querySelector<HTMLElement>(".agent-sidebar-panel");
+      if (!panel) return;
+
+      panelObserver = new MutationObserver(update);
+      panelObserver.observe(panel, {
+        attributes: true,
+        attributeFilter: ["aria-hidden", "class", "inert", "style"],
+      });
+      if (panel.parentElement && panel.parentElement !== document.body) {
+        parentObserver = new MutationObserver(update);
+        parentObserver.observe(panel.parentElement, {
+          attributes: true,
+          attributeFilter: ["aria-hidden", "class", "inert", "style"],
+          childList: true,
+        });
+      }
+    };
+    const updateAndObserve = () => {
+      update();
+      observePanel();
+    };
+    const discovery = new MutationObserver(updateAndObserve);
+    discovery.observe(document.body, { childList: true });
+    updateAndObserve();
     window.addEventListener("resize", update);
     window.addEventListener("agent-panel:open", update);
     window.addEventListener("agent-panel:toggle", update);
     window.addEventListener("agent-panel:set-mode", update);
 
     return () => {
-      observer.disconnect();
+      discovery.disconnect();
+      panelObserver?.disconnect();
+      parentObserver?.disconnect();
       window.removeEventListener("resize", update);
       window.removeEventListener("agent-panel:open", update);
       window.removeEventListener("agent-panel:toggle", update);

package/corpus/templates/slides/app/context/DeckContext.tsx

@@ -379,6 +379,35 @@ const DECK_SAVE_RETRY_BASE_MS = 250;
 // Ops are appended by enqueueDeckOp and drained when the debounce fires.
 const pendingOpsQueue = new Map<string, GranularOp[]>();
 
+// The ops a deck's current in-flight save actually sent, so a slide-scoped
+// check can tell "this slide's save is in flight" from "some other slide in
+// this deck has a save in flight" — `inFlightSaves` alone can't, since it is
+// deck-wide and previously made every slide in the deck look pending for the
+// whole request duration, starving unrelated agent writes of live sync.
+const inFlightOpSlides = new Map<string, GranularOp[]>();
+
+// Slides currently mid inline-edit (contentEditable open, keystrokes not yet
+// committed to a "patch-slide" op). `onInlineEditStart`/`onInlineEditEnd`
+// keep this current; a slide only reaches `pendingOpsQueue` when editing
+// ends, so this is the only signal that catches live, uncommitted typing.
+const activeInlineEditSlides = new Map<string, Set<string>>();
+
+/** Mark `slideId` as mid inline-edit so a concurrent agent write to the same
+ *  slide is not adopted over the user's uncommitted keystrokes. */
+export function markSlideEditingActive(deckId: string, slideId: string) {
+  const set = activeInlineEditSlides.get(deckId) ?? new Set<string>();
+  set.add(slideId);
+  activeInlineEditSlides.set(deckId, set);
+}
+
+/** Clear the mid-edit mark once inline editing ends (committed or discarded). */
+export function clearSlideEditingActive(deckId: string, slideId: string) {
+  const set = activeInlineEditSlides.get(deckId);
+  if (!set) return;
+  set.delete(slideId);
+  if (set.size === 0) activeInlineEditSlides.delete(deckId);
+}
+
 // Cached snapshot for useSyncExternalStore. MUST be stable when either value
 // is unchanged or React will infinite-loop (it compares snapshots with
 // Object.is — a fresh object literal every call schedules a new update,
@@ -528,6 +557,7 @@ function drainPendingDeckOps(deckId: string): Promise<void> {
     typeof AbortController === "undefined" ? null : new AbortController();
   if (controller) inFlightSaveControllers.set(deckId, controller);
   inFlightSaves.add(deckId);
+  inFlightOpSlides.set(deckId, ops);
   const isCurrentGeneration = () =>
     (deckSaveGenerations.get(deckId) ?? 0) === generation;
   const next = persistDeckOps(deckId, ops, controller?.signal)
@@ -568,6 +598,7 @@ function drainPendingDeckOps(deckId: string): Promise<void> {
           inFlightSaveControllers.delete(deckId);
         }
         inFlightSaves.delete(deckId);
+        inFlightOpSlides.delete(deckId);
         const flushImmediately = immediateFlushRequests.delete(deckId);
         notifySaveListeners();
         if (flushImmediately) {
@@ -1250,6 +1281,61 @@ export function mergeServerAddedSlides(local: Deck, server: Deck): Deck {
   return { ...local, slides: merged };
 }
 
+/** True when `op` is a deck-wide write (touches every slide) or targets
+ *  `slideId` specifically. */
+function opTargetsSlide(op: GranularOp, slideId: string): boolean {
+  return (
+    op.op === "full-replace" ||
+    op.op === "reorder-slides" ||
+    ("slideId" in op && op.slideId === slideId)
+  );
+}
+
+/**
+ * True when some queued-or-in-flight write for `deckId` could still touch
+ * `slideId`, so adopting the server's copy of that slide would race a local
+ * write instead of reflecting it. Checking the actual ops (queued or
+ * in-flight) rather than a deck-wide "a save is running" flag matters: an
+ * in-flight save for slide B must not block slide A's live update for the
+ * whole request duration. The slide being mid inline-edit (typing not yet
+ * committed to any op) also counts as a pending write.
+ */
+function hasPendingWriteForSlide(deckId: string, slideId: string): boolean {
+  if (activeInlineEditSlides.get(deckId)?.has(slideId)) return true;
+  const inFlightOps = inFlightOpSlides.get(deckId);
+  if (inFlightOps?.some((op) => opTargetsSlide(op, slideId))) return true;
+  const queue = pendingOpsQueue.get(deckId);
+  if (!queue) return false;
+  return queue.some((op) => opTargetsSlide(op, slideId));
+}
+
+/**
+ * Same additive merge as `mergeServerAddedSlides`, but additionally adopts
+ * the server's content for `changedSlideId` when no local write is pending
+ * for that specific slide. This closes the gap where an agent edit to a
+ * slide that already exists locally (e.g. removing a table row) was
+ * otherwise invisible until the deck went fully clean or the page reloaded —
+ * see the module doc on `refetchOpenDeckIfChanged`.
+ */
+export function mergeServerSlideUpdate(
+  local: Deck,
+  server: Deck,
+  changedSlideId: string | undefined,
+  deckId: string,
+): Deck {
+  const merged = mergeServerAddedSlides(local, server);
+  if (!changedSlideId || hasPendingWriteForSlide(deckId, changedSlideId)) {
+    return merged;
+  }
+  const serverSlide = server.slides.find((s) => s.id === changedSlideId);
+  if (!serverSlide) return merged;
+  const idx = merged.slides.findIndex((s) => s.id === changedSlideId);
+  if (idx < 0 || merged.slides[idx] === serverSlide) return merged;
+  const nextSlides = [...merged.slides];
+  nextSlides[idx] = serverSlide;
+  return { ...merged, slides: nextSlides };
+}
+
 export const defaultSlideContent: Record<SlideLayout, string> = {
   title: `<div class="fmd-slide" style="padding: 80px 110px; justify-content: space-between;">
   <div>
@@ -1557,7 +1643,7 @@ export function DeckProvider({ children }: { children: ReactNode }) {
   const refetchOpenDeckIfChanged = useCallback(
     async (
       currentOpenId: string,
-      options?: { clearPendingWrites?: boolean },
+      options?: { clearPendingWrites?: boolean; changedSlideId?: string },
     ): Promise<Deck | null> => {
       const requestId =
         (openDeckRequestIdByDeckRef.current.get(currentOpenId) ?? 0) + 1;
@@ -1584,7 +1670,12 @@ export function DeckProvider({ children }: { children: ReactNode }) {
 
       if (hasLocalEdits && clientDeck) {
         // Content-preserving: only ADD server slides missing locally.
-        const merged = mergeServerAddedSlides(clientDeck, serverDeck);
+        const merged = mergeServerSlideUpdate(
+          clientDeck,
+          serverDeck,
+          options?.changedSlideId,
+          currentOpenId,
+        );
         if (merged === clientDeck) return serverDeck; // nothing new to surface
         lastExternalUpdateRef.current = Date.now();
         setDecks((prev) => {
@@ -1874,7 +1965,12 @@ export function DeckProvider({ children }: { children: ReactNode }) {
             // write that arrived during the same local edit. The reconciler
             // preserves local slide bodies and local-only slides while still
             // surfacing server-added slides immediately.
-            void refetchOpenDeckIfChanged(data.deckId).catch((error) => {
+            const changedSlideId =
+              typeof data.slideId === "string" ? data.slideId : undefined;
+            const refetchPromise = refetchOpenDeckIfChanged(data.deckId, {
+              changedSlideId,
+            });
+            void refetchPromise.catch((error) => {
               console.error(
                 `Failed to refresh deck ${data.deckId} after sync event:`,
                 error,

package/corpus/templates/slides/app/i18n/en-US.ts

@@ -444,6 +444,12 @@ const messages = {
     pasteStyle: "Paste style",
     copy: "Copy",
     paste: "Paste",
+    insertRowAbove: "Insert row above",
+    insertRowBelow: "Insert row below",
+    deleteRow: "Delete row",
+    insertColumnLeft: "Insert column left",
+    insertColumnRight: "Insert column right",
+    deleteColumn: "Delete column",
   },
   animations: {
     appear: "Appear",

package/corpus/templates/slides/app/pages/DeckEditor.tsx

@@ -58,8 +58,10 @@ import {
 } from "@/components/ui/alert-dialog";
 import { Button } from "@/components/ui/button";
 import {
+  clearSlideEditingActive,
   deckIdFromPathname,
   hasUnsavedDeckChanges,
+  markSlideEditingActive,
   type Slide,
   useDecks,
   useSaveState,
@@ -1561,11 +1563,15 @@ export default function DeckEditor() {
                 options,
               )
             }
-            onInlineEditStart={() => {
+            onInlineEditStart={(slideId) => {
               setInlineEditActive(true);
               markDeckDirty(id);
+              if (id) markSlideEditingActive(id, slideId);
+            }}
+            onInlineEditEnd={(slideId) => {
+              setInlineEditActive(false);
+              if (id) clearSlideEditingActive(id, slideId);
             }}
-            onInlineEditEnd={() => setInlineEditActive(false)}
             onGenerateImage={() => setImageGenOpen(true)}
             onOpenAssetLibrary={(src) => {
               setReplaceImageSrc(src);

package/dist/action.js

@@ -326,8 +326,8 @@ const SUBSCHEMA_MAP_KEYS = [
     "dependentSchemas",
 ];
 /**
- * Remove JSON Schema keywords that some providers' function-calling schema
- * validators reject. OpenAI (and Gemini via the Builder gateway) reject
+ * Remove or rewrite JSON Schema keywords that some providers' function-calling
+ * schema validators reject. OpenAI (and Gemini via the Builder gateway) reject
  * `propertyNames` — which Zod v4 emits for `z.record(z.string(), …)` — with a
  * `400 invalid_function_parameters` error, causing the model turn to produce no
  * content (surfacing as an empty assistant response). Anthropic ignores the
@@ -335,6 +335,15 @@ const SUBSCHEMA_MAP_KEYS = [
  * portable. `propertyNames` only constrained object *keys*; the value/shape of
  * the object is unaffected by its removal.
  *
+ * OpenAI rejects `oneOf` the same way — "Invalid schema for function 'x': …
+ * 'oneOf' is not permitted" — while accepting `anyOf`. Zod v4's `toJSONSchema`
+ * emits `oneOf` for every `z.discriminatedUnion`, so any action with one was
+ * 400'd for the whole request before a token streamed, and the gateway folded
+ * that 400 into a generic 500. Measured: 178k events / 786 users over seven
+ * weeks from a single action. For a discriminated union the two keywords accept
+ * the same documents, and the tool-input validator already handles both
+ * (see `narrowUnionBranchErrors`), so the rewrite is behaviour-preserving.
+ *
  * Only descends through actual subschema positions (properties, items, union
  * branches, definitions, etc.) — never through value-bearing keywords like
  * `default`, `const`, `enum`, or `examples`, whose objects may legitimately
@@ -371,6 +380,14 @@ function stripUnsupportedSchemaKeywords(node) {
             }
         }
     }
+    // After descending, so nested unions are rewritten too. Merged rather than
+    // overwritten on the pathological case where a schema carries both: dropping
+    // either arm would silently narrow what the tool accepts.
+    if (Array.isArray(obj.oneOf)) {
+        const existing = Array.isArray(obj.anyOf) ? obj.anyOf : [];
+        obj.anyOf = [...existing, ...obj.oneOf];
+        delete obj.oneOf;
+    }
     return node;
 }
 /**