@agent-native/core 0.163.4 → 0.164.3

package/corpus/templates/design/app/pages/design-editor/effects/publish-agent-selection-context.ts

@@ -0,0 +1,252 @@
+import { setClientAppState } from "@agent-native/core/client/hooks";
+import type { RefObject } from "react";
+
+import type { CodeWorkbenchActiveFile } from "@/components/design/code-workbench/CodeWorkbench";
+import type { InspectorTab } from "@/components/design/EditPanel";
+import type { ElementInfo } from "@/components/design/types";
+import type { ResponsiveEditScope } from "@/pages/design-editor/command-types";
+import { DESIGN_SELECTION_ZOOM_SAVE_DELAY_MS } from "@/pages/design-editor/editor-constants";
+import { designSelectionStateKeys } from "@/pages/design-editor/editor-helpers";
+import type {
+  DesignData,
+  DesignFile,
+  DesignLeftPanel,
+  DesignTool,
+  EditorMode,
+} from "@/pages/design-editor/types";
+
+export interface PublishAgentSelectionContextArgs {
+  activeBreakpointWidthState: number | undefined;
+  activeCodeFile: CodeWorkbenchActiveFile | null;
+  activeFile: DesignFile;
+  activeInspectorTab: InspectorTab;
+  activeLeftPanel: DesignLeftPanel;
+  activeTool: DesignTool;
+  design: DesignData | null;
+  designDataJson: Record<string, unknown>;
+  designSelectionOwnerIdRef: RefObject<string>;
+  files: DesignFile[];
+  hoveredElement: ElementInfo | null;
+  id: string | undefined;
+  isSignedIn: boolean;
+  mode: EditorMode;
+  motionDockOpen: boolean;
+  pendingPersistedSelectionWriteRef: RefObject<{
+    key: string;
+    contextKey: string;
+    value: Record<string, unknown>;
+  } | null>;
+  persistedSelectionContextRef: RefObject<string | null>;
+  persistedSelectionStateRef: RefObject<string | null>;
+  persistedSelectionWriteTimerRef: RefObject<number | null>;
+  responsiveEditScope: ResponsiveEditScope;
+  selectedElement: ElementInfo | null;
+  selectedScreenIds: string[];
+  selectedStateId: string | null;
+  viewMode: "single" | "overview";
+  zoom: number;
+}
+
+export function runPublishAgentSelectionContext({
+  activeBreakpointWidthState,
+  activeCodeFile,
+  activeFile,
+  activeInspectorTab,
+  activeLeftPanel,
+  activeTool,
+  design,
+  designDataJson,
+  designSelectionOwnerIdRef,
+  files,
+  hoveredElement,
+  id,
+  isSignedIn,
+  mode,
+  motionDockOpen,
+  pendingPersistedSelectionWriteRef,
+  persistedSelectionContextRef,
+  persistedSelectionStateRef,
+  persistedSelectionWriteTimerRef,
+  responsiveEditScope,
+  selectedElement,
+  selectedScreenIds,
+  selectedStateId,
+  viewMode,
+  zoom,
+}: PublishAgentSelectionContextArgs) {
+  if (!id || !isSignedIn) return;
+  const selection = {
+    designId: id,
+    designTitle: design?.title ?? null,
+    activeFileId: activeFile?.id ?? null,
+    activeFilename: activeFile?.filename ?? null,
+    viewMode,
+    zoom,
+    screens: files.map((file) => ({
+      id: file.id,
+      filename: file.filename,
+      fileType: file.fileType,
+    })),
+    selectedScreenIds,
+    selectedElement,
+    hoveredElement,
+    mode,
+    activeTool,
+    inspectorTab: activeInspectorTab,
+    leftPanel: activeLeftPanel,
+    codeWorkspace: {
+      open: activeLeftPanel === "code",
+      backendKind: activeCodeFile?.backendKind ?? "virtual-inline",
+      activePath: activeCodeFile?.path ?? null,
+      activeFileId: activeCodeFile?.fileId ?? null,
+      dirty: activeCodeFile?.dirty ?? false,
+      versionHash: activeCodeFile?.versionHash ?? null,
+    },
+    // §8 DesignNavigationState additions — dock + breakpoint context
+    dock: { kind: "motion" as const, open: motionDockOpen },
+    motion: {
+      previewing: false,
+      playheadMs: 0,
+      timelineId: undefined as string | undefined,
+      selectedTrackId: undefined as string | undefined,
+      selectedKeyframeId: undefined as string | undefined,
+    },
+    // §8 breakpoint fields — "auto" = no specific breakpoint focused.
+    breakpoint: (activeBreakpointWidthState != null
+      ? activeBreakpointWidthState < 500
+        ? "mobile"
+        : activeBreakpointWidthState < 1024
+          ? "tablet"
+          : "desktop"
+      : "auto") as "auto" | "mobile" | "tablet" | "desktop",
+    activeBreakpointId: (() => {
+      if (activeBreakpointWidthState == null) return undefined;
+      try {
+        const raw = (designDataJson as Record<string, unknown>)?.breakpointSet;
+        if (
+          raw &&
+          typeof raw === "object" &&
+          Array.isArray((raw as Record<string, unknown>).breakpoints)
+        ) {
+          const bps = (
+            raw as { breakpoints: Array<{ id: string; widthPx: number }> }
+          ).breakpoints;
+          return bps.find((b) => b.widthPx === activeBreakpointWidthState)?.id;
+        }
+        // coercion-ok: an unreadable breakpointSet means "none configured", which the undefined return already expresses.
+      } catch {
+        // ignore
+      }
+      return undefined;
+    })(),
+    responsiveEditScope,
+    breakpointSetId: (() => {
+      try {
+        const raw = (designDataJson as Record<string, unknown>)?.breakpointSet;
+        if (raw && typeof raw === "object") {
+          return (raw as Record<string, unknown>).id as string | undefined;
+        }
+        // coercion-ok: an unreadable breakpointSet means "none configured", which the undefined return already expresses.
+      } catch {
+        // ignore
+      }
+      return undefined;
+    })(),
+    // §8 — active design state (null = Default / live view)
+    selectedStateId,
+  };
+  (window as any).__designSelection = selection;
+  const persistedSelection = {
+    designId: selection.designId,
+    designTitle: selection.designTitle,
+    activeFileId: selection.activeFileId,
+    activeFilename: selection.activeFilename,
+    viewMode: selection.viewMode,
+    zoom: selection.zoom,
+    screens: selection.screens,
+    selectedScreenIds: selection.selectedScreenIds,
+    selectedElement: selection.selectedElement,
+    mode: selection.mode,
+    activeTool: selection.activeTool,
+    inspectorTab: selection.inspectorTab,
+    leftPanel: selection.leftPanel,
+    codeWorkspace: selection.codeWorkspace,
+    dock: selection.dock,
+    motion: selection.motion,
+    breakpoint: selection.breakpoint,
+    activeBreakpointId: selection.activeBreakpointId,
+    responsiveEditScope: selection.responsiveEditScope,
+    breakpointSetId: selection.breakpointSetId,
+    selectedStateId: selection.selectedStateId,
+    ownerId: designSelectionOwnerIdRef.current,
+  };
+  const persistedKey = JSON.stringify(persistedSelection);
+  const { zoom: _zoom, ...persistedContext } = persistedSelection;
+  const persistedContextKey = JSON.stringify(persistedContext);
+  const writePersistedSelection = (pending: {
+    key: string;
+    contextKey: string;
+    value: Record<string, unknown>;
+  }) => {
+    persistedSelectionStateRef.current = pending.key;
+    persistedSelectionContextRef.current = pending.contextKey;
+    for (const key of designSelectionStateKeys()) {
+      setClientAppState(key, pending.value, { keepalive: true }).catch(
+        () => {},
+      );
+    }
+  };
+  if (persistedSelectionStateRef.current === persistedKey) {
+    // A zoom gesture can return to the last persisted value before its
+    // trailing write fires. Cancel that now-stale queued intermediate.
+    if (persistedSelectionWriteTimerRef.current !== null) {
+      window.clearTimeout(persistedSelectionWriteTimerRef.current);
+      persistedSelectionWriteTimerRef.current = null;
+    }
+    pendingPersistedSelectionWriteRef.current = null;
+  } else if (persistedSelectionContextRef.current !== persistedContextKey) {
+    // Screen/selection/tool/panel changes are agent context and stay
+    // immediate. Only zoom-only churn is coalesced below.
+    if (persistedSelectionWriteTimerRef.current !== null) {
+      window.clearTimeout(persistedSelectionWriteTimerRef.current);
+      persistedSelectionWriteTimerRef.current = null;
+    }
+    pendingPersistedSelectionWriteRef.current = null;
+    writePersistedSelection({
+      key: persistedKey,
+      contextKey: persistedContextKey,
+      value: persistedSelection,
+    });
+  } else if (pendingPersistedSelectionWriteRef.current?.key !== persistedKey) {
+    // Wheel/pinch zoom can render at 60+ Hz. Writing both scoped and global
+    // application-state keys for every tick creates an avoidable request +
+    // sync-event storm; keep the immediate in-memory context above and
+    // persist only the settled zoom after a short trailing delay.
+    pendingPersistedSelectionWriteRef.current = {
+      key: persistedKey,
+      contextKey: persistedContextKey,
+      value: persistedSelection,
+    };
+    if (persistedSelectionWriteTimerRef.current !== null) {
+      window.clearTimeout(persistedSelectionWriteTimerRef.current);
+    }
+    persistedSelectionWriteTimerRef.current = window.setTimeout(() => {
+      persistedSelectionWriteTimerRef.current = null;
+      const pending = pendingPersistedSelectionWriteRef.current;
+      pendingPersistedSelectionWriteRef.current = null;
+      if (pending) writePersistedSelection(pending);
+    }, DESIGN_SELECTION_ZOOM_SAVE_DELAY_MS);
+  }
+  const el = document.documentElement;
+  el.dataset.designId = id;
+  if (activeFile?.id) el.dataset.fileId = activeFile.id;
+  el.dataset.viewMode = viewMode;
+  el.dataset.zoom = String(zoom);
+  return () => {
+    delete (window as any).__designSelection;
+    delete el.dataset.designId;
+    delete el.dataset.fileId;
+    delete el.dataset.viewMode;
+    delete el.dataset.zoom;
+  };
+}

