@agent-native/core 0.149.3 → 0.149.5

package/corpus/README.md

@@ -31,4 +31,4 @@ rg -n "defineAction|useActionQuery" node_modules/@agent-native/core/corpus
 
 ## Generated Counts
 
-- template files: 8038
+- template files: 8043

package/corpus/templates/slides/.agents/skills/slide-editing/SKILL.md

@@ -72,10 +72,17 @@ To edit a slide's content:
 3. **Modify the content** HTML string for the intended slide. Preserve an
    approved native template or component when it already fits; generate
    net-new structure only when the relevant corpus is empty.
-4. **Update the slide** with the `update-slide` action using `deckId`,
-   `slideId`, and `fullContent`. Do not write deck rows directly or add raw
-   full-deck writes for normal slide edits; use `patch-deck` for browser/editor
-   changes.
+4. **Update the slide** with `update-slide` using `deckId`, `slideId`, and
+   ordered `edits`. For code-style work, first read with `get-deck` using the
+   target `slideId`, `compact=false`, and `format=true`, then send the returned
+   `contentHash` as `baseContentHash`. Use exact replace, insert before/after,
+   replace between markers, or regex replace. Set `expectedMatches` whenever a
+   marker could be ambiguous. All edits are applied in memory under the deck
+   lock; if one required edit fails, nothing is written. Set `format=true` on
+   `update-slide` to persist readable Prettier line breaks. Use `fullContent`
+   only for an intentional full rewrite - do not regenerate a slide to make a
+   small change. Do not write deck rows directly or add raw full-deck writes;
+   use `patch-deck` for browser/editor changes.
 5. For browser/editor code, enqueue granular deck operations through
    `patch-deck` / `DeckContext.tsx` instead of replacing the whole deck JSON.
 
@@ -83,6 +90,18 @@ To edit a slide's content:
    preserve quote, speaker, date, metric, and uncertainty status. Existing HTML
    or visual similarity is not proof of source fidelity.
 
+## Click-to-reveal animations
+
+Animations are metadata over the final slide HTML, not alternate slide markup.
+Read the full target slide, keep its existing visual structure, and patch the
+complete ordered `animations` list with `elementPath` values from that exact
+HTML. Elements omitted from the list remain visible immediately, so labels and
+headings need no duplicate markup. Do not add hidden duplicates, layout
+spacers, absolute-positioned copies, transforms, or placeholder content to
+simulate reveals. When content and reveals change together, send both fields in
+one `patch-deck` operation. To remove reveals, send `animations: []` with the
+existing content and verify the persisted slide afterward.
+
 If retrieval produces a new immutable context pack, keep its `contextPackId`
 and reuse labels with the deck provenance. Existing slide HTML is not proof of
 which source version influenced it.

package/corpus/templates/slides/actions/get-deck.ts

@@ -4,7 +4,9 @@ import { getRequestUserEmail } from "@agent-native/core/server/request-context";
 import { resolveAccess } from "@agent-native/core/sharing";
 import { z } from "zod";
 
+import { formatSlideHtml } from "../server/lib/slide-content-patch.js";
 import { summarizeSlideAnimationTargets } from "../server/lib/validate-slide-animations.js";
