@agent-native/core 0.149.3 → 0.149.5

package/corpus/templates/slides/server/lib/slide-content-patch.ts

@@ -0,0 +1,355 @@
+export type SlideContentEdit =
+  | {
+      op?: "replace";
+      find: string;
+      replace: string;
+      all?: boolean;
+      occurrence?: number;
+      expectedMatches?: number;
+      required?: boolean;
+    }
+  | {
+      op: "insert-before" | "insert-after";
+      marker: string;
+      content: string;
+      occurrence?: number;
+      expectedMatches?: number;
+      required?: boolean;
+    }
+  | {
+      op: "replace-between";
+      start: string;
+      end: string;
+      content: string;
+      includeDelimiters?: boolean;
+      expectedMatches?: number;
+      required?: boolean;
+    }
+  | {
+      op: "regex-replace";
+      pattern: string;
+      replace: string;
+      flags?: string;
+      all?: boolean;
+      expectedMatches?: number;
+      required?: boolean;
+    };
+
+export class SlideContentEditError extends Error {
+  readonly code = "slide_content_edit_failed";
+
+  constructor(message: string) {
+    super(message);
+    this.name = "SlideContentEditError";
+  }
+}
+
+export interface SlideContentPatchResult {
+  content: string;
+  applied: string[];
+  formatted: boolean;
+  changed: boolean;
+}
+
+/**
+ * Applies every edit to an in-memory string before the caller persists it.
+ * A failed edit throws, so callers never write a partially applied patch list.
+ */
+export async function applySlideContentEdits(
+  currentContent: string,
+  edits: readonly SlideContentEdit[],
+  format = false,
+): Promise<SlideContentPatchResult> {
+  try {
+    let content = currentContent;
+    const applied: string[] = [];
+
+    for (const edit of edits) {
+      const result = applyEdit(content, edit);
+      content = result.content;
+      applied.push(result.summary);
+    }
+
+    const changed = content !== currentContent;
+
+    if (format) {
+      content = await formatSlideHtml(content);
+    }
+
+    return { content, applied, formatted: format, changed };
+  } catch (error) {
+    if (error instanceof SlideContentEditError) throw error;
+    const message = error instanceof Error ? error.message : String(error);
+    throw new SlideContentEditError(message);
+  }
+}
+
+export async function formatSlideHtml(content: string): Promise<string> {
+  try {
+    const prettier = await import("prettier");
+    return await prettier.format(content, {
+      parser: "html",
+      htmlWhitespaceSensitivity: "ignore",
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (
+      message.includes("Cannot find package 'prettier'") ||
+      message.includes('Cannot find package "prettier"') ||
+      message.includes("Cannot find module 'prettier'") ||
+      message.includes('Cannot find module "prettier"')
+    ) {
+      throw new SlideContentEditError(
+        "HTML formatting is unavailable because Prettier is not installed",
+      );
+    }
+    throw new SlideContentEditError(`Unable to format slide HTML: ${message}`);
+  }
+}
+
+function applyEdit(
+  content: string,
+  edit: SlideContentEdit,
+): { content: string; summary: string } {
+  switch (edit.op ?? "replace") {
+    case "replace":
+      return applyLiteralReplace(
+        content,
+        edit as Extract<SlideContentEdit, { op?: "replace" }>,
+      );
+    case "insert-before":
+    case "insert-after":
+      return applyInsert(
+        content,
+        edit as Extract<
+          SlideContentEdit,
+          { op: "insert-before" | "insert-after" }
+        >,
+      );
+    case "replace-between":
+      return applyReplaceBetween(
+        content,
+        edit as Extract<SlideContentEdit, { op: "replace-between" }>,
+      );
+    case "regex-replace":
+      return applyRegexReplace(
+        content,
+        edit as Extract<SlideContentEdit, { op: "regex-replace" }>,
+      );
+    default:
+      throw new SlideContentEditError(
+        `Unsupported slide content edit operation: ${String(edit.op)}`,
+      );
+  }
+}
+
+function applyLiteralReplace(
+  content: string,
+  edit: Extract<SlideContentEdit, { op?: "replace" }>,
+): { content: string; summary: string } {
+  const matches = countOccurrences(content, edit.find);
+  assertMatchCount("replace", matches, edit.expectedMatches, edit.required);
+  if (matches === 0) return { content, summary: "replace:0" };
+
+  if (edit.occurrence !== undefined) {
+    return {
+      content: replaceNth(content, edit.find, edit.replace, edit.occurrence),
+      summary: `replace:nth:${edit.occurrence}`,
+    };
+  }
+
+  if (edit.all) {
+    return {
+      content: content.split(edit.find).join(edit.replace),
+      summary: `replace:all:${matches}`,
+    };
+  }
+
+  return {
+    content: content.replace(edit.find, edit.replace),
+    summary: "replace:first",
+  };
+}
+
+function applyInsert(
+  content: string,
+  edit: Extract<SlideContentEdit, { op: "insert-before" | "insert-after" }>,
+): { content: string; summary: string } {
+  const matches = countOccurrences(content, edit.marker);
+  assertMatchCount(edit.op, matches, edit.expectedMatches, edit.required);
+  if (matches === 0) return { content, summary: `${edit.op}:0` };
+
+  const occurrence = edit.occurrence ?? 1;
+  const index = nthIndexOf(content, edit.marker, occurrence);
+  if (index < 0) {
+    throw new SlideContentEditError(
+      `${edit.op} could not find occurrence ${occurrence}`,
+    );
+  }
+  const insertAt =
+    edit.op === "insert-before" ? index : index + edit.marker.length;
+  return {
+    content:
+      content.slice(0, insertAt) + edit.content + content.slice(insertAt),
+    summary: `${edit.op}:${occurrence}`,
+  };
+}
+
+function applyReplaceBetween(
+  content: string,
+  edit: Extract<SlideContentEdit, { op: "replace-between" }>,
+): { content: string; summary: string } {
+  const ranges = findBetweenRanges(content, edit.start, edit.end);
+  assertMatchCount(
+    "replace-between",
+    ranges.length,
+    edit.expectedMatches,
+    edit.required,
+  );
+  if (!ranges.length) return { content, summary: "replace-between:0" };
+  if (ranges.length > 1 && edit.expectedMatches === undefined) {
+    throw new SlideContentEditError(
+      `replace-between matched ${ranges.length} ranges; pass expectedMatches to confirm`,
+    );
+  }
+
+  let next = content;
+  for (const range of ranges.slice().reverse()) {
+    const start = edit.includeDelimiters ? range.start : range.innerStart;
+    const end = edit.includeDelimiters ? range.end : range.innerEnd;
+    next = next.slice(0, start) + edit.content + next.slice(end);
+  }
+  return { content: next, summary: `replace-between:${ranges.length}` };
+}
+
+function applyRegexReplace(
+  content: string,
+  edit: Extract<SlideContentEdit, { op: "regex-replace" }>,
+): { content: string; summary: string } {
+  const flags = normalizeRegexFlags(edit.flags, edit.all);
+  const regex = new RegExp(edit.pattern, flags);
+  const countRegex = new RegExp(edit.pattern, ensureGlobal(flags));
+  const matches = Array.from(content.matchAll(countRegex)).length;
+  assertMatchCount(
+    "regex-replace",
+    matches,
+    edit.expectedMatches,
+    edit.required,
+  );
+  if (matches === 0) return { content, summary: "regex-replace:0" };
+  return {
+    content: content.replace(regex, edit.replace),
+    summary: `regex-replace:${edit.all ? "all" : "first"}:${matches}`,
+  };
+}
+
+function assertMatchCount(
+  op: string,
+  actual: number,
+  expected: number | undefined,
+  required: boolean | undefined,
+): void {
+  if (expected !== undefined && actual !== expected) {
+    throw new SlideContentEditError(
+      `${op} expected ${expected} match(es), found ${actual}`,
+    );
+  }
+  if (expected === undefined && required !== false && actual === 0) {
+    throw new SlideContentEditError(`${op} found no matches`);
+  }
+}
+
+function countOccurrences(content: string, needle: string): number {
+  if (!needle) {
+    throw new SlideContentEditError("Patch find/marker text cannot be empty");
+  }
+  let count = 0;
+  let index = 0;
+  while (true) {
+    index = content.indexOf(needle, index);
+    if (index < 0) return count;
+    count += 1;
+    index += needle.length;
+  }
+}
+
+function nthIndexOf(
+  content: string,
+  needle: string,
+  occurrence: number,
+): number {
+  if (!Number.isInteger(occurrence) || occurrence < 1) {
+    throw new SlideContentEditError("occurrence must be a positive integer");
+  }
+  let index = -1;
+  let from = 0;
+  for (let i = 0; i < occurrence; i += 1) {
+    index = content.indexOf(needle, from);
+    if (index < 0) return -1;
+    from = index + needle.length;
+  }
+  return index;
+}
+
+function replaceNth(
+  content: string,
+  find: string,
+  replace: string,
+  occurrence: number,
+): string {
+  const index = nthIndexOf(content, find, occurrence);
+  if (index < 0) {
+    throw new SlideContentEditError(
+      `replace could not find occurrence ${occurrence}`,
+    );
+  }
+  return content.slice(0, index) + replace + content.slice(index + find.length);
+}
+
+function findBetweenRanges(
+  content: string,
+  startMarker: string,
+  endMarker: string,
+): Array<{ start: number; innerStart: number; innerEnd: number; end: number }> {
+  if (!startMarker || !endMarker) {
+    throw new SlideContentEditError(
+      "replace-between requires non-empty start and end markers",
+    );
+  }
+  const ranges: Array<{
+    start: number;
+    innerStart: number;
+    innerEnd: number;
+    end: number;
+  }> = [];
+  let cursor = 0;
+  while (cursor < content.length) {
+    const start = content.indexOf(startMarker, cursor);
+    if (start < 0) break;
+    const innerStart = start + startMarker.length;
+    const innerEnd = content.indexOf(endMarker, innerStart);
+    if (innerEnd < 0) {
+      throw new SlideContentEditError(
+        "replace-between found a start marker without an end",
+      );
+    }
+    const end = innerEnd + endMarker.length;
+    ranges.push({ start, innerStart, innerEnd, end });
+    cursor = end;
+  }
+  return ranges;
+}
+
+function normalizeRegexFlags(flags: string | undefined, all?: boolean): string {
+  const unique = new Set((flags ?? "").split("").filter(Boolean));
+  if (all) {
+    unique.add("g");
+  } else {
+    unique.delete("g");
+  }
+  return Array.from(unique).join("");
+}
+
+function ensureGlobal(flags: string): string {
+  return flags.includes("g") ? flags : `${flags}g`;
+}

package/corpus/templates/slides/server/lib/uploaded-reference-storage.ts

@@ -84,25 +84,44 @@ export async function readUploadedReferenceBlob(
       decryptSecretValue(reference.slice(UPLOADED_REFERENCE_PREFIX.length)),
     ) as UploadedReferenceDescriptor;
   } catch {
+    console.warn("[slides-upload] invalid uploaded reference descriptor", {
+      reason: "decrypt-or-parse",
+    });
     throw new Error("Invalid uploaded file reference");
   }
 
+  const requestOrgId = getRequestOrgId() ?? null;
+  const ownerMatches = descriptor?.ownerKey === tenantFileKey(email);
+  const orgMatches = descriptor?.orgId === requestOrgId;
+  const filename = descriptor?.filename;
+  const safeFilename =
+    typeof filename === "string" && filename === path.basename(filename)
+      ? filename
+      : null;
+  const handleIsOpaque = descriptor?.handle?.opaque === true;
   if (
     descriptor?.kind !== "slides-upload" ||
-    descriptor.version !== 1 ||
-    descriptor.ownerKey !== tenantFileKey(email) ||
-    descriptor.orgId !== (getRequestOrgId() ?? null) ||
-    typeof descriptor.filename !== "string" ||
-    descriptor.filename !== path.basename(descriptor.filename) ||
-    typeof descriptor.handle?.id !== "string" ||
-    typeof descriptor.handle?.provider !== "string" ||
-    descriptor.handle.opaque !== true
+    descriptor?.version !== 1 ||
+    !ownerMatches ||
+    !orgMatches ||
+    safeFilename === null ||
+    typeof descriptor?.handle?.id !== "string" ||
+    typeof descriptor?.handle?.provider !== "string" ||
+    !handleIsOpaque
   ) {
+    console.warn("[slides-upload] uploaded reference rejected", {
+      handleIsOpaque,
+      hasDescriptorOrg: descriptor?.orgId != null,
+      hasRequestOrg: requestOrgId != null,
+      orgMatches,
+      ownerMatches,
+      reason: "scope-or-handle-validation",
+    });
     throw new Error(
       "Access denied: uploaded file reference is not valid for this user or organization",
     );
   }
 
   const blob = await readPrivateBlob(descriptor.handle);
-  return { data: Buffer.from(blob.data), filename: descriptor.filename };
+  return { data: Buffer.from(blob.data), filename: safeFilename };
 }