package/corpus/templates/design/app/pages/design-editor/effects/resume-pending-generation.ts

@@ -0,0 +1,178 @@
+import type { AgentChatMessage } from "@agent-native/core/client/agent-chat";
+import type { PromptComposerSubmitOptions } from "@agent-native/core/client/composer";
+import type { Dispatch, RefObject, SetStateAction } from "react";
+
+import {
+  isPendingGenerationStale,
+  patchPendingGeneration,
+  readPendingGeneration,
+} from "@/lib/pending-generation";
+import {
+  designGenerationDirectives,
+  designIntakeQuestionDirectives,
+  designTemplateRefinementDirectives,
+  designVariantGenerationDirectives,
+  formatUploadedFileContext,
+  imageAttachmentsFromUploadedFiles,
+  loadDesignSystemGenerationContext,
+  promptRequestsVariantExploration,
+} from "@/pages/design-editor/generation-prompt-directives";
+import type { DesignData, DesignFile } from "@/pages/design-editor/types";
+
+export interface ResumePendingGenerationArgs {
+  agentSubmit: (
+    message: string,
+    context: string,
+    options?: Omit<AgentChatMessage, "message" | "context">,
+  ) => string;
+  clearGenerationCompleteTimer: () => void;
+  design: DesignData | null;
+  files: DesignFile[];
+  generationModelRef: RefObject<{
+    model?: string;
+    engine?: string;
+    effort?: PromptComposerSubmitOptions["effort"];
+  } | null>;
+  id: string | undefined;
+  markGenerationStale: () => void;
+  setGenerationChatTabId: Dispatch<SetStateAction<string | null>>;
+  setGenerationIssue: Dispatch<SetStateAction<string | null>>;
+  setHasPendingGeneration: Dispatch<SetStateAction<boolean>>;
+  trackAgentGeneration: (tabId: string) => void;
+}
+
+export function runResumePendingGeneration({
+  agentSubmit,
+  clearGenerationCompleteTimer,
+  design,
+  files,
+  generationModelRef,
+  id,
+  markGenerationStale,
+  setGenerationChatTabId,
+  setGenerationIssue,
+  setHasPendingGeneration,
+  trackAgentGeneration,
+}: ResumePendingGenerationArgs) {
+  if (!id || !design) return;
+
+  const pending = readPendingGeneration(id);
+  if (!pending) {
+    setHasPendingGeneration(false);
+    return;
+  }
+  const templateRefinement = Boolean(pending.templateId && files.length > 0);
+  if (files.length > 0 && !templateRefinement) return;
+
+  if (isPendingGenerationStale(pending)) {
+    markGenerationStale();
+    return;
+  }
+
+  if (pending.runTabId) {
+    setGenerationIssue(null);
+    setHasPendingGeneration(true);
+    setGenerationChatTabId(pending.runTabId);
+    trackAgentGeneration(pending.runTabId);
+    return;
+  }
+
+  const prompt =
+    pending.prompt?.trim() || `Create an initial design for ${design.title}.`;
+  const uploadedFiles = Array.isArray(pending.files) ? pending.files : [];
+  const fileContext = formatUploadedFileContext(uploadedFiles);
+  const images = imageAttachmentsFromUploadedFiles(uploadedFiles);
+  const sourceContext = pending.source
+    ? `The user picked the "${pending.source}" template${pending.templateId ? ` (id: "${pending.templateId}")` : ""}.`
+    : "The user just created a new empty design.";
+  const pendingDesignSystemId =
+    pending.designSystemId === undefined
+      ? design.designSystemId
+      : pending.designSystemId;
+
+  if (pending.autoGenerate === false) {
+    setGenerationIssue(null);
+    setHasPendingGeneration(true);
+    return;
+  }
+
+  let cancelled = false;
+  void (async () => {
+    const shouldExploreVariants = promptRequestsVariantExploration(prompt);
+    // A reference screenshot already answers the questions the intake flow
+    // asks. Spending the one turn that can see the image on a questionnaire
+    // means the turn that writes HTML never sees it.
+    const hasReferenceImages = images.length > 0;
+    const shouldSkipQuestions =
+      pending.skipQuestions === true ||
+      shouldExploreVariants ||
+      hasReferenceImages;
+    const designSystemContext = await loadDesignSystemGenerationContext(
+      pendingDesignSystemId,
+    );
+    if (cancelled) return;
+    const context = [
+      sourceContext,
+      `Design id: "${id}"`,
+      `Design title: "${design.title}"`,
+      `User request: "${prompt}"`,
+      pendingDesignSystemId
+        ? `Design system id: "${pendingDesignSystemId}"`
+        : "",
+      designSystemContext,
+      fileContext,
+      "",
+      ...(pending.templateId
+        ? designTemplateRefinementDirectives(
+            id,
+            pending.templateId,
+            pendingDesignSystemId,
+          )
+        : shouldExploreVariants
+          ? designVariantGenerationDirectives(id, pendingDesignSystemId)
+          : shouldSkipQuestions
+            ? designGenerationDirectives(
+                id,
+                pendingDesignSystemId,
+                images.length,
+              )
+            : designIntakeQuestionDirectives(
+                id,
+                pendingDesignSystemId,
+                images.length,
+              )),
+    ].join("\n");
+
+    clearGenerationCompleteTimer();
+    setGenerationIssue(null);
+    generationModelRef.current = {
+      model: pending.model,
+      engine: pending.engine,
+      effort: pending.effort,
+    };
+    const runTabId = agentSubmit(
+      shouldSkipQuestions
+        ? `Generate design for "${design.title}": ${prompt}`
+        : `Create design: ${prompt}`,
+      context,
+      {
+        model: pending.model,
+        engine: pending.engine,
+        effort: pending.effort,
+        newTab: true,
+        images,
+      },
+    );
+    setGenerationChatTabId(runTabId);
+    patchPendingGeneration(id, {
+      runTabId,
+      attempt: pending.attempt ?? 1,
+      designSystemId: pendingDesignSystemId,
+      startedAt: Date.now(),
+    });
+    setHasPendingGeneration(true);
+  })();
+  return () => {
+    cancelled = true;
+  };
+}

