@agent-native/core 0.161.6 → 0.161.8

package/corpus/templates/slides/app/components/presentation/PresenterView.tsx

@@ -31,9 +31,32 @@ export default function PresenterView({
   designSystem,
 }: PresenterViewProps) {
   const t = useT();
-  const [index, setIndex] = useState(startIndex);
+  // `startIndex` is a raw index into the full (unfiltered) deck.slides array.
+  // Skipped slides are absent from safeSlides below, so translate it to the
+  // nearest visible slide's position within safeSlides — matching
+  // PresentationView, whose filtered currentIndex this view's `index` state
+  // otherwise mirrors via the BroadcastChannel.
+  const initialIndex = useMemo(() => {
+    const rawSlides = (Array.isArray(slides) ? slides : []).filter(Boolean);
+    if (rawSlides.length === 0) return 0;
+    const clampedRaw = Math.max(0, Math.min(startIndex, rawSlides.length - 1));
+    for (let i = clampedRaw; i < rawSlides.length; i++) {
+      if (!rawSlides[i]?.skipped) {
+        return rawSlides.slice(0, i).filter((s) => !s?.skipped).length;
+      }
+    }
+    for (let i = clampedRaw - 1; i >= 0; i--) {
+      if (!rawSlides[i]?.skipped) {
+        return rawSlides.slice(0, i).filter((s) => !s?.skipped).length;
+      }
+    }
+    return 0;
+  }, [slides, startIndex]);
+  const [index, setIndex] = useState(initialIndex);
   const [elapsed, setElapsed] = useState(0);
   const channelRef = useRef<BroadcastChannel | null>(null);
+  const indexRef = useRef(index);
+  indexRef.current = index;
 
   useEffect(() => {
     const channel = openPresentChannel(deckId);
@@ -88,13 +111,72 @@ export default function PresenterView({
   }, [goNext, goPrev]);
 
   const safeSlides = useMemo(
-    () => (Array.isArray(slides) ? slides.filter(Boolean) : []),
+    () =>
+      Array.isArray(slides)
+        ? slides.filter(
+            (slide): slide is Slide => Boolean(slide) && !slide.skipped,
+          )
+        : [],
     [slides],
   );
+
+  // One atomic effect handles both cases so they can't race each other:
+  // - A genuine deep link or deck switch (startIndex/deckId changed) reseeds
+  //   from initialIndex. This route is reused across decks (see the
+  //   BroadcastChannel effect above, keyed on deckId).
+  // - Otherwise, a skip toggle or reorder changed safeSlides without a new
+  //   deep link. A length-only clamp would silently swap in a different
+  //   slide at the same index, so follow the previously-shown slide's id to
+  //   its new position, falling back to a raw clamp only when it's gone.
+  const prevDeepLinkKeyRef = useRef({ startIndex, deckId });
+  const prevSafeSlideIdsRef = useRef<string[]>(safeSlides.map((s) => s.id));
+  useEffect(() => {
+    const prevKey = prevDeepLinkKeyRef.current;
+    const isDeepLinkChange =
+      prevKey.startIndex !== startIndex || prevKey.deckId !== deckId;
+    prevDeepLinkKeyRef.current = { startIndex, deckId };
+
+    if (isDeepLinkChange) {
+      prevSafeSlideIdsRef.current = safeSlides.map((s) => s.id);
+      setIndex(initialIndex);
+      return;
+    }
+
+    // Read the prior ids before overwriting the ref below — the lookup
+    // needs the slide order from before this update, not the one it's
+    // producing.
+    const activeId = prevSafeSlideIdsRef.current[indexRef.current];
+    const newIds = safeSlides.map((s) => s.id);
+    const followedIndex = activeId ? newIds.indexOf(activeId) : -1;
+    prevSafeSlideIdsRef.current = newIds;
+    setIndex(
+      followedIndex >= 0
+        ? followedIndex
+        : Math.max(0, Math.min(indexRef.current, safeSlides.length - 1)),
+    );
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [safeSlides, startIndex, deckId]);
+
   const current = safeSlides[index];
   const next = safeSlides[index + 1];
   const notes = current?.notes?.trim();
 
+  if (safeSlides.length === 0) {
+    return (
+      // guard:allow-raw-color — matches the presenter's dedicated dark surface used throughout this file, not app chrome
+      <div className="fixed inset-0 flex items-center justify-center bg-[hsl(240,6%,6%)] text-white">
+        <button
+          type="button"
+          onClick={() => window.close()}
+          // guard:allow-raw-color — matches the presenter's dedicated dark surface used throughout this file, not app chrome
+          className="cursor-pointer rounded-lg bg-white/10 px-4 py-3 text-sm hover:bg-white/20"
+        >
+          {t("presentation.noSlides")}
+        </button>
+      </div>
+    );
+  }
+
   return (
     <div className="fixed inset-0 flex flex-col bg-[hsl(240,6%,6%)] text-white">
       <header className="flex items-center justify-between gap-4 border-b border-white/10 px-5 py-3">

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

@@ -112,6 +112,8 @@ export interface Slide {
   animations?: SlideAnimation[];
   /** @deprecated Use animations instead */
   splitByParagraph?: boolean;
+  /** Excluded from Present/Presenter mode playback, but stays in the deck. */
+  skipped?: boolean;
 }
 
 export type AnimationType = "appear" | "fade" | "slide-up" | "zoom";
@@ -237,6 +239,14 @@ interface DeckContextType {
   ) => void;
   deleteSlide: (deckId: string, slideId: string) => void;
   duplicateSlide: (deckId: string, slideId: string) => string | undefined;
+  /** Inserts a copy of arbitrary slide data after `afterSlideId`. Used for
+   *  slide cut/paste, where the original may already be deleted so there is
+   *  no live slide id left to duplicate from. */
+  pasteSlide: (
+    deckId: string,
+    afterSlideId: string,
+    slideFields: Omit<Slide, "id">,
+  ) => string | undefined;
   reorderSlides: (deckId: string, oldIndex: number, newIndex: number) => void;
   setDeckSlides: (deckId: string, slides: Slide[]) => void;
   /**
@@ -287,13 +297,54 @@ type DuplicateDeckActionResult = {
   url?: string;
 };
 
+/** Per-slide fields `get-deck` computes for the agent (slide position/hash
+ *  hints) that aren't part of the client's own `Slide` shape. Left on the
+ *  fetched deck, they make every server refetch look "changed" relative to
+ *  the client's slim optimistic copy — see `normalizeActionDeck`. */
+const GET_DECK_ONLY_SLIDE_FIELDS = [
+  "slideNumber",
+  "zeroBasedIndex",
+  "contentHash",
+] as const;
+
+/** Deck-level fields `get-deck` computes for the agent (counts, deep links,
+ *  the currently-selected slide) that aren't part of the client's own `Deck`
+ *  shape. See `normalizeActionDeck`. */
+const GET_DECK_ONLY_DECK_FIELDS = [
+  "slideCount",
+  "slideNumbering",
+  "deepLink",
+  "selectedSlideId",
+] as const;
+
 function normalizeActionDeck(value: unknown): Deck | null {
   if (!value || typeof value !== "object") return null;
   const deck = value as Partial<Deck>;
   if (typeof deck.id !== "string") return null;
 
+  const deckRecord = deck as unknown as Record<string, unknown>;
+  const cleanedDeck = { ...deckRecord };
+  for (const field of GET_DECK_ONLY_DECK_FIELDS) delete cleanedDeck[field];
+
+  // Strip the same decorative fields from every slide, so a deck fetched from
+  // `get-deck` is structurally identical to one built by local mutations —
+  // otherwise `deckContentSignature` sees a "change" on every refetch of the
+  // open deck and spams the undo stack with no-op `replace-deck` entries.
+  const slides = Array.isArray(deck.slides)
+    ? deck.slides.map((slide) => {
+        if (!slide || typeof slide !== "object") return slide;
+        const cleanedSlide = {
+          ...(slide as unknown as Record<string, unknown>),
+        };
+        for (const field of GET_DECK_ONLY_SLIDE_FIELDS) {
+          delete cleanedSlide[field];
+        }
+        return cleanedSlide as unknown as Slide;
+      })
+    : [];
+
   return {
-    ...deck,
+    ...cleanedDeck,
     id: deck.id,
     title: typeof deck.title === "string" ? deck.title : "Untitled",
     createdAt:
@@ -304,7 +355,7 @@ function normalizeActionDeck(value: unknown): Deck | null {
       typeof deck.updatedAt === "string"
         ? deck.updatedAt
         : deck.createdAt || "",
-    slides: Array.isArray(deck.slides) ? deck.slides : [],
+    slides,
   } as Deck;
 }
 
@@ -873,7 +924,14 @@ export function deriveInverseOp(
         // restores exactly what changed (including clearing fields back to
         // undefined).
         if (!equalDeckValue(prior[key], op.fields[key])) {
-          (priorFields as Record<string, unknown>)[key] = prior[key];
+          let priorValue: unknown = prior[key];
+          // `skipped` is undefined on a slide that was never skipped, but
+          // `undefined` doesn't survive JSON transport to the server — its
+          // `patch-slide` handler treats an absent field as "don't touch",
+          // so the persisted deck would stay skipped after undo. `false` is
+          // equivalent for this boolean field and does survive.
+          if (key === "skipped" && priorValue === undefined) priorValue = false;
+          (priorFields as Record<string, unknown>)[key] = priorValue;
         }
       }
       if (Object.keys(priorFields).length === 0) return null;
@@ -2346,6 +2404,38 @@ export function DeckProvider({ children }: { children: ReactNode }) {
     [markDeckDirty, recordUndo, setDecksLocal],
   );
 
+  const pasteSlide = useCallback(
+    (deckId: string, afterSlideId: string, slideFields: Omit<Slide, "id">) => {
+      const before = decksRef.current.find((d) => d.id === deckId);
+      if (!before) return undefined;
+
+      markDeckDirty(deckId);
+      const newSlide: Slide = { ...slideFields, id: nanoid(8) };
+      setDecksLocal((prev) =>
+        prev.map((d) => {
+          if (d.id !== deckId) return d;
+          const idx = d.slides.findIndex((s) => s.id === afterSlideId);
+          const insertAt = idx === -1 ? d.slides.length : idx + 1;
+          const slides = [...d.slides];
+          slides.splice(insertAt, 0, newSlide);
+          return { ...d, slides, updatedAt: new Date().toISOString() };
+        }),
+      );
+      // Granular add-slide op, same as duplicateSlide — inserts after
+      // afterSlideId regardless of whether that id is also the copy source.
+      const op: PatchDeckOp = {
+        op: "add-slide",
+        slideId: newSlide.id,
+        afterSlideId,
+        fields: addSlideFields(newSlide),
+      };
+      enqueueDeckOp(deckId, op);
+      recordUndo(before, op, { label: "Paste slide" });
+      return newSlide.id;
+    },
+    [markDeckDirty, recordUndo, setDecksLocal],
+  );
+
   const reorderSlides = useCallback(
     (deckId: string, oldIndex: number, newIndex: number) => {
       markDeckDirty(deckId);
@@ -2432,6 +2522,7 @@ export function DeckProvider({ children }: { children: ReactNode }) {
         updateSlide,
         deleteSlide,
         duplicateSlide,
+        pasteSlide,
         reorderSlides,
         setDeckSlides,
         markDeckDirty,

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

@@ -524,6 +524,11 @@ const messages = {
     newSlide: "New slide",
     closeAddSlides: "Close",
     describeThisSlide: "Describe this slide",
+    cut: "Cut",
+    copy: "Copy",
+    paste: "Paste",
+    skipSlide: "Skip slide",
+    unskipSlide: "Unskip slide",
   },
   presentation: {
     loadFailed: "Could not load this presentation.",

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

@@ -60,6 +60,7 @@ import { Button } from "@/components/ui/button";
 import {
   deckIdFromPathname,
   hasUnsavedDeckChanges,
+  type Slide,
   useDecks,
   useSaveState,
 } from "@/context/DeckContext";
@@ -185,6 +186,7 @@ export default function DeckEditor() {
     updateSlide,
     deleteSlide,
     duplicateSlide,
+    pasteSlide,
     duplicateDeck,
     addSlide,
     flushDeckSave,
@@ -852,11 +854,107 @@ export default function DeckEditor() {
     return () => document.removeEventListener("keydown", handleKeyDown);
   }, [deck, id, activeSlideId, deleteSlideWithUndo, pinMode, drawMode]);
 
-  // Command/Ctrl+C then Command/Ctrl+V on the slide rail duplicates the
+  // Slide-level clipboard backing both the Cmd+C/Cmd+V shortcut below and the
+  // rail's right-click Cut/Copy/Paste menu. Holds a full slide snapshot
+  // (rather than just an id) so paste still works after Cut has already
+  // removed the original slide from the deck.
+  const slideClipboardRef = useRef<Slide | null>(null);
+  const [hasSlideClipboard, setHasSlideClipboard] = useState(false);
+
+  const copySlide = useCallback(
+    (slideId: string) => {
+      const slide = deck?.slides.find((s) => s.id === slideId);
+      if (!slide) return;
+      slideClipboardRef.current = slide;
+      setHasSlideClipboard(true);
+    },
+    [deck],
+  );
+
+  const cutSlide = useCallback(
+    (slideId: string) => {
+      if (!deck || !id || deck.slides.length <= 1) return; // don't cut the last slide
+      const slide = deck.slides.find((s) => s.id === slideId);
+      if (!slide) return;
+      slideClipboardRef.current = slide;
+      setHasSlideClipboard(true);
+      const idx = deck.slides.findIndex((s) => s.id === slideId);
+      const nextSlide = deck.slides[idx + 1] || deck.slides[idx - 1];
+      deleteSlideWithUndo(id, slideId);
+      if (activeSlideId === slideId && nextSlide) {
+        setActiveSlideId(nextSlide.id);
+      }
+    },
+    [deck, id, activeSlideId, deleteSlideWithUndo],
+  );
+
+  const pasteSlideAfter = useCallback(
+    (targetSlideId: string) => {
+      const clipboard = slideClipboardRef.current;
+      if (!clipboard || !id) return;
+      const { id: _clipboardId, ...fields } = clipboard;
+      const newId = pasteSlide(id, targetSlideId, fields);
+      if (newId) setActiveSlideId(newId);
+    },
+    [id, pasteSlide],
+  );
+
+  // Handlers backing the slide rail's right-click menu.
+  const handleDeleteSlideFromRail = useCallback(
+    (slideId: string) => {
+      if (!deck || !id || deck.slides.length <= 1) return; // don't delete the last slide
+      const idx = deck.slides.findIndex((s) => s.id === slideId);
+      const nextSlide = deck.slides[idx + 1] || deck.slides[idx - 1];
+      deleteSlideWithUndo(id, slideId);
+      if (activeSlideId === slideId && nextSlide) {
+        setActiveSlideId(nextSlide.id);
+      }
+    },
+    [deck, id, activeSlideId, deleteSlideWithUndo],
+  );
+
+  const handleDuplicateSlideFromRail = useCallback(
+    (slideId: string) => {
+      if (!id) return;
+      const newId = duplicateSlide(id, slideId);
+      if (newId) setActiveSlideId(newId);
+    },
+    [id, duplicateSlide],
+  );
+
+  const handleNewSlideAfter = useCallback(
+    (afterSlideId: string) => {
+      if (!deck || !id) return;
+      const afterIdx = deck.slides.findIndex((s) => s.id === afterSlideId);
+      // Immediate persistence: mirrors handleAddEmptySlide, since this also
+      // opens the "describe this slide" popover right away.
+      const newId = addSlide(
+        id,
+        "blank",
+        afterIdx >= 0 ? afterIdx : undefined,
+        { persistence: "immediate" },
+      );
+      setActiveSlideId(newId);
+      setSidebarOpen(true);
+      setDescribeSlideId(newId);
+    },
+    [deck, id, addSlide],
+  );
+
+  const handleToggleSkipSlide = useCallback(
+    (slideId: string) => {
+      if (!deck || !id) return;
+      const slide = deck.slides.find((s) => s.id === slideId);
+      if (!slide) return;
+      updateSlide(id, slideId, { skipped: !slide.skipped });
+    },
+    [deck, id, updateSlide],
+  );
+
+  // Command/Ctrl+C then Command/Ctrl+V on the slide rail copies/pastes the
   // selected slide directly below itself. Only claims the shortcut when no
   // slide element is selected — SlideEditor owns Cmd+C/V for object copy/paste
   // in that case.
-  const copiedSlideIdRef = useRef<string | null>(null);
   useEffect(() => {
     const handleKeyDown = (e: KeyboardEvent) => {
       if (!deck || !id || !canEdit) return;
@@ -925,19 +1023,27 @@ export default function DeckEditor() {
 
       if (key === "c") {
         if (!activeSlideId) return;
-        copiedSlideIdRef.current = activeSlideId;
+        copySlide(activeSlideId);
         return;
       }
 
-      const copiedId = copiedSlideIdRef.current;
-      if (!copiedId || !deck.slides.some((s) => s.id === copiedId)) return;
+      if (!hasSlideClipboard || !activeSlideId) return;
       e.preventDefault();
-      const newId = duplicateSlide(id, copiedId);
-      if (newId) setActiveSlideId(newId);
+      pasteSlideAfter(activeSlideId);
     };
     document.addEventListener("keydown", handleKeyDown);
     return () => document.removeEventListener("keydown", handleKeyDown);
-  }, [deck, id, canEdit, activeSlideId, duplicateSlide, pinMode, drawMode]);
+  }, [
+    deck,
+    id,
+    canEdit,
+    activeSlideId,
+    copySlide,
+    hasSlideClipboard,
+    pasteSlideAfter,
+    pinMode,
+    drawMode,
+  ]);
 
   // Resolve the active slide from URL/deck state. Imports replace slide IDs, so
   // keep this valid after deck contents change instead of only on first load.
@@ -1371,6 +1477,14 @@ export default function DeckEditor() {
                     setGeneratingSlideSelected(true);
                     if (window.innerWidth < 768) setSidebarOpen(false);
                   }}
+                  hasSlideClipboard={hasSlideClipboard}
+                  onCutSlide={cutSlide}
+                  onCopySlide={copySlide}
+                  onPasteSlide={pasteSlideAfter}
+                  onDeleteSlide={handleDeleteSlideFromRail}
+                  onNewSlideAfter={handleNewSlideAfter}
+                  onDuplicateSlide={handleDuplicateSlideFromRail}
+                  onToggleSkipSlide={handleToggleSkipSlide}
                 />
               </DndContext>
             </div>

package/corpus/templates/videos/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "videos",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "build": "node ../../scripts/build-retired-netlify-site.ts videos"
+  },
+  "agentNativeRetiredCompatibility": true
+}

package/dist/a2a/correlation.d.ts

@@ -3,11 +3,11 @@ export declare const MAX_A2A_CORRELATION_VALUE_CHARS = 200;
 export declare const MAX_A2A_DELEGATION_HOPS = 3;
 export declare function sanitizeA2ACorrelationId(value: unknown): string | undefined;
 /**
- * Keep only bounded, opaque ASCII correlation identifiers. These values
- * remain telemetry hints; authentication continues to come exclusively from
- * the verified A2A token/request context. `callerModel` is the one value here
- * a receiver may act on, and only as a preference — it never reaches identity,
- * org, access, or approval resolution, and it can only name a model the
- * receiver's own engine already offers (see `resolveDelegatedRunModel`).
+ * Keep only bounded, opaque ASCII correlation and routing identifiers.
+ * Authentication continues to come exclusively from the verified A2A
+ * token/request context. A receiver may use `selectedReceiverApp` only to
+ * prioritize its matching local tool surface, and `callerModel` only to choose
+ * a model its own engine already offers. Neither reaches identity, data
+ * ownership, org, access, or approval resolution.
  */
 export declare function sanitizeA2ACorrelationMetadata(value: unknown): A2ACorrelationMetadata;

package/dist/a2a/correlation.js

@@ -19,18 +19,19 @@ export function sanitizeA2ACorrelationId(value) {
     return boundedIdentifier(value, CORRELATION_ID_PATTERN);
 }
 /**
- * Keep only bounded, opaque ASCII correlation identifiers. These values
- * remain telemetry hints; authentication continues to come exclusively from
- * the verified A2A token/request context. `callerModel` is the one value here
- * a receiver may act on, and only as a preference — it never reaches identity,
- * org, access, or approval resolution, and it can only name a model the
- * receiver's own engine already offers (see `resolveDelegatedRunModel`).
+ * Keep only bounded, opaque ASCII correlation and routing identifiers.
+ * Authentication continues to come exclusively from the verified A2A
+ * token/request context. A receiver may use `selectedReceiverApp` only to
+ * prioritize its matching local tool surface, and `callerModel` only to choose
+ * a model its own engine already offers. Neither reaches identity, data
+ * ownership, org, access, or approval resolution.
  */
 export function sanitizeA2ACorrelationMetadata(value) {
     if (!value || typeof value !== "object" || Array.isArray(value))
         return {};
     const metadata = value;
     const callerApp = boundedIdentifier(metadata.callerApp, APP_ID_PATTERN);
+    const selectedReceiverApp = boundedIdentifier(metadata.selectedReceiverApp, APP_ID_PATTERN);
     const callerThreadId = sanitizeA2ACorrelationId(metadata.callerThreadId);
     const parentRunId = sanitizeA2ACorrelationId(metadata.parentRunId);
     const parentTurnId = sanitizeA2ACorrelationId(metadata.parentTurnId);
@@ -62,6 +63,7 @@ export function sanitizeA2ACorrelationMetadata(value) {
                 : undefined;
     return {
         ...(callerApp ? { callerApp } : {}),
+        ...(selectedReceiverApp ? { selectedReceiverApp } : {}),
         ...(callerThreadId ? { callerThreadId } : {}),
         ...(parentRunId ? { parentRunId } : {}),
         ...(parentTurnId ? { parentTurnId } : {}),

package/dist/a2a/types.d.ts

@@ -117,14 +117,16 @@ export interface A2ASourceContextReference {
     integrationTaskId: string;
 }
 /**
- * Telemetry-only cross-app correlation, plus `callerModel` — a preference
- * hint. Receivers must never use any caller-supplied value here for identity,
- * ownership, org scoping, access, or approval decisions. `callerModel` widens
- * this channel to a preference, never to an authorization: it may at most pick
- * a model the receiver's already-resolved engine advertises.
+ * Bounded cross-app correlation and routing preferences. Receivers must never
+ * use any caller-supplied value here for identity, data ownership, org scoping,
+ * access, or approval decisions. `selectedReceiverApp` may only prioritize the
+ * matching receiver's local tool surface, while `callerModel` may only pick a
+ * model the receiver's already-resolved engine advertises.
  */
 export interface A2ACorrelationMetadata {
     callerApp?: string;
+    /** App the caller deliberately selected for this delegated objective. */
+    selectedReceiverApp?: string;
     callerThreadId?: string;
     parentRunId?: string;
     parentTurnId?: string;

package/dist/collab/awareness.d.ts

@@ -62,11 +62,11 @@ export declare const postAwareness: import("h3").EventHandlerWithFetch<import("h
     error: string;
     states?: undefined;
 } | {
+    error?: undefined;
     states: {
         clientId: number;
         state: string;
     }[];
-    error?: undefined;
 }>>;
 /**
  * GET /_agent-native/collab/:docId/users
@@ -77,9 +77,9 @@ export declare const getActiveUsers: import("h3").EventHandlerWithFetch<import("
     error: string;
     users?: undefined;
 } | {
+    error?: undefined;
     users: {
         clientId: number;
         lastSeen: number;
     }[];
-    error?: undefined;
 }>>;

package/dist/deploy/build.js

@@ -268,6 +268,14 @@ export const CLOUDFLARE_WORKER_STUB_SUBPATH_MODULES = {
         "export default { CanvasFactory, getData };",
         "",
     ].join("\n"),
+    "pdfjs-dist/legacy/build/pdf.mjs": [
+        "const unavailable = () => { throw new Error('pdfjs-dist unavailable in Cloudflare Pages worker'); };",
+        "export const OPS = new Proxy({}, { get: unavailable });",
+        "export const Util = new Proxy({}, { get: unavailable });",
+        "export const getDocument = unavailable;",
+        "export default { OPS, Util, getDocument };",
+        "",
+    ].join("\n"),
 };
 export function cloudflareWorkerStubAliasArgs(stubDir) {
     const subpathAliases = Object.keys(CLOUDFLARE_WORKER_STUB_SUBPATH_MODULES)

package/dist/observability/routes.d.ts

@@ -41,27 +41,27 @@ export declare function createObservabilityHandler(): import("h3").EventHandlerW
     thumbsUpRate: number;
     avgEvalScore: number;
 } | {
-    error?: undefined;
-    ok?: undefined;
     summary: import("./types.js").TraceSummary;
     spans: import("./types.js").TraceSpan[];
     id?: undefined;
-} | {
     error?: undefined;
     ok?: undefined;
+} | {
     summary?: undefined;
     spans?: undefined;
     id: string;
-} | {
+    error?: undefined;
     ok?: undefined;
+} | {
     summary?: undefined;
     spans?: undefined;
     id?: undefined;
     error: any;
+    ok?: undefined;
 } | {
-    error?: undefined;
     summary?: undefined;
     spans?: undefined;
     id?: undefined;
+    error?: undefined;
     ok: boolean;
 }>>;

package/dist/progress/routes.d.ts

@@ -15,6 +15,6 @@ export declare function createProgressHandler(): import("h3").EventHandlerWithFe
     error: string;
     ok?: undefined;
 } | {
-    error?: undefined;
     ok: boolean;
+    error?: undefined;
 }>>;