package/corpus/templates/slides/server/plugins/agent-chat.ts

@@ -1,10 +1,10 @@
-import { getOrgContext } from "@agent-native/core/org";
 import {
   createAgentChatPlugin,
   loadActionsFromStaticRegistry,
 } from "@agent-native/core/server";
 
 import actionsRegistry from "../../.generated/actions-registry.js";
+import { resolveSlidesRequestAuthContext } from "../handlers/request-auth-context.js";
 import { prepareSlidesChatAttachments } from "../lib/chat-attachments.js";
 import "../register-secrets.js";
 
@@ -48,12 +48,21 @@ export default createAgentChatPlugin({
   // paginate, and reduce provider data through providerFetch() without us
   // hardcoding one action per Google Drive endpoint.
   codeExecution: { production: "sandboxed" },
-  resolveOrgId: async (event) => (await getOrgContext(event)).orgId,
+  // Upload routes and action routes must use the same session/org resolver.
+  // Reading getOrgContext directly here skipped the upload route's session
+  // fallback and could reject a freshly uploaded reference after a transient
+  // org lookup or active-org transition.
+  resolveOrgId: async (event) => {
+    const authContext = await resolveSlidesRequestAuthContext(event);
+    return authContext.orgId === undefined ? null : authContext.orgId;
+  },
   prepareRequest: prepareSlidesChatAttachments,
   systemPrompt: `You are an AI deck assistant. You create, edit, import, export, style, share, and navigate decks through actions and shared application state. For a newly created presentation, use create-deck with slides: [] only when you are creating the deck yourself, then add-slide sequentially with full rendered HTML. The legacy generate-slides-ai action returns Markdown drafts and is not part of the persisted presentation workflow.
 
 When the user asks to improve, beautify, restyle, or make an uploaded/existing deck on-brand, treat it as an in-place source-preserving edit unless the user explicitly asks to rewrite the story or change slide count. First call view-screen when the active deck is unclear, then get-deck with compact=true for deck orientation. If you need slide markup, call get-deck with compact=false explicitly and only when the edit requires the full HTML. If get-deck.sourceImport exists, preserve its slide count, order, IDs, factual copy, notes, images, charts, tables, diagrams, freeform objects, and source aspect ratio. For a deck-wide restyle, use one patch-deck call with requireAllSourceSlides=true and one patch-slide operation with fields.content for every source slide ID; the action rejects partial coverage. Do not split a full-deck restyle into arbitrary batches or use one-by-one update-slide calls - reserve update-slide for targeted one-slide edits. After the patch succeeds, verify with get-deck using compact=true so the verification does not retransmit every slide's HTML. Do not claim a partial or initial pass. Do not use add-slide, delete, reorder, or replace source imagery with generic cards for this workflow. If sourceImport.fidelity is partial or imagesSkipped is nonzero, stop and report the exact fidelity warning instead of claiming a reliable improvement.
-For a targeted one-slide edit, prefer get-deck with the stable slideId from view-screen or compact get-deck. It returns only that slide's full HTML by default, so do not load the full deck when one slide is enough. Pass compact=true when you only need a lightweight check of that slide.
+For a targeted one-slide edit, prefer get-deck with the stable slideId from view-screen or compact get-deck. It returns only that slide's full HTML by default, so do not load the full deck when one slide is enough. For code-style edits, request compact=false and format=true, then call update-slide with that slide's contentHash as baseContentHash and an ordered edits list. Use exact replace, insert-before/after, replace-between, or regex-replace edits; include expectedMatches for ambiguous markers. The action applies the whole list atomically under the deck lock, so a failed required match writes nothing. Set format=true on update-slide when readable line breaks should be persisted. Use fullContent only for an intentional full rewrite. Pass compact=true when you only need a lightweight check of that slide.
+
+For click-to-reveal animations, keep the slide HTML as the visual source and store reveals only in the slide's animations metadata. Read the target slide's full HTML, preserve its existing structure, and patch the complete ordered animations list with elementPath values from that final HTML. Leave labels and headings visible by omitting them from the list. Never simulate reveals by adding duplicate elements, visibility:hidden, fmd-layout-spacer, fmd-freeform-object, absolute positioning, transforms, or placeholder markup. If content and reveals both change, send them together in one patch-deck patch-slide operation. If a user asks to remove or revert reveals, send the existing content with animations: [], then re-read the slide; do not use a simplified replacement or rely on update-slide text alone.
 
 When the active Slides editor is already showing the deck you just changed, do not include an "Open the updated deck" or similar link in the final response. The deck is already open and the action updated it in place; say that plainly instead. Only provide an open-deck link when the user is elsewhere, the active deck is different, or the user explicitly asks for a link.
 

package/dist/cli/create.js

@@ -17,6 +17,49 @@ const STANDALONE_EXACT_DEPENDENCY_OVERRIDES = {
     "@react-router/fs-routes": "8.1.0",
     "react-router": "8.1.0",
 };
+const TIPTAP_WORKSPACE_OVERRIDES = {
+    '"@tiptap/core"': '"3.28.0"',
+    '"@tiptap/extension-blockquote"': '"3.28.0"',
+    '"@tiptap/extension-bold"': '"3.28.0"',
+    '"@tiptap/extension-bubble-menu"': '"3.28.0"',
+    '"@tiptap/extension-bullet-list"': '"3.28.0"',
+    '"@tiptap/extension-code"': '"3.28.0"',
+    '"@tiptap/extension-code-block"': '"3.28.0"',
+    '"@tiptap/extension-code-block-lowlight"': '"3.28.0"',
+    '"@tiptap/extension-collaboration"': '"3.28.0"',
+    '"@tiptap/extension-collaboration-caret"': '"3.28.0"',
+    '"@tiptap/extension-color"': '"3.28.0"',
+    '"@tiptap/extension-document"': '"3.28.0"',
+    '"@tiptap/extension-dropcursor"': '"3.28.0"',
+    '"@tiptap/extension-floating-menu"': '"3.28.0"',
+    '"@tiptap/extension-gapcursor"': '"3.28.0"',
+    '"@tiptap/extension-hard-break"': '"3.28.0"',
+    '"@tiptap/extension-heading"': '"3.28.0"',
+    '"@tiptap/extension-horizontal-rule"': '"3.28.0"',
+    '"@tiptap/extension-image"': '"3.28.0"',
+    '"@tiptap/extension-italic"': '"3.28.0"',
+    '"@tiptap/extension-link"': '"3.28.0"',
+    '"@tiptap/extension-list"': '"3.28.0"',
+    '"@tiptap/extension-list-item"': '"3.28.0"',
+    '"@tiptap/extension-list-keymap"': '"3.28.0"',
+    '"@tiptap/extension-ordered-list"': '"3.28.0"',
+    '"@tiptap/extension-paragraph"': '"3.28.0"',
+    '"@tiptap/extension-placeholder"': '"3.28.0"',
+    '"@tiptap/extension-strike"': '"3.28.0"',
+    '"@tiptap/extension-table"': '"3.28.0"',
+    '"@tiptap/extension-table-cell"': '"3.28.0"',
+    '"@tiptap/extension-table-header"': '"3.28.0"',
+    '"@tiptap/extension-table-row"': '"3.28.0"',
+    '"@tiptap/extension-task-item"': '"3.28.0"',
+    '"@tiptap/extension-task-list"': '"3.28.0"',
+    '"@tiptap/extension-text"': '"3.28.0"',
+    '"@tiptap/extension-text-style"': '"3.28.0"',
+    '"@tiptap/extension-underline"': '"3.28.0"',
+    '"@tiptap/extensions"': '"3.28.0"',
+    '"@tiptap/pm"': '"3.28.0"',
+    '"@tiptap/react"': '"3.28.0"',
+    '"@tiptap/starter-kit"': '"3.28.0"',
+};
 const REACT_ROUTER_BUILD_DEPENDENCIES = [
     "@react-router/dev",
     "@react-router/fs-routes",
@@ -1457,6 +1500,12 @@ function postProcessStandalone(name, targetDir, templateName, resolution) {
                 nf3: '"0.3.17"',
             };
         }
+        if (templateName && getTemplate(templateName)) {
+            sections.overrides = {
+                ...sections.overrides,
+                ...TIPTAP_WORKSPACE_OVERRIDES,
+            };
+        }
         const localToolkit = localToolkitOverride();
         if (localToolkit) {
             sections.overrides ??= {};

package/dist/client/chat-first/index.d.ts

@@ -6,7 +6,7 @@ export { defaultChatFirstCopy } from "./copy.js";
 export { ChatFirstChatHistory, type ChatFirstChatHistoryProps, } from "./chat-history.js";
 export { ChatFirstSessionWatchPane } from "./session-watch-pane.js";
 export { ChatFirstSurfacePanel, type ChatFirstSurfacePanelProps, } from "./surface-panel.js";
-export { ChatFirstPrimaryNavigation } from "./primary-nav.js";
+export { ChatFirstPrimaryNavigation, type ChatFirstPrimaryTab, } from "./primary-nav.js";
 export { emitChatFirstOpenApp, resolveChatFirstAppTarget, CHAT_FIRST_DEFAULT_APP_IDS, type ChatFirstOpenAppDetail, } from "../chat-first.js";
 export { buildChatFirstAppCreationPrompt, titleFromChatFirstAppPrompt, type ChatFirstAppCreationPromptInput, type ChatFirstAppCreationResource, type ChatFirstAppCreationVaultAccessMode, } from "../../shared/chat-first-app-creation.js";
 export { ChatFirstSurfaceContent, ChatFirstSurfaceTabs, } from "./surface-tabs.js";

package/dist/client/chat-first/index.js

@@ -6,7 +6,7 @@ export { defaultChatFirstCopy } from "./copy.js";
 export { ChatFirstChatHistory, } from "./chat-history.js";
 export { ChatFirstSessionWatchPane } from "./session-watch-pane.js";
 export { ChatFirstSurfacePanel, } from "./surface-panel.js";
-export { ChatFirstPrimaryNavigation } from "./primary-nav.js";
+export { ChatFirstPrimaryNavigation, } from "./primary-nav.js";
 export { emitChatFirstOpenApp, resolveChatFirstAppTarget, CHAT_FIRST_DEFAULT_APP_IDS, } from "../chat-first.js";
 export { buildChatFirstAppCreationPrompt, titleFromChatFirstAppPrompt, } from "../../shared/chat-first-app-creation.js";
 export { ChatFirstSurfaceContent, ChatFirstSurfaceTabs, } from "./surface-tabs.js";

package/dist/client/chat-first/primary-nav.d.ts

@@ -1,8 +1,10 @@
 import type { ChatFirstCopy } from "./types.js";
-export declare function ChatFirstPrimaryNavigation({ onNewChat, onOpenIntegrations, onOpenScheduled, onSearch, copy, }: {
+export type ChatFirstPrimaryTab = "new-chat" | "integrations" | "scheduled";
+export declare function ChatFirstPrimaryNavigation({ onNewChat, onOpenIntegrations, onOpenScheduled, onSearch, activeTab, copy, }: {
     onNewChat?: () => void;
     onOpenIntegrations: () => void;
     onOpenScheduled: () => void;
     onSearch?: () => void;
+    activeTab?: ChatFirstPrimaryTab;
     copy?: ChatFirstCopy;
 }): import("react").JSX.Element;

package/dist/client/chat-first/primary-nav.js

@@ -1,6 +1,12 @@
 import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { IconClock, IconPlus, IconPlugConnected, IconSearch, } from "@tabler/icons-react";
 import { defaultChatFirstCopy } from "./copy.js";
-export function ChatFirstPrimaryNavigation({ onNewChat, onOpenIntegrations, onOpenScheduled, onSearch, copy = defaultChatFirstCopy, }) {
-    return (_jsxs(_Fragment, { children: [onNewChat ? (_jsxs("button", { type: "button", className: "flex h-8 w-full items-center gap-2 rounded-md px-2 text-[13px] font-medium text-sidebar-foreground/80 hover:bg-sidebar-accent hover:text-sidebar-accent-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring", onClick: onNewChat, children: [_jsx(IconPlus, { size: 15, className: "shrink-0", "aria-hidden": "true" }), _jsx("span", { children: copy("newChat") })] })) : null, _jsxs("button", { type: "button", className: "flex h-8 w-full items-center gap-2 rounded-md px-2 text-[13px] font-medium text-sidebar-foreground/80 hover:bg-sidebar-accent hover:text-sidebar-accent-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring", onClick: onOpenIntegrations, children: [_jsx(IconPlugConnected, { size: 15, className: "shrink-0", "aria-hidden": "true" }), _jsx("span", { children: copy("integrations") })] }), _jsxs("button", { type: "button", className: "flex h-8 w-full items-center gap-2 rounded-md px-2 text-[13px] font-medium text-sidebar-foreground/80 hover:bg-sidebar-accent hover:text-sidebar-accent-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring", onClick: onOpenScheduled, children: [_jsx(IconClock, { size: 15, className: "shrink-0", "aria-hidden": "true" }), _jsx("span", { children: copy("scheduled") })] }), onSearch ? (_jsxs("button", { type: "button", className: "flex h-8 w-full items-center gap-2 rounded-md px-2 text-[13px] font-medium text-sidebar-foreground/80 hover:bg-sidebar-accent hover:text-sidebar-accent-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring", onClick: onSearch, children: [_jsx(IconSearch, { size: 15, className: "shrink-0", "aria-hidden": "true" }), _jsx("span", { children: copy("search") })] })) : null] }));
+export function ChatFirstPrimaryNavigation({ onNewChat, onOpenIntegrations, onOpenScheduled, onSearch, activeTab, copy = defaultChatFirstCopy, }) {
+    const tabClassName = (tab) => `flex h-8 w-full items-center gap-2 rounded-md px-2 text-[13px] font-medium transition-[background-color,color] focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring ${activeTab === tab
+        ? "bg-sidebar-accent text-sidebar-accent-foreground"
+        : "text-sidebar-foreground/80 hover:bg-sidebar-accent hover:text-sidebar-accent-foreground"}`;
+    const renderTab = (tab, content, onSelect) => (_jsx("button", { type: "button", role: "tab", "aria-selected": activeTab === tab, className: tabClassName(tab), onClick: onSelect, children: content }));
+    return (_jsxs("div", { children: [_jsxs("div", { role: "tablist", "aria-label": "Primary navigation", className: "grid gap-px", children: [onNewChat
+                        ? renderTab("new-chat", _jsxs(_Fragment, { children: [_jsx(IconPlus, { size: 15, className: "shrink-0", "aria-hidden": "true" }), _jsx("span", { children: copy("newChat") })] }), onNewChat)
+                        : null, renderTab("integrations", _jsxs(_Fragment, { children: [_jsx(IconPlugConnected, { size: 15, className: "shrink-0", "aria-hidden": "true" }), _jsx("span", { children: copy("integrations") })] }), onOpenIntegrations), renderTab("scheduled", _jsxs(_Fragment, { children: [_jsx(IconClock, { size: 15, className: "shrink-0", "aria-hidden": "true" }), _jsx("span", { children: copy("scheduled") })] }), onOpenScheduled)] }), onSearch ? (_jsxs("button", { type: "button", className: "mt-px flex h-8 w-full items-center gap-2 rounded-md px-2 text-[13px] font-medium text-sidebar-foreground/80 transition-[background-color,color] hover:bg-sidebar-accent hover:text-sidebar-accent-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring", onClick: onSearch, children: [_jsx(IconSearch, { size: 15, className: "shrink-0", "aria-hidden": "true" }), _jsx("span", { children: copy("search") })] })) : null] }));
 }

package/dist/collab/struct-routes.d.ts

@@ -13,8 +13,8 @@
  * Body: { json: any, fieldName?: string, type?: "map"|"array", requestSource?: string }
  */
 export declare const postCollabJson: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    error: string;
     ok?: undefined;
+    error: string;
 } | {
     error?: undefined;
     ok: boolean;

package/dist/deploy/build.d.ts

@@ -147,6 +147,10 @@ export declare function emitSingleTemplateNetlifyKeepWarmFunction(projectCwd: st
  * Emit the durable recurring-job trigger. Netlify's scheduled function only
  * hands off work; the existing `-background` function owns the long sweep so
  * a model run is not constrained by the synchronous scheduled-function wall.
+ *
+ * The entry imports `node:crypto`, so `includedFiles: ["**"]` must stay: the
+ * deploy packager only accepts an omitted `includedFiles` for scheduled
+ * functions whose entry file has no import/require edge at all.
  */
 export declare function emitSingleTemplateNetlifyRecurringJobsFunction(projectCwd: string): void;
 /**

package/dist/deploy/build.js

@@ -2438,6 +2438,10 @@ export const config = {
  * Emit the durable recurring-job trigger. Netlify's scheduled function only
  * hands off work; the existing `-background` function owns the long sweep so
  * a model run is not constrained by the synchronous scheduled-function wall.
+ *
+ * The entry imports `node:crypto`, so `includedFiles: ["**"]` must stay: the
+ * deploy packager only accepts an omitted `includedFiles` for scheduled
+ * functions whose entry file has no import/require edge at all.
  */
 export function emitSingleTemplateNetlifyRecurringJobsFunction(projectCwd) {
     if (!isRecurringJobsDeployEnabled())
@@ -2505,6 +2509,7 @@ export const config = {
   generator: "agent-native build",
   schedule: "* * * * *",
   nodeBundler: "none",
+  includedFiles: ["**"],
 };
 `;
     fs.writeFileSync(path.join(dest, `${functionName}.mjs`), entry);

package/dist/deploy/workspace-deploy.js

@@ -482,6 +482,10 @@ function copyNetlifyFunctionIntoWorkspace(workspaceRoot, app, workspaceApps, sta
  * Emit the per-app Netlify Scheduled Function that hands one recurring-job
  * sweep to that app's durable background worker. The worker owns the actual
  * scan so scheduled-function timeouts cannot strand the automation runner.
+ *
+ * The entry imports `node:crypto`, so `includedFiles: ["**"]` must stay: the
+ * deploy packager only accepts an omitted `includedFiles` for scheduled
+ * functions whose entry file has no import/require edge at all.
  */
 function emitNetlifyRecurringJobsFunction(workspaceRoot, app) {
     const functionName = `${app}-agent-recurring-jobs`;
@@ -545,6 +549,7 @@ export const config = {
   generator: "agent-native workspace deploy",
   schedule: "* * * * *",
   nodeBundler: "none",
+  includedFiles: ["**"],
 };
 `;
     fs.writeFileSync(path.join(dest, `${functionName}.mjs`), entry);