package/corpus/templates/design/app/pages/design-editor/effects/seed-collab-content.ts

@@ -0,0 +1,157 @@
+import type { Dispatch, RefObject, SetStateAction } from "react";
+import * as Y from "yjs";
+
+import { shouldRebaseCollabDocFromStoredContent } from "@/pages/design-editor/collab-sync";
+import { TAB_ID } from "@/pages/design-editor/editor-session";
+import type { PreviewContentReplaceResult } from "@/pages/design-editor/editor-state";
+import { previewContentReplaceNeedsRenderFallback } from "@/pages/design-editor/editor-state";
+import type { DesignFile } from "@/pages/design-editor/types";
+
+export interface SeedCollabContentArgs {
+  activeFile: DesignFile;
+  activeFileId: string | null;
+  collabContentFileIdRef: RefObject<string | null>;
+  isSynced: boolean;
+  lastAppliedFileUpdatedAtRef: RefObject<string | null>;
+  lastLocalContentRef: RefObject<string | null>;
+  latestActiveContentRef: RefObject<string | null>;
+  pendingLocalFileContentsRef: RefObject<
+    Map<
+      string,
+      { content: string; startedAt: number; baseUpdatedAt?: string | null }
+    >
+  >;
+  replacePreviewContent: (
+    nextContent: string,
+    selector?: string | null,
+    options?: { forceFullDocument?: boolean },
+  ) => PreviewContentReplaceResult;
+  setCollabContent: Dispatch<SetStateAction<string | null>>;
+  setCollabContentFileId: Dispatch<SetStateAction<string | null>>;
+  setContentRenderRevision: Dispatch<SetStateAction<number>>;
+  undoManagerRef: RefObject<Y.UndoManager | null>;
+  ydoc: Y.Doc | null;
+}
+
+export function runSeedCollabContent({
+  activeFile,
+  activeFileId,
+  collabContentFileIdRef,
+  isSynced,
+  lastAppliedFileUpdatedAtRef,
+  lastLocalContentRef,
+  latestActiveContentRef,
+  pendingLocalFileContentsRef,
+  replacePreviewContent,
+  setCollabContent,
+  setCollabContentFileId,
+  setContentRenderRevision,
+  undoManagerRef,
+  ydoc,
+}: SeedCollabContentArgs) {
+  if (!ydoc || !isSynced || !activeFileId) return;
+  const fileId = activeFileId;
+  const ytext = ydoc.getText("content");
+  const text = ytext.toString();
+  const pendingLocalContent =
+    pendingLocalFileContentsRef.current.get(fileId)?.content;
+  if (pendingLocalContent && text !== pendingLocalContent) {
+    setCollabContent(pendingLocalContent);
+    setCollabContentFileId(fileId);
+    lastLocalContentRef.current = pendingLocalContent;
+    latestActiveContentRef.current = pendingLocalContent;
+    if (
+      previewContentReplaceNeedsRenderFallback(
+        replacePreviewContent(pendingLocalContent, null, {
+          forceFullDocument: true,
+        }),
+      )
+    ) {
+      setContentRenderRevision((revision) => revision + 1);
+    }
+    // Full delete+insert with an untracked origin: the UndoManager only
+    // tracks LOCAL_EDIT_ORIGIN, so this rewrite is invisible to it. Clear
+    // the undo stack so a subsequent Cmd+Z can't replay a tracked delta
+    // from before this rewrite against content it no longer matches
+    // (see the DE:5135-style mitigation below for the same hazard).
+    undoManagerRef.current?.clear(true, false);
+    ydoc.transact(() => {
+      ytext.delete(0, ytext.length);
+      ytext.insert(0, pendingLocalContent);
+    }, TAB_ID);
+    return;
+  }
+  if (text.length > 0) {
+    const storedContent = activeFile?.content ?? "";
+    // §gesture-persistence — a freshly-connected/just-synced doc snapshot
+    // has no proven watermark yet in this session. Don't let it outrank
+    // SQL merely because it looks like well-formed HTML: rebase from SQL
+    // whenever they differ and no baseline has been established (or the
+    // live text is outright malformed). See
+    // shouldRebaseCollabDocFromStoredContent's doc comment for the full
+    // clobber this closes.
+    if (
+      shouldRebaseCollabDocFromStoredContent({
+        liveContent: text,
+        storedContent,
+        storedUpdatedAt: activeFile?.updatedAt ?? null,
+        lastAppliedUpdatedAt: lastAppliedFileUpdatedAtRef.current,
+        fileType: activeFile?.fileType ?? "html",
+      })
+    ) {
+      setCollabContent(storedContent);
+      setCollabContentFileId(fileId);
+      lastLocalContentRef.current = storedContent;
+      latestActiveContentRef.current = storedContent;
+      if (activeFile?.updatedAt) {
+        lastAppliedFileUpdatedAtRef.current = activeFile.updatedAt;
+      }
+      if (
+        previewContentReplaceNeedsRenderFallback(
+          replacePreviewContent(storedContent, null, {
+            forceFullDocument: true,
+          }),
+        )
+      ) {
+        setContentRenderRevision((revision) => revision + 1);
+      }
+      // Untracked full rewrite — see clear() note above.
+      undoManagerRef.current?.clear(true, false);
+      ydoc.transact(() => {
+        ytext.delete(0, ytext.length);
+        ytext.insert(0, storedContent);
+      }, TAB_ID);
+      return;
+    }
+    // Y.Doc snapshots are a render seed, not the SQL source of truth; the
+    // reconcile effect below advances the updatedAt watermark only after it
+    // confirms or applies the current DB content.
+    //
+    // Item 5 (edit-flash) root cause: this effect's deps include
+    // `activeFile?.content`/`activeFile?.updatedAt`, which change on EVERY
+    // save (useActionMutation's default onSuccess invalidates all
+    // `["action"]` queries, so `get-design` refetches after every single
+    // edit and hands back a new `activeFile` object with a bumped
+    // `updatedAt`). That refire lands here even when the Y.Doc's `text`
+    // hasn't changed at all since the last time this ran — previously this
+    // unconditionally re-adopted `text` and bumped contentRenderRevision on
+    // every such refire, forcing a full srcdoc rebuild after nearly every
+    // commit. Only touch collab/render state when `text` genuinely differs
+    // from what is already reflected.
+    if (
+      text !== latestActiveContentRef.current ||
+      collabContentFileIdRef.current !== fileId
+    ) {
+      setCollabContent(text);
+      setCollabContentFileId(fileId);
+      latestActiveContentRef.current = text;
+      if (
+        previewContentReplaceNeedsRenderFallback(
+          replacePreviewContent(text, null, { forceFullDocument: true }),
+        )
+      ) {
+        setContentRenderRevision((revision) => revision + 1);
+      }
+    }
+  }
+}

