@agent-native/core 0.131.2 → 0.131.4

package/corpus/templates/design/app/pages/design-editor/text-edit-utils.ts

@@ -1,7 +1,38 @@
 import { POINTER_TEXT_EDIT_ACTIVATION_DELAY_MS } from "@/components/design/design-canvas/pending-text-edit";
+import { findCanvasIframeForScreen } from "@/components/design/multi-screen/iframe-targeting";
 
 import { queryUniqueSelector } from "./dom-utils";
 
+/**
+ * Why one begin-text-edit attempt did not end up in an editing session. These
+ * stay distinct on purpose: a screen whose iframe is not mounted yet
+ * ("no-iframe") is a retry-worthy race, while an iframe that answered and does
+ * not have the node ("node-missing") or has it un-focused ("not-editing") is a
+ * different situation entirely. Collapsing them all to `false` is what made the
+ * board-space text bug invisible — every probe failed identically, so nothing
+ * distinguished "asked the wrong window" from "user has not typed yet".
+ */
+export type BeginTextEditOutcome =
+  | "active"
+  | "done"
+  | "node-missing"
+  | "not-editing"
+  | "no-iframe"
+  | "no-reply"
+  /** begin-text-edit was posted; the iframe has not been re-probed yet. Never
+   *  settle on this — it is not evidence the node was abandoned, and the
+   *  caller's exhaustion path deletes untouched nodes. */
+  | "activation-requested";
+
+export function isTextEditSessionOutcome(
+  outcome: BeginTextEditOutcome,
+): boolean {
+  return outcome === "active" || outcome === "done";
+}
+
+/** Grace period before re-probing a just-requested activation. */
+const ACTIVATION_CONFIRM_DELAY_MS = 300;
+
 /**
  * Ask a single iframe's editor-chrome bridge whether a text-edit session for
  * `nodeId` is "active" (focused), "done" (non-empty committed text), or
@@ -13,16 +44,16 @@ import { queryUniqueSelector } from "./dom-utils";
 function queryTextEditStatus(
   iframe: HTMLIFrameElement,
   nodeId: string,
-): Promise<"active" | "done" | false> {
+): Promise<"active" | "done" | "node-missing" | "not-editing" | "no-reply"> {
   const win = iframe.contentWindow;
-  if (!win) return Promise.resolve(false);
+  if (!win) return Promise.resolve("no-reply");
   const correlationId = `text-edit-status-${Date.now()}-${Math.random()
     .toString(36)
     .slice(2, 6)}`;
   return new Promise((resolve) => {
     const timer = window.setTimeout(() => {
       window.removeEventListener("message", listener);
-      resolve(false);
+      resolve("no-reply");
     }, 250);
     const listener = (event: MessageEvent) => {
       if (
@@ -38,7 +69,13 @@ function queryTextEditStatus(
       window.clearTimeout(timer);
       window.removeEventListener("message", listener);
       const status = event.data.status;
-      resolve(status === "active" || status === "done" ? status : false);
+      if (status === "active" || status === "done") {
+        resolve(status);
+        return;
+      }
+      // Older bridges answer a bare `false` for both cases; treat that as
+      // "present but not editing" so the retry ladder behaves as before.
+      resolve(status === "missing" ? "node-missing" : "not-editing");
     };
     window.addEventListener("message", listener);
     win.postMessage(
@@ -48,31 +85,50 @@ function queryTextEditStatus(
   });
 }
 
-async function postBeginTextEditToPreviewIframes(
+async function probeTextEdit(
+  screenId: string | null,
+  nodeId: string,
+  boardFileId: string | null,
+): Promise<BeginTextEditOutcome> {
+  if (typeof document === "undefined" || !nodeId || !screenId) {
+    return "no-iframe";
+  }
+  // The board surface's live iframe carries no `data-screen-iframe-id`, so the
+  // old `dataset.screenIframeId === screenId` filter never matched it and every
+  // attempt fell through to broadcasting at all the *screen* iframes — none of
+  // which own a board node. findCanvasIframeForScreen is the one resolver that
+  // already knows the board's `[data-board-surface-layer]` shape.
+  const iframe = findCanvasIframeForScreen(
+    document.body,
+    screenId,
+    boardFileId ?? undefined,
+  );
+  if (!iframe?.contentWindow) return "no-iframe";
+  return queryTextEditStatus(iframe, nodeId);
+}
+
+/** Probes, and asks the iframe to enter edit mode when it is not already
+ *  editing. Reports `activation-requested` rather than the status observed
+ *  *before* the request: that pre-activation status is not an answer about the
+ *  session it just asked for. */
+async function requestTextEdit(
   screenId: string | null,
   nodeId: string,
-): Promise<"active" | "done" | false> {
-  if (typeof document === "undefined" || !nodeId) return false;
-  const iframes = Array.from(
-    document.querySelectorAll<HTMLIFrameElement>(
-      "iframe[data-design-preview-iframe]",
-    ),
+  boardFileId: string | null,
+): Promise<BeginTextEditOutcome> {
+  const status = await probeTextEdit(screenId, nodeId, boardFileId);
+  if (isTextEditSessionOutcome(status) || status === "no-iframe") return status;
+  const iframe = findCanvasIframeForScreen(
+    document.body,
+    screenId ?? "",
+    boardFileId ?? undefined,
   );
-  const targetIframes = iframes.filter(
-    (iframe) => screenId && iframe.dataset.screenIframeId === screenId,
+  if (!iframe?.contentWindow) return "no-iframe";
+  iframe.contentWindow.postMessage(
+    { type: "begin-text-edit", nodeId, force: true },
+    "*",
   );
-  const orderedIframes = targetIframes.length > 0 ? targetIframes : iframes;
-  for (const iframe of orderedIframes) {
-    const status = await queryTextEditStatus(iframe, nodeId);
-    if (status === "active" || status === "done") return status;
-  }
-  orderedIframes.forEach((iframe) => {
-    iframe.contentWindow?.postMessage(
-      { type: "begin-text-edit", nodeId, force: true },
-      "*",
-    );
-  });
-  return false;
+  return "activation-requested";
 }
 
 /**
@@ -93,13 +149,20 @@ async function postBeginTextEditToPreviewIframes(
 export function scheduleBeginTextEditForScreen(
   screenId: string | null,
   nodeId: string,
-  onExhausted?: (finalStatus: "active" | "done" | false) => void,
+  options?: {
+    /** Board file id, so a board-space text node resolves the board surface's
+     *  iframe instead of looking for a `data-screen-iframe-id` it never has. */
+    boardFileId?: string | null;
+    onExhausted?: (finalStatus: BeginTextEditOutcome) => void;
+  },
 ): () => void {
   if (typeof window === "undefined") return () => {};
+  const onExhausted = options?.onExhausted;
+  const boardFileId = options?.boardFileId ?? null;
   let finished = false;
-  let lastStatus: "active" | "done" | false = false;
+  let lastStatus: BeginTextEditOutcome = "no-iframe";
   const timers: number[] = [];
-  const settle = (status: "active" | "done" | false) => {
+  const settle = (status: BeginTextEditOutcome) => {
     if (finished) return;
     finished = true;
     lastStatus = status;
@@ -119,19 +182,31 @@ export function scheduleBeginTextEditForScreen(
   delays.forEach((delay, index) => {
     const timer = window.setTimeout(() => {
       if (finished) return;
-      void postBeginTextEditToPreviewIframes(screenId, nodeId).then(
-        (status) => {
+      void requestTextEdit(screenId, nodeId, boardFileId).then((status) => {
+        if (finished) return;
+        lastStatus = status;
+        if (isTextEditSessionOutcome(status)) {
+          settle(status);
+          return;
+        }
+        if (index !== delays.length - 1) return;
+        if (status !== "activation-requested") {
+          settle(status);
+          return;
+        }
+        // Activation is still in flight, and the caller deletes untouched nodes
+        // on exhaustion. Settle on what the iframe reports, never on the request.
+        const confirmTimer = window.setTimeout(() => {
           if (finished) return;
-          lastStatus = status;
-          if (status === "active" || status === "done") {
-            settle(status);
-            return;
-          }
-          if (index === delays.length - 1) {
-            settle(false);
-          }
-        },
-      );
+          void probeTextEdit(screenId, nodeId, boardFileId).then(
+            (confirmed) => {
+              if (finished) return;
+              settle(confirmed);
+            },
+          );
+        }, ACTIVATION_CONFIRM_DELAY_MS);
+        timers.push(confirmTimer);
+      });
     }, delay);
     timers.push(timer);
   });

package/corpus/templates/design/changelog/2026-07-28-generated-design-variants-no-longer-overlap-each-other-on-th.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-28
+---
+
+Generated design variants no longer overlap each other on the overview board, and zooming or panning a board with breakpoint frames no longer flashes screen content

package/corpus/templates/design/changelog/2026-07-29-auto-layout-direction-icons-show-an-arrow.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-07-29
+---
+
+Auto-layout direction buttons now show a direction arrow, so the flow direction is readable without hovering for the tooltip.

package/corpus/templates/design/changelog/2026-07-29-breakpoints-no-longer-overlap-neighbouring-screens.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-29
+---
+
+Adding a breakpoint now re-packs the board when the new frames would overlap a neighbouring screen, and the add control says it applies to all screens.

package/corpus/templates/design/changelog/2026-07-29-canvas-is-more-responsive-when-selecting-and-adding-frames.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-07-29
+---
+
+Selecting layers and adding frames are faster: the layer projection is reused for unchanged screens and creating a frame no longer refetches every screen's contents.

package/corpus/templates/design/changelog/2026-07-29-canvas-zoom-is-smoother-and-labels-hold-their-size.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-07-29
+---
+
+Canvas zoom now steps about 10% per mouse notch like Figma instead of nearly tripling, and frame labels hold a constant size throughout the gesture instead of scaling and snapping back.

package/corpus/templates/design/changelog/2026-07-29-double-click-a-frame-now-drills-into-its-layers.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-29
+---
+
+Double-clicking a frame now selects the layer under the pointer so its styling options open, instead of switching the editor into Interact.

package/corpus/templates/design/changelog/2026-07-29-export-preview-shows-the-real-render.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-29
+---
+
+The inspector's export preview now shows the actual rendered output instead of a plain coloured rectangle, and says so when it cannot render.

package/corpus/templates/design/changelog/2026-07-29-figma-parity-shortcuts.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-07-29
+---
+
+Added Figma-parity shortcuts: A also picks the frame tool, Shift+Cmd+G ungroups, and Shift+0 resets zoom to 100%.

package/corpus/templates/design/changelog/2026-07-29-more-breakpoint-width-presets.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-07-29
+---
+
+The breakpoint + menu keeps offering device widths after the default Desktop, Tablet, and Phone breakpoints are added, instead of falling back to a bare number input.

package/corpus/templates/design/changelog/2026-07-29-resize-a-selected-frame-to-a-device-preset.md

@@ -0,0 +1,6 @@
+---
+type: added
+date: 2026-07-29
+---
+
+A selected frame's size is now editable, with a device-preset picker on the Size section, so an existing frame can be set to a phone, tablet, or desktop size.

package/corpus/templates/design/changelog/2026-07-29-text-tool-reaches-the-right-surface.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-29
+---
+
+The text tool now reaches the board's own editing surface, so a text box you draw on the canvas can be typed into immediately, and boxes left empty are cleaned up instead of lingering invisibly.

package/corpus/templates/design/shared/canvas-frames.ts

@@ -58,6 +58,29 @@ export function parseCanvasFrameGeometryById(
   );
 }
 
+/** Y a new group must start at to clear existing frames, or 0 when the board is
+ *  empty. Placing at y=0 unconditionally stacks each new group on the last. */
+export function nextFreeCanvasRowY(
+  existing: unknown,
+  gap: number,
+  options: { ignoreFileIds?: readonly string[] } = {},
+): number {
+  const ignored = new Set(options.ignoreFileIds ?? []);
+  const frames = Object.entries(parseCanvasFrameGeometryById(existing)).filter(
+    ([id]) => !ignored.has(id),
+  );
+  let bottom = 0;
+  let sawFrame = false;
+  for (const [, frame] of frames) {
+    const y = frame.y ?? 0;
+    const height = frame.height ?? 0;
+    if (!Number.isFinite(y) || !Number.isFinite(height)) continue;
+    sawFrame = true;
+    bottom = Math.max(bottom, y + height);
+  }
+  return sawFrame ? bottom + gap : 0;
+}
+
 export function mergeCanvasFramePlacements({
   existing,
   placements,

package/corpus/templates/design/shared/code-layer.ts

@@ -2230,6 +2230,38 @@ function buildProjection(
   };
 }
 
+/**
+ * Most-recently-used projections, keyed by the exact document they came from.
+ *
+ * Projecting means a full HTML parse plus a tree walk, and the editor calls
+ * this on nearly every selection and content change from dozens of call sites —
+ * repeatedly, synchronously, on the main thread, for documents that have not
+ * changed. That is the canvas "freezing while just clicking" and the sluggish
+ * cursor.
+ *
+ * Keyed on the whole HTML string rather than a hash on purpose: a 32-bit hash
+ * collision would hand a caller a confidently wrong layer tree, and every
+ * id-keyed edit downstream would target the wrong node. The string is already
+ * retained by the file/query cache, so the key costs a reference, not a copy.
+ *
+ * Callers must treat the result as read-only — it is shared now. Every consumer
+ * only reads (`find`/`filter`/`map`); `applyCodeLayer*`-style writers build new
+ * HTML and re-project rather than editing a projection in place.
+ */
+const PROJECTION_CACHE_MAX = 24;
+const projectionCache = new Map<string, CodeLayerProjection>();
+
+/** Every own field of the source, sorted, so adding a field to
+ *  CodeLayerSource later cannot silently start returning a projection whose
+ *  `.source` came from a different call. */
+function projectionSourceKey(source: CodeLayerSource): string {
+  const record = source as unknown as Record<string, unknown>;
+  return Object.keys(source)
+    .sort()
+    .map((field) => `${field}=${record[field] ?? ""}`)
+    .join("\u0000");
+}
+
 export function buildCodeLayerProjection(
   html: string,
   options: { source?: CodeLayerSource } = {},
@@ -2238,8 +2270,28 @@ export function buildCodeLayerProjection(
   // (e.g. `activeContent` is briefly undefined on first render). Projecting a
   // non-string must yield an empty projection, never crash the editor.
   const safeHtml = typeof html === "string" ? html : "";
-  return buildProjection(safeHtml, options.source ?? { kind: "inline-html" })
-    .projection;
+  const source = options.source ?? { kind: "inline-html" };
+  const key = `${projectionSourceKey(source)}\u0000${safeHtml}`;
+  const cached = projectionCache.get(key);
+  if (cached) {
+    // Re-insert so the Map's insertion order stays least-recently-used first.
+    projectionCache.delete(key);
+    projectionCache.set(key, cached);
+    return cached;
+  }
+  const projection = buildProjection(safeHtml, source).projection;
+  projectionCache.set(key, projection);
+  if (projectionCache.size > PROJECTION_CACHE_MAX) {
+    const oldest = projectionCache.keys().next();
+    if (!oldest.done) projectionCache.delete(oldest.value);
+  }
+  return projection;
+}
+
+/** Drops every cached projection. Exists for tests that assert projection
+ *  identity/eviction; production has no reason to call it. */
+export function clearCodeLayerProjectionCache(): void {
+  projectionCache.clear();
 }
 
 export function ensureCodeLayerNodeIdsInHtml(

package/corpus/templates/design/shared/responsive-frame-layout.ts

@@ -0,0 +1,55 @@
+/**
+ * Geometry of one screen's responsive frame group: the primary frame plus the
+ * breakpoint previews painted to its right.
+ *
+ * This lives in `shared/` because both sides of the contract need it. Actions
+ * that *place* screens on the overview board (present-design-variants) must
+ * reserve the same width the canvas will actually *paint*, or the next screen
+ * lands underneath the previous screen's breakpoint row. Keeping the width in
+ * one place is what makes writer and renderer agree.
+ */
+
+/** Gap between the primary frame and each breakpoint preview beside it. */
+export const BREAKPOINT_FRAME_GAP = 24;
+
+/** Drops any breakpoint whose width equals the primary frame's own width — a
+ * redundant duplicate of the base — also cleaning up designs authored before
+ * the default set excluded the primary width. */
+export function visibleBreakpointWidths(
+  breakpointWidths: readonly number[] | undefined,
+  primaryWidthPx: number | undefined,
+): number[] {
+  const deduped = Array.from(
+    new Set(
+      (breakpointWidths ?? []).filter(
+        (width) => Number.isFinite(width) && width > 0,
+      ),
+    ),
+  );
+  if (primaryWidthPx === undefined || !Number.isFinite(primaryWidthPx)) {
+    return deduped;
+  }
+  return deduped.filter((width) => Math.abs(width - primaryWidthPx) > 1);
+}
+
+/**
+ * Total painted width of a screen's frame group: the primary box plus every
+ * breakpoint preview beside it, each drawn at the primary's own uniform
+ * `scale`. `visibleWidths` must already be filtered through
+ * `visibleBreakpointWidths` — callers differ in which width they dedupe
+ * against, but the arithmetic must not.
+ */
+export function getResponsiveGroupWidth({
+  primaryWidth,
+  scale,
+  visibleWidths,
+}: {
+  primaryWidth: number;
+  scale: number;
+  visibleWidths: readonly number[];
+}): number {
+  return visibleWidths.reduce(
+    (total, width) => total + BREAKPOINT_FRAME_GAP + width * scale,
+    Math.max(1, primaryWidth),
+  );
+}

package/corpus/templates/slides/.agents/skills/analytics-data-for-decks/SKILL.md

@@ -0,0 +1,48 @@
+---
+name: analytics-data-for-decks
+description: >-
+  Route customer, account, CRM, HubSpot, pipeline, renewal, usage, product
+  activity, Gong, and other analytics-backed deck requests through the
+  Analytics agent. Use when generating or updating Slides content that needs
+  external or first-party data.
+---
+
+# Analytics data for decks
+
+When a deck needs customer or product data, ask the Analytics agent over A2A
+before creating or changing Slides content. The user's wording can be direct,
+such as "ask the analytics agent to ...", or implicit in a request for customer,
+account, CRM, HubSpot, pipeline, renewal, usage, product-activity, Gong, or
+other analytics data.
+
+## Delegation
+
+- For a known, read-only operation, use `call-agent` with `agent: "analytics"`,
+  the exact `action`, and complete `input`. This invokes Analytics directly
+  without starting a second model loop.
+- For ambiguous, multi-source, or narrative questions, use `call-agent` with a
+  natural-language `message` and let Analytics decide which source or sources
+  to use.
+- Useful Analytics operations include `hubspot-records` for bounded CRM
+  records and `hubspot-deals` for pipeline and deal metrics,
+  `account-deep-dive` for a named account or renewal/risk review, `gong-calls`
+  for quotes/counts/transcripts and coverage, and `gong-native-insights` for
+  bounded narrative synthesis. For first-party product activity, send a
+  natural-language message and let Analytics choose its query.
+- Slides must not write SQL, choose a warehouse or provider, call HubSpot/Gong
+  directly, or interpret a provider schema itself. Analytics owns source
+  selection, data dictionary interpretation, filters, joins, and query
+  execution using its own instructions and connected-source status.
+
+## Evidence and deck behavior
+
+- Preserve the question, source, filters, date window, coverage, counts,
+  pagination, and limitations from Analytics. Never invent customer data or
+  claim a lookup succeeded when it failed.
+- If a source is unavailable, name the missing source and continue only with
+  clearly labeled data that Analytics actually returned. Do not expose
+  credentials or raw provider payloads.
+- Before generation, call `get-workspace-defaults` when no reference deck or
+  design system is named, then follow `creative-context` for approved brand
+  context and provenance. For updates, preserve the existing deck structure
+  and make focused slide edits.

package/corpus/templates/slides/AGENTS.md

@@ -45,6 +45,8 @@ ladder.
   and `input` (or `invokeAgentAction`) instead of starting the sibling agent's
   model loop. In Analytics, use `gong-native-insights` for provider-synthesized
   briefs and `gong-calls` for quotes, counts, transcripts, and coverage claims.
+- For data requests, read `.agents/skills/analytics-data-for-decks/SKILL.md` and
+  delegate via Analytics over A2A; do not write SQL or call providers directly.
 - When the user names no reference deck or design system, call
   `get-workspace-defaults` first so a bare "make a deck about X" is still on
   brand.
@@ -102,3 +104,4 @@ Read the relevant skill before deeper work:
 - `design-systems`, `frontend-design`, `shadcn-ui`, and `actions` as needed.
 - `creative-context` for cross-app source reuse, pinned packs, provenance, and
   context opt-out.
+- `analytics-data-for-decks` for delegated data.

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

@@ -1,4 +1,7 @@
-import { appBasePath } from "@agent-native/core/client/api-path";
+import {
+  agentNativePath,
+  appBasePath,
+} from "@agent-native/core/client/api-path";
 import { useT } from "@agent-native/core/client/i18n";
 import {
   IconDownload,
@@ -8,6 +11,7 @@ import {
   IconCopy,
   IconShare2,
   IconBrandGoogle,
+  IconPlugConnected,
 } from "@tabler/icons-react";
 import { toast } from "sonner";
 
@@ -122,6 +126,57 @@ export function ExportMenu({
     }
   };
 
+  const handleConnectGoogle = async () => {
+    const authUrl = new URL(
+      agentNativePath("/_agent-native/google-docs/auth-url"),
+      window.location.origin,
+    );
+    authUrl.searchParams.set(
+      "return",
+      window.location.pathname + window.location.search,
+    );
+
+    const popup = window.open(
+      "",
+      "google-docs-oauth",
+      "popup,width=520,height=720",
+    );
+    if (!popup) {
+      toast.error(t("editorExport.exportFailed"), {
+        description: t("editorExport.exportGoogleSlidesError"),
+      });
+      return;
+    }
+
+    try {
+      const response = await fetch(authUrl.toString(), {
+        credentials: "same-origin",
+      });
+      if (!response.ok) {
+        throw new Error(
+          await readErrorMessage(
+            response,
+            t("editorExport.exportGoogleSlidesError"),
+          ),
+        );
+      }
+      const data = (await response.json()) as { url?: unknown };
+      if (typeof data.url !== "string") {
+        throw new Error(t("editorExport.exportGoogleSlidesError"));
+      }
+      popup.location.href = data.url;
+    } catch (err) {
+      popup?.close();
+      console.error("Google connection failed:", err);
+      toast.error(t("editorExport.exportFailed"), {
+        description:
+          err instanceof Error
+            ? err.message
+            : t("editorExport.exportGoogleSlidesError"),
+      });
+    }
+  };
+
   const handleExportHtml = async () => {
     try {
       const res = await fetch(`${appBasePath()}/api/exports/html`, {
@@ -189,13 +244,22 @@ export function ExportMenu({
           {t("editorExport.exportPptx")}
         </DropdownMenuItem>
         {onExportGoogleSlides && (
-          <DropdownMenuItem
-            onClick={handleExportGoogleSlides}
-            className="cursor-pointer"
-          >
-            <IconBrandGoogle className="w-4 h-4 mr-2" />
-            {t("editorExport.openInGoogleSlides")}
-          </DropdownMenuItem>
+          <>
+            <DropdownMenuItem
+              onClick={handleConnectGoogle}
+              className="cursor-pointer"
+            >
+              <IconPlugConnected className="w-4 h-4 mr-2" />
+              {t("editorExport.connectGoogle")}
+            </DropdownMenuItem>
+            <DropdownMenuItem
+              onClick={handleExportGoogleSlides}
+              className="cursor-pointer"
+            >
+              <IconBrandGoogle className="w-4 h-4 mr-2" />
+              {t("editorExport.openInGoogleSlides")}
+            </DropdownMenuItem>
+          </>
         )}
         <DropdownMenuSeparator />
         <DropdownMenuItem onClick={onDuplicate} className="cursor-pointer">

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

@@ -262,6 +262,7 @@ const messages = {
     downloadHtml: "Download as HTML",
     exportPdf: "Export as PDF",
     exportPptx: "Export as PPTX",
+    connectGoogle: "Connect Google",
     openInGoogleSlides: "Open in Google Slides",
     googleSlidesCreated: "Opened in Google Slides",
     googleSlidesCreatedHint:

package/corpus/templates/slides/changelog/2026-07-29-google-slides-exports-can-connect-your-google-account-direct.md

@@ -0,0 +1,6 @@
+---
+type: added
+date: 2026-07-29
+---
+
+Google Slides exports can connect your Google account directly from the export menu

package/corpus/templates/slides/server/handlers/google-docs-auth.ts

@@ -12,7 +12,6 @@ import {
 import {
   defineEventHandler,
   getQuery,
-  sendRedirect,
   setResponseStatus,
   type H3Event,
 } from "h3";
@@ -98,7 +97,10 @@ export const getGoogleDocsAuthUrlHandler = defineEventHandler(
       });
       const url = await getGoogleDocsAuthUrl(redirectUri, state, owner);
       if (q.redirect === "1") {
-        return sendRedirect(event, url, 302);
+        return new Response(null, {
+          status: 302,
+          headers: { Location: url },
+        });
       }
       return { url };
     } catch (error) {