+import { hashSlideContent } from "../shared/slide-fit.js";
 import "../server/db/index.js"; // ensure registerShareableResource runs
 
 function stripHtml(html: string): string {
@@ -76,6 +78,12 @@ export default defineAction({
       .describe(
         "Set to 'true' for compact slide summaries, or 'false' for full slide HTML. In-app agent calls without slideId default to compact output.",
       ),
+    format: z
+      .enum(["true", "false"])
+      .optional()
+      .describe(
+        "Set to 'true' to return full slide HTML formatted with Prettier for code-style patches. The contentHash still identifies the persisted source.",
+      ),
   }),
   http: { method: "GET" },
   mcpApp: {
@@ -169,6 +177,22 @@ export default defineAction({
     const deckMetadata = { ...data };
     delete deckMetadata.slides;
 
+    const formatHtml = args.format === "true";
+    const fullSlides = await Promise.all(
+      slideEntries.map(async ({ slide: s, index: i }) => ({
+        ...s,
+        slideNumber: i + 1,
+        zeroBasedIndex: i,
+        id: s.id,
+        layout: s.layout ?? null,
+        content: formatHtml
+          ? await formatSlideHtml(String(s.content ?? ""))
+          : s.content,
+        contentHash: hashSlideContent(String(s.content ?? "")),
+        notes: s.notes ?? null,
+      })),
+    );
+
     return {
       ...deckMetadata,
       id: row.id,
@@ -184,15 +208,7 @@ export default defineAction({
       updatedAt: row.updatedAt,
       deepLink: deckDeepLink(row.id),
       ...(selectedSlide ? { selectedSlideId: selectedSlide.id } : {}),
-      slides: slideEntries.map(({ slide: s, index: i }) => ({
-        ...s,
-        slideNumber: i + 1,
-        zeroBasedIndex: i,
-        id: s.id,
-        layout: s.layout ?? null,
-        content: s.content,
-        notes: s.notes ?? null,
-      })),
+      slides: fullSlides,
     };
   },
   link: ({ result, args }) => {

package/corpus/templates/slides/actions/patch-deck.ts

@@ -434,6 +434,52 @@ export function applyOperation(deck: any, op: Operation): void {
   }
 }
 
+/**
+ * Agent content rewrites must not inherit click-reveal paths implicitly. A
+ * caller that wants to revise both HTML and reveals sends `animations` in the
+ * same patch, including the complete ordered list. Source-preserving edits are
+ * the exception: they retain imported reveal metadata unless the caller opts
+ * into an explicit source rewrite.
+ */
+export function clearOmittedAnimationsForAgentContentPatches(
+  deck: any,
+  operations: readonly Operation[],
+  options?: { sourceImport?: SourceImportMetadata | null },
+): void {
+  const explicitAnimationSlideIds = new Set(
+    operations.flatMap((operation) =>
+      operation.op === "patch-slide" &&
+      operation.fields.animations !== undefined
+        ? [operation.slideId]
+        : [],
+    ),
+  );
+  const sourceSlideIds = new Set(
+    options?.sourceImport?.slideIds ??
+      options?.sourceImport?.slides.map((slide) => slide.id) ??
+      [],
+  );
+  const slideIds = new Set(
+    operations.flatMap((operation) =>
+      operation.op === "patch-slide" &&
+      operation.fields.content !== undefined &&
+      operation.fields.animations === undefined &&
+      !explicitAnimationSlideIds.has(operation.slideId) &&
+      (operation.preserveSource === false ||
+        !sourceSlideIds.has(operation.slideId))
+        ? [operation.slideId]
+        : [],
+    ),
+  );
+  if (!slideIds.size) return;
+
+  for (const slide of Array.isArray(deck.slides) ? deck.slides : []) {
+    if (slideIds.has(slide?.id) && Array.isArray(slide.animations)) {
+      delete slide.animations;
+    }
+  }
+}
+
 /**
  * Content and animation metadata are one contract. Validate only slides whose
  * content or animation list changed so unrelated note/title writes do not
@@ -620,6 +666,11 @@ export default defineAction({
       for (const op of operations) {
         applyOperation(deck, op);
       }
+      if (isAgentCaller) {
+        clearOmittedAnimationsForAgentContentPatches(deck, operations, {
+          sourceImport,
+        });
+      }
       assertPatchedSlideAnimationsResolve(deck, operations, {
         requireElementPaths: isAgentCaller,
       });

package/corpus/templates/slides/actions/update-slide.ts

@@ -16,6 +16,11 @@ import { normalizeSlidePadding } from "../app/lib/normalize-slide-padding.js";
 import { getDb, schema } from "../server/db/index.js"; // ensure registerShareableResource runs
 import { notifyClients } from "../server/handlers/decks.js";
 import { createDeckVersionSnapshot } from "../server/lib/deck-versions.js";
+import {
+  applySlideContentEdits,
+  formatSlideHtml,
+  type SlideContentEdit,
+} from "../server/lib/slide-content-patch.js";
 import {
   assertSourceSlidePreserved,
   sourceImportForDeck,
@@ -92,8 +97,7 @@ function storedCreativeContext(value: unknown): {
 
 export default defineAction({
   description:
-    "Surgically edit a slide's content using search-replace or full replacement. " +
-    "Syncs live to open editors. Prefer this over full deck rewrites. Source-imported slides preserve their original images and factual copy by default.",
+    "Atomically patch a slide's HTML like a code editor: send several exact edits against the current source, optionally format it with Prettier, and sync the result live to open editors. Prefer edits over fullContent so unrelated markup is not regenerated. Use baseContentHash from get-deck to reject stale patches. Content edits clear existing click-reveal metadata; use patch-deck with the complete animations list when the edit intentionally changes both content and reveals. Source-imported slides preserve their original images and factual copy by default.",
   schema: z.object({
     deckId: z.string().describe("Deck ID"),
     slideId: z.string().describe("Slide ID"),
@@ -109,6 +113,64 @@ export default defineAction({
       .string()
       .optional()
       .describe("Full HTML to replace entire slide content"),
+    edits: z
+      .array(
+        z.union([
+          z.object({
+            op: z.literal("replace").optional(),
+            find: z.string(),
+            replace: z.string(),
+            all: z.boolean().optional(),
+            occurrence: z.number().int().positive().optional(),
+            expectedMatches: z.number().int().nonnegative().optional(),
+            required: z.boolean().optional(),
+          }),
+          z.object({
+            op: z.enum(["insert-before", "insert-after"]),
+            marker: z.string(),
+            content: z.string(),
+            occurrence: z.number().int().positive().optional(),
+            expectedMatches: z.number().int().nonnegative().optional(),
+            required: z.boolean().optional(),
+          }),
+          z.object({
+            op: z.literal("replace-between"),
+            start: z.string(),
+            end: z.string(),
+            content: z.string(),
+            includeDelimiters: z.boolean().optional(),
+            expectedMatches: z.number().int().nonnegative().optional(),
+            required: z.boolean().optional(),
+          }),
+          z.object({
+            op: z.literal("regex-replace"),
+            pattern: z.string(),
+            replace: z.string(),
+            flags: z.string().optional(),
+            all: z.boolean().optional(),
+            expectedMatches: z.number().int().nonnegative().optional(),
+            required: z.boolean().optional(),
+          }),
+        ]),
+      )
+      .min(1)
+      .optional()
+      .describe(
+        "Ordered atomic edits against the current HTML. Each edit must match unless required=false. Use expectedMatches to make ambiguity explicit.",
+      ),
+    baseContentHash: z
+      .string()
+      .optional()
+      .describe(
+        "Hash returned by get-deck for the exact slide source being patched. The edit is rejected if the source changed since it was read.",
+      ),
+    format: z
+      .boolean()
+      .optional()
+      .default(false)
+      .describe(
+        "Format the resulting HTML with Prettier before persisting it.",
+      ),
     preserveSource: z
       .boolean()
       .optional()
@@ -142,13 +204,24 @@ export default defineAction({
       find,
       replace,
       fullContent,
+      edits,
+      baseContentHash,
+      format,
       preserveSource,
       contextPackId,
       contextModeOverride,
       reuseLabels,
     } = args;
-    if (!find && !fullContent) {
-      throw new Error("Either --find or --fullContent is required");
+    if (!edits && find === undefined && fullContent === undefined) {
+      throw new Error("One of --edits, --find, or --fullContent is required");
+    }
+    if (find !== undefined && find.length === 0) {
+      throw new Error("find must not be empty for legacy search/replace");
+    }
+    if (edits && (find !== undefined || fullContent !== undefined)) {
+      throw new Error(
+        "Use --edits instead of combining it with --find or --fullContent",
+      );
     }
     await assertAccess("deck", deckId, "editor");
 
@@ -203,6 +276,15 @@ export default defineAction({
         throw new Error(`Slide ${slideId} not found in deck ${deckId}`);
       }
 
+      if (
+        baseContentHash !== undefined &&
+        hashSlideContent(String(slide.content ?? "")) !== baseContentHash
+      ) {
+        throw new Error(
+          "Slide content changed since it was read. Call get-deck with this slideId again and rebase the patch.",
+        );
+      }
+
       // ─── Apply the edit to the slide content in decks.data ────────────────
       //
       // The agent edits the canonical slide HTML stored in `decks.data` (SQL is
@@ -215,8 +297,9 @@ export default defineAction({
       // structure renders and merges with concurrent typing via the Yjs CRDT.
       let applied = false;
       let notFound = false;
+      const previousContent = String(slide.content ?? "");
 
-      if (fullContent) {
+      if (fullContent !== undefined) {
         const nextContent = normalizeSlidePadding(fullContent);
         assertSourceSlidePreserved({
           metadata: sourceImportForDeck(deck.sourceImport),
@@ -225,16 +308,35 @@ export default defineAction({
           preserveSource,
         });
         slide.content = nextContent;
-        applied = true;
-      } else if (find) {
-        const idx = (slide.content as string).indexOf(find);
+        applied = nextContent !== previousContent;
+      } else if (edits) {
+        const sourceContent = format
+          ? await formatSlideHtml(previousContent)
+          : previousContent;
+        const patched = await applySlideContentEdits(
+          sourceContent,
+          edits as SlideContentEdit[],
+          format,
+        );
+        const nextContent = normalizeSlidePadding(patched.content);
+        assertSourceSlidePreserved({
+          metadata: sourceImportForDeck(deck.sourceImport),
+          slideId,
+          nextContent,
+          preserveSource,
+        });
+        slide.content = nextContent;
+        applied = patched.changed;
+        if (!applied) slide.content = previousContent;
+      } else if (find !== undefined) {
+        const idx = previousContent.indexOf(find);
         if (idx === -1) {
           notFound = true;
         } else {
           const nextContent =
-            slide.content.slice(0, idx) +
+            previousContent.slice(0, idx) +
             (replace ?? "") +
-            slide.content.slice(idx + find.length);
+            previousContent.slice(idx + find.length);
           assertSourceSlidePreserved({
             metadata: sourceImportForDeck(deck.sourceImport),
             slideId,
@@ -242,10 +344,19 @@ export default defineAction({
             preserveSource,
           });
           slide.content = nextContent;
-          applied = true;
+          applied = nextContent !== previousContent;
         }
       }
 
+      // Animation targets are paths into the persisted HTML. A content edit
+      // can keep every path valid while changing which visual element lives at
+      // that path, so preserving the old list would reveal the wrong content.
+      // patch-deck is the explicit escape hatch when content and animations
+      // are intentionally revised together.
+      if (applied && Array.isArray(slide.animations)) {
+        delete slide.animations;
+      }
+
       // ─── Persist to SQL ───────────────────────────────────────────────────
       //
       // The fresh `updatedAt` (on both the deck JSON and the row) is the signal
@@ -352,23 +463,41 @@ export default defineAction({
           notFound,
           slide,
           slideIndex,
+          contentHash: hashSlideContent(String(slide.content ?? "")),
           contextMode,
           contextPackId: validated.contextPackId,
           reuseLabels: slideReuseLabels,
         };
       }
 
-      return { applied, notFound, slide, slideIndex };
+      return {
+        applied,
+        notFound,
+        slide,
+        slideIndex,
+        contentHash: hashSlideContent(String(slide.content ?? "")),
+      };
     });
 
     if (rmw.notFound) {
       return {
         ok: false,
-        message: `Text not found in slide: "${find!.slice(0, 60)}". Use get-deck with compact=false to see the current slide HTML.`,
+        message: `Text not found in slide: "${find!.slice(0, 60)}". Use get-deck with this slideId to see the current slide HTML.`,
       };
     }
 
     const { applied } = rmw;
+    if (!applied) {
+      return {
+        ok: true,
+        deckId,
+        slideId,
+        applied: false,
+        contentHash: rmw.contentHash,
+        deepLink: deckDeepLink(deckId),
+      };
+    }
+
     // Start the freshness window after the SQL write and before notifying the
     // editor. This keeps a fast render from being rejected as stale.
     const fitSince = Date.now();
@@ -390,7 +519,7 @@ export default defineAction({
     notifyClients(deckId, { slideId, actor: "agent" });
 
     console.log(
-      `update-slide: deck=${deckId} slide=${slideId} ${find ? `find="${find.slice(0, 40)}"` : "fullContent"} applied=${applied}`,
+      `update-slide: deck=${deckId} slide=${slideId} ${edits ? `edits=${edits.length}` : find !== undefined ? `find="${find.slice(0, 40)}"` : "fullContent"} applied=${applied}`,
     );
 
     // Wait briefly for the editor to re-render and measure. If the patched
@@ -408,6 +537,7 @@ export default defineAction({
       deckId,
       slideId,
       applied,
+      contentHash: rmw.contentHash,
       deepLink: deckDeepLink(deckId),
       ...(rmw.contextMode
         ? {

package/corpus/templates/slides/app/lib/create-deck-generation.ts

@@ -108,11 +108,19 @@ export function isSourceImprovementRequest(
     /\bmake\b[\s\S]{0,40}\b(better|modern|professional|polished|prett\w*)\b/.test(
       normalized,
     );
+  const asksToPreserveSource =
+    /(?:\b(turn|convert|transform)\b[\s\S]{0,50}\b(into|to)\b[\s\S]{0,30}\b(deck|presentation|slides?)\b|\b(create|build|make|generate)\b[\s\S]{0,80}\b(deck|presentation|slides?)\b[\s\S]{0,80}\bfrom\b)/.test(
+      normalized,
+    ) &&
+    /\b(copy|slide[- ]for[- ]slide|preserv\w*|same order|before\s*\/?\s*after|placeholder\w*|out of order)\b/.test(
+      normalized,
+    );
   // A source deck attachment is the object being improved even when the
-  // prompt uses an implicit phrase such as "make this prettier". Requiring a
-  // source noun here silently falls back to reference-only generation and can
-  // discard the uploaded deck's slide IDs and content.
-  return asksToImprove;
+  // prompt uses an implicit phrase such as "make this prettier" or asks to
+  // copy and restyle it. Requiring a source noun here silently falls back to
+  // reference-only generation and can discard the uploaded deck's slide IDs
+  // and content.
+  return asksToImprove || asksToPreserveSource;
 }
 
 function describeUploadedFilesForAgent(

package/corpus/templates/slides/changelog/2026-08-11-pdf-requests-to-restyle-and-preserve-a-source-deck-now-impor.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-08-11
+---
+
+PDF requests to restyle and preserve a source deck now import the full deck before editing

package/corpus/templates/slides/changelog/2026-08-11-slide-edits-preserve-their-layout-without-introducing-hidden.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-08-11
+---
+
+Slide edits preserve their layout without introducing hidden duplicate elements or stale click reveals

package/corpus/templates/slides/changelog/2026-08-11-slides-reliably-imports-uploaded-pdfs-and-presentations.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-08-11
+---
+
+Slides reliably imports uploaded PDFs and presentations

package/corpus/templates/slides/changelog/2026-08-11-slides-support-atomic-code-style-html-patches-without-regene.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-08-11
+---
+
+Slides support atomic code-style HTML patches without regenerating whole slides

package/corpus/templates/slides/package.json

@@ -57,6 +57,7 @@
     "pdf-parse": "^2.4.5",
     "pdfjs-dist": "5.4.296",
     "pptxgenjs": "4.0.1",
+    "prettier": "^3.9.6",
     "react-markdown": "^10.1.0",
     "rehype-raw": "^7.0.0",
     "y-protocols": "catalog:",