package/corpus/templates/design/app/pages/design-editor/preview-html.ts

@@ -0,0 +1,19 @@
+export function externalPreviewUrlForContent(content: string): string | null {
+  const trimmed = content.trim();
+  if (!/^https?:\/\//i.test(trimmed)) return null;
+  try {
+    const url = new URL(trimmed);
+    url.hash = "";
+    return url.toString();
+  } catch {
+    // coercion-ok: a non-parseable string is "not an external URL", which is
+    // exactly what the null return means to every caller here.
+    return null;
+  }
+}
+
+export function fullPreviewHtml(content: string): string {
+  const trimmed = content.trim();
+  if (/<!doctype html|<html[\s>]/i.test(trimmed)) return content;
+  return `<!DOCTYPE html><html><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"></head><body>${content}</body></html>`;
+}

package/corpus/templates/design/app/routes/examples.tsx

@@ -1,7 +1,8 @@
+import { withSsrHtmlContentType } from "@agent-native/core/shared";
 import { redirect } from "react-router";
 
 export function loader() {
-  return redirect("/", 302);
+  return withSsrHtmlContentType(redirect("/", 302));
 }
 
 export default function ExamplesRedirect() {

package/corpus/templates/design/netlify.toml

@@ -13,6 +13,8 @@ AGENT_CHAT_DURABLE_BACKGROUND = "true"
 
 [context.production.environment]
 AGENT_NATIVE_HOSTED_HARNESS = "true"
+AGENT_NATIVE_ENABLE_KEEP_WARM = "1"
+AGENT_NATIVE_DISABLE_KEEP_WARM_BACKGROUND = "1"
 
 # Emit the Netlify background function used by Design's durable agent-chat opt-in.
 # The normal server timeout still protects non-background HTTP handlers.

package/corpus/templates/design/shared/board-file.ts

@@ -678,7 +678,8 @@ export function stripBoardSurfaceOffsetFromCoord(value: number): number {
  * Parent-relative position for a node being reparented INTO a target
  * container, from the two elements' persisted absolute positions in the same
  * coordinate space. This is the pure seam used by
- * `handleOverviewPrimitiveReparent` (DesignEditor.tsx).
+ * `handleOverviewPrimitiveReparent`
+ * (app/pages/design-editor/commands/overview-primitive-reparent.ts).
  *
  * The flat subtraction below is only correct when both `source` and `target`
  * are already expressed in the SAME coordinate space — historically that

package/corpus/templates/dispatch/netlify.toml

@@ -15,6 +15,8 @@ AGENT_CHAT_DURABLE_BACKGROUND = "true"
 
 [context.production.environment]
 AGENT_NATIVE_HOSTED_HARNESS = "true"
+AGENT_NATIVE_ENABLE_KEEP_WARM = "1"
+AGENT_NATIVE_DISABLE_KEEP_WARM_BACKGROUND = "1"
 
 # A2A delegation calls run a full agent loop (LLM + tool calls + DB queries).
 # The framework does not impose a default agent-run timeout; if a template sets

package/corpus/templates/forms/app/routes/_index.tsx

@@ -1,4 +1,5 @@
 import { DefaultSpinner } from "@agent-native/core/client/ui";
+import { withSsrHtmlContentType } from "@agent-native/core/shared";
 import { redirect, type LoaderFunctionArgs } from "react-router";
 
 import messages from "@/i18n/en-US";
@@ -11,11 +12,11 @@ function target(url: URL): string {
 }
 
 export function loader({ url }: LoaderFunctionArgs) {
-  throw redirect(target(url));
+  throw withSsrHtmlContentType(redirect(target(url)), { varyByQuery: true });
 }
 
 export function clientLoader({ url }: LoaderFunctionArgs) {
-  throw redirect(target(url));
+  throw withSsrHtmlContentType(redirect(target(url)), { varyByQuery: true });
 }
 
 export function meta() {

package/corpus/templates/forms/netlify.toml

@@ -12,6 +12,8 @@ NPM_CONFIG_PRODUCTION = "false"
 
 [context.production.environment]
 AGENT_NATIVE_HOSTED_HARNESS = "true"
+AGENT_NATIVE_ENABLE_KEEP_WARM = "1"
+AGENT_NATIVE_DISABLE_KEEP_WARM_BACKGROUND = "1"
 
 # A2A delegation calls run a full agent loop (LLM + tool calls + DB queries).
 # The framework does not impose a default agent-run timeout; if a template sets