@agent-native/core-corpus 0.209.2 → 0.209.3-nightly-20261016183441

package/corpus/templates/design/app/pages/design-editor/clone-and-pen-edit.ts

@@ -756,6 +756,17 @@ function setRootLayerPosition(
     return false;
   }
   if (position.positionMode === "relative") {
+    host.style.removeProperty("inset");
+    [
+      ["inset-inline", "auto"],
+      ["inset-inline-start", "auto"],
+      ["inset-inline-end", "auto"],
+      ["inset-block", "auto"],
+      ["inset-block-start", "auto"],
+      ["inset-block-end", "auto"],
+      ["right", "auto"],
+      ["bottom", "auto"],
+    ].forEach(([property, value]) => host.style.setProperty(property!, value!));
     host.style.position = "relative";
   } else {
     host.style.removeProperty("inset");

package/corpus/templates/design/app/pages/design-editor/command-types.ts

@@ -7,6 +7,7 @@ import type {
 } from "@/components/design/types";
 import type { UploadedFile } from "@/components/editor/PromptDialog";
 import type { DesignClipboardManagedStyleSnapshot } from "@/lib/design-clipboard-managed-styles";
+import type { RelativePositionOffset } from "@/lib/design-import";
 
 import type { PendingLiveStructureEdit } from "./pending-edits";
 
@@ -74,6 +75,7 @@ export interface CanvasLayerClipboardEntry {
   rootNodeId?: string;
   sourceParentNodeId?: string;
   sourceFileId: string;
+  sourceRelativeOffset?: RelativePositionOffset | null;
   portableStyleSnapshot?: PortableStyleSnapshot;
   styleSnapshotCaptureFailed?: boolean;
   managedStyleSnapshot?: DesignClipboardManagedStyleSnapshot;

package/corpus/templates/design/app/pages/design-editor/commands/copy-selection.ts

@@ -113,6 +113,9 @@ export async function runCopySelection({
     rootNodeId: snapshot.rootNodeId,
     sourceParentNodeId: snapshot.sourceParentNodeId,
     sourceFileId: snapshot.sourceFileId,
+    ...(snapshot.sourceRelativeOffset !== undefined
+      ? { sourceRelativeOffset: snapshot.sourceRelativeOffset }
+      : {}),
     ...portableStylesForClipboard(snapshot, readPortableStyleSnapshot),
     managedStyleSnapshot: snapshot.managedStyleSnapshot,
   }));

package/corpus/templates/design/app/pages/design-editor/commands/get-selected-layer-snapshots.ts

@@ -21,6 +21,7 @@ import type {
 } from "@/pages/design-editor/command-types";
 import type { OverviewScreen } from "@/pages/design-editor/derive/overview-screens";
 import { shouldUseRuntimeLayerProjection } from "@/pages/design-editor/pending-edits";
+import { effectiveRelativePositionOffset } from "@/pages/design-editor/relative-position-offset";
 import type { DesignFile } from "@/pages/design-editor/types";
 
 function getSourceParentNodeId(
@@ -134,11 +135,21 @@ export function runGetSelectedLayerSnapshots({
         : undefined;
       const styleSnapshotCaptureFailed =
         selectedInfo?.styleSnapshotCaptureFailed ? true : undefined;
+      const sourceRelativeOffset =
+        selectedInfo?.computedStyles?.position === "relative"
+          ? effectiveRelativePositionOffset(
+              selectedInfo.computedStyles,
+              selectedInfo.relativeContainingBlockDirection,
+            )
+          : undefined;
       snapshots.push({
         html,
         rootNodeId: node.dataAttributes["data-agent-native-node-id"] ?? node.id,
         sourceParentNodeId: getSourceParentNodeId(projection, node),
         sourceFileId: file.id,
+        ...(selectedInfo?.computedStyles?.position === "relative"
+          ? { sourceRelativeOffset }
+          : {}),
         portableStyleSnapshot,
         styleSnapshotCaptureFailed,
         managedStyleSnapshot: extractDesignClipboardManagedStyles(
@@ -190,6 +201,14 @@ export function runGetSelectedLayerSnapshots({
           selectedElement.id,
         sourceParentNodeId: getSourceParentNodeId(projection, node),
         sourceFileId: activeFile.id,
+        ...(selectedElement.computedStyles?.position === "relative"
+          ? {
+              sourceRelativeOffset: effectiveRelativePositionOffset(
+                selectedElement.computedStyles,
+                selectedElement.relativeContainingBlockDirection,
+              ),
+            }
+          : {}),
         portableStyleSnapshot: selectedElement.portableStyleSnapshot,
         styleSnapshotCaptureFailed: selectedElement.styleSnapshotCaptureFailed,
         managedStyleSnapshot: extractDesignClipboardManagedStyles(

package/corpus/templates/design/app/pages/design-editor/commands/paste-selection.ts

@@ -19,7 +19,10 @@ import type {
   ClipboardContentMutationPublication,
 } from "@/lib/clipboard-content-lineage";
 import type { DesignClipboardManagedStyleSnapshot } from "@/lib/design-clipboard-managed-styles";
-import type { DesignClipboardScreenEntry } from "@/lib/design-import";
+import type {
+  DesignClipboardScreenEntry,
+  RelativePositionOffset,
+} from "@/lib/design-import";
 import {
   extractLayerPosition,
   insertClonedHtmlLayers,
@@ -55,6 +58,7 @@ import {
   resolvePastePlacementForSelection,
   resolvePasteSourceAnchor,
 } from "@/pages/design-editor/paste-placement";
+import { effectiveRelativePositionOffset } from "@/pages/design-editor/relative-position-offset";
 import type { DesignFile } from "@/pages/design-editor/types";
 
 import type { ApplyLinkedComponentEdit } from "./linked-component-structure";
@@ -212,7 +216,11 @@ function cloneLayerPositionForRepeat(
 function clipboardRepeatLayerLayout(args: {
   position?: string;
   left?: string;
+  right?: string;
   top?: string;
+  bottom?: string;
+  parentDirection?: string;
+  relativeOffset?: RelativePositionOffset | null;
   unknownPosition?: boolean;
 }): ClipboardRepeatLayerLayout {
   const position = args.position?.trim().toLowerCase();
@@ -223,11 +231,26 @@ function clipboardRepeatLayerLayout(args: {
       : { kind: "unavailable" };
   }
   if (position === "relative") {
+    const hasSourceOffset = Object.prototype.hasOwnProperty.call(
+      args,
+      "relativeOffset",
+    );
+    const relativeOffset = hasSourceOffset
+      ? args.relativeOffset
+      : effectiveRelativePositionOffset(
+          {
+            left: args.left,
+            right: args.right,
+            top: args.top,
+            bottom: args.bottom,
+          },
+          args.parentDirection,
+        );
     return {
       kind: "flow",
-      position: isPixelPosition(args.left, args.top),
+      position: relativeOffset ?? null,
       positionMode: "relative",
-      unknownPosition: false,
+      unknownPosition: relativeOffset === null,
     };
   }
   return {
@@ -254,15 +277,41 @@ function clipboardRepeatSourceLayout(
     const snapshotStyles = entry.portableStyleSnapshot?.nodes.find(
       (node) => node.path.length === 0,
     )?.styles;
-    const position =
-      root.style.getPropertyValue("position") || snapshotStyles?.position;
+    const hasRelativeOffsetMetadata = Object.prototype.hasOwnProperty.call(
+      entry,
+      "sourceRelativeOffset",
+    );
+    const position = hasRelativeOffsetMetadata
+      ? "relative"
+      : root.style.getPropertyValue("position") || snapshotStyles?.position;
     const left = root.style.left || snapshotStyles?.left;
+    const right = root.style.right || snapshotStyles?.right;
     const top = root.style.top || snapshotStyles?.top;
+    const bottom = root.style.bottom || snapshotStyles?.bottom;
     const unknownPosition = !position;
+    const hasRelativeShorthand = [
+      "inset",
+      "inset-block",
+      "inset-block-end",
+      "inset-block-start",
+      "inset-inline",
+      "inset-inline-end",
+      "inset-inline-start",
+    ].some(
+      (property) =>
+        root.style.getPropertyValue(property) || snapshotStyles?.[property],
+    );
     return clipboardRepeatLayerLayout({
       position,
       left,
+      right,
       top,
+      bottom,
+      ...(hasRelativeOffsetMetadata
+        ? { relativeOffset: entry.sourceRelativeOffset }
+        : hasRelativeShorthand
+          ? { relativeOffset: null }
+          : {}),
       unknownPosition,
     });
   } catch {
@@ -273,7 +322,20 @@ function clipboardRepeatSourceLayout(
 function clipboardRepeatSelectedCloneLayout(args: {
   html?: string;
   inlineStyles?: Record<string, string>;
+  computedStyles?: Record<string, string>;
+  parentDirection?: string;
 }): ClipboardRepeatLayerLayout {
+  if (args.computedStyles?.position) {
+    return clipboardRepeatLayerLayout({
+      position: args.computedStyles.position,
+      left: args.computedStyles.left,
+      right: args.computedStyles.right,
+      top: args.computedStyles.top,
+      bottom: args.computedStyles.bottom,
+      parentDirection: args.parentDirection,
+      unknownPosition: false,
+    });
+  }
   if (args.html !== undefined) {
     if (typeof window === "undefined") return { kind: "unavailable" };
     try {
@@ -287,7 +349,9 @@ function clipboardRepeatSelectedCloneLayout(args: {
       return clipboardRepeatLayerLayout({
         position: root.style.position,
         left: root.style.left,
+        right: root.style.right,
         top: root.style.top,
+        bottom: root.style.bottom,
         unknownPosition: !root.style.position,
       });
     } catch {
@@ -297,7 +361,10 @@ function clipboardRepeatSelectedCloneLayout(args: {
   return clipboardRepeatLayerLayout({
     position: args.inlineStyles?.position,
     left: args.inlineStyles?.left,
+    right: args.inlineStyles?.right,
     top: args.inlineStyles?.top,
+    bottom: args.inlineStyles?.bottom,
+    parentDirection: args.parentDirection,
   });
 }
 
@@ -312,7 +379,10 @@ function positionsFromSelectedClipboardClone(
   }
   if (
     sourceLayouts.some((layout) => layout.kind === "unavailable") ||
-    selectedCloneLayout.kind === "unavailable"
+    selectedCloneLayout.kind === "unavailable" ||
+    (selectedCloneLayout.kind === "flow" &&
+      selectedCloneLayout.positionMode === "relative" &&
+      selectedCloneLayout.unknownPosition)
   ) {
     return null;
   }
@@ -320,16 +390,36 @@ function positionsFromSelectedClipboardClone(
     layout.kind === "unavailable" ? null : layout.position,
   );
   const hasSourcePosition = sourcePositions.some(Boolean);
+  if (
+    sourceLayouts.some(
+      (layout) =>
+        layout.kind === "flow" &&
+        layout.positionMode === "relative" &&
+        layout.unknownPosition,
+    )
+  ) {
+    return null;
+  }
   const unknownPositionInMixedRoots =
     hasSourcePosition &&
     sourceLayouts.some(
-      (layout) => layout.kind === "flow" && layout.unknownPosition,
+      (layout) =>
+        layout.kind === "flow" &&
+        layout.positionMode !== "relative" &&
+        layout.unknownPosition,
     );
   if (unknownPositionInMixedRoots) return null;
   const naturalFlowRoots = sourceLayouts.map(
     (layout) => layout.kind === "flow",
   );
-  if (naturalFlowRoots.every(Boolean) && selectedCloneLayout.kind === "flow") {
+  const allUnpositionedFlowRoots = sourceLayouts.every(
+    (layout) => layout.kind === "flow" && layout.positionMode !== "relative",
+  );
+  if (
+    allUnpositionedFlowRoots &&
+    naturalFlowRoots.every(Boolean) &&
+    selectedCloneLayout.kind === "flow"
+  ) {
     return undefined;
   }
   const selectedClonePosition = selectedCloneLayout.position;
@@ -466,13 +556,7 @@ function positionsFromSource(
   cascadeOffset = 0,
 ) {
   if (cascadeOffset === 0) return undefined;
-  if (
-    sourceLayouts.some(
-      (layout) =>
-        layout.kind === "unavailable" ||
-        (layout.kind === "flow" && layout.unknownPosition),
-    )
-  ) {
+  if (sourceLayouts.some((layout) => layout.kind === "unavailable")) {
     return undefined;
   }
   return sourceLayouts.map((layout) =>
@@ -821,6 +905,7 @@ export async function runPasteSelection(
     const sourceParentAnchor = sourceParentNodeId
       ? { selector: "", sourceId: sourceParentNodeId }
       : null;
+    const sourceLayouts = entries.map(clipboardRepeatSourceLayout);
     const sourcePositions = entries.map((entry) =>
       extractLayerPosition(entry.html),
     );
@@ -865,20 +950,19 @@ export async function runPasteSelection(
     const selectedCloneLayout = selectedPastedLayer
       ? clipboardRepeatSelectedCloneLayout({
           inlineStyles: selectedElement?.inlineStyles,
+          computedStyles: selectedElement?.computedStyles,
+          parentDirection: selectedElement?.relativeContainingBlockDirection,
         })
       : null;
     const selectedSourcePositions = selectedPastedLayer
       ? positionsFromSelectedClipboardClone(
-          entries.map(clipboardRepeatSourceLayout),
+          sourceLayouts,
           selectedPastedLayer.entryIndex,
           selectedCloneLayout ?? { kind: "unavailable" },
           cascadeOffset,
         )
       : directlyCopiedAnchor
-        ? positionsFromSource(
-            entries.map(clipboardRepeatSourceLayout),
-            cascadeOffset,
-          )
+        ? positionsFromSource(sourceLayouts, cascadeOffset)
         : undefined;
     if (selectedSourcePositions === null) {
       toast.error(t("designEditor.toasts.layerMoveFailed"), {
@@ -903,6 +987,10 @@ export async function runPasteSelection(
                   space: "visual" as const,
                 };
           }
+          const layout = sourceLayouts[index];
+          if (layout?.kind === "flow" && layout.positionMode === "relative") {
+            return undefined;
+          }
           return source
             ? {
                 x: source.x + cascadeOffset,
@@ -1162,10 +1250,15 @@ export async function runPasteSelection(
               selectedNode.source.start,
               selectedNode.source.end,
             ),
+            computedStyles: selectedElement?.computedStyles,
+            parentDirection: selectedElement?.relativeContainingBlockDirection,
           })
         : selectedPastedLayer
           ? clipboardRepeatSelectedCloneLayout({
               inlineStyles: selectedElement?.inlineStyles,
+              computedStyles: selectedElement?.computedStyles,
+              parentDirection:
+                selectedElement?.relativeContainingBlockDirection,
             })
           : null;
     const selectedSourcePositions = selectedClipboardRoot
@@ -1234,6 +1327,7 @@ export async function runPasteSelection(
   const sourcePositions = entries.map((entry) =>
     extractLayerPosition(entry.html),
   );
+  const sourceLayouts = entries.map(clipboardRepeatSourceLayout);
   const positionedSources = sourcePositions.filter(
     (source): source is { x: number; y: number } => Boolean(source),
   );
@@ -1316,6 +1410,10 @@ export async function runPasteSelection(
             space: "visual" as const,
           };
     }
+    const layout = sourceLayouts[index];
+    if (layout?.kind === "flow" && layout.positionMode === "relative") {
+      return undefined;
+    }
     if (rootFallbackPlacement) {
       return {
         x: ORPHANED_PASTE_INSET + cascadeOffset + index * 16,

package/corpus/templates/design/app/pages/design-editor/domains/use-editor-layer-actions.ts

@@ -54,6 +54,7 @@ import {
   measurePositionCoordinateContext,
   positionCoordinateRenderOffsetForWindow,
 } from "../position-coordinate-context";
+import { readRelativePositionStyles } from "../relative-position-offset";
 import {
   isScreenRootElementInfo,
   resolveMarqueeAdditive,
@@ -93,7 +94,9 @@ function readRenderedLayerInfo(
         preferredCodeLayerSelector(owner.node),
       );
       if (!element) continue;
-      const computed = preview.getComputedStyle(element);
+      const relativePosition = readRelativePositionStyles(element, (target) =>
+        preview.getComputedStyle(target),
+      );
       const parent = element.parentElement;
       const renderOffset = positionCoordinateRenderOffsetForWindow(preview);
       if (!renderOffset) continue;
@@ -115,9 +118,10 @@ function readRenderedLayerInfo(
         sourceLayerIdentity: { screenId: owner.fileId, nodeId: owner.node.id },
         computedStyles: {
           ...base.computedStyles,
-          position: computed.position,
-          zIndex: computed.zIndex,
+          ...relativePosition.computedStyles,
         },
+        relativeContainingBlockDirection:
+          relativePosition.relativeContainingBlockDirection,
         boundingRect: {
           x: rect.x + scrollX,
           y: rect.y + scrollY,
@@ -971,9 +975,17 @@ export function useEditorLayerActions({
               measured.positionContainingBlockOrigin,
             positionContainingBlockTransform:
               measured.positionContainingBlockTransform,
+            relativeContainingBlockDirection:
+              measured.relativeContainingBlockDirection,
             computedStyles: {
               ...measured.computedStyles,
               ...current.computedStyles,
+              position: measured.computedStyles.position,
+              left: measured.computedStyles.left,
+              right: measured.computedStyles.right,
+              top: measured.computedStyles.top,
+              bottom: measured.computedStyles.bottom,
+              zIndex: measured.computedStyles.zIndex,
             },
           };
           return samePlainData(merged, current) ? current : merged;

package/corpus/templates/design/app/pages/design-editor/relative-position-offset.ts

@@ -0,0 +1,109 @@
+import { relativePositionContainingBlockDirection } from "@shared/relative-position-containing-block";
+
+import type { RelativePositionOffset } from "@/lib/design-import";
+
+type PositionStyle = Pick<
+  CSSStyleDeclaration,
+  | "position"
+  | "left"
+  | "right"
+  | "top"
+  | "bottom"
+  | "zIndex"
+  | "display"
+  | "direction"
+>;
+
+export function readRelativePositionStyles<
+  T extends { parentElement: T | null },
+>(
+  element: T,
+  getComputedStyle: (element: T) => PositionStyle,
+): {
+  computedStyles: Pick<
+    Record<string, string>,
+    "position" | "left" | "right" | "top" | "bottom" | "zIndex"
+  >;
+  relativeContainingBlockDirection?: "ltr" | "rtl";
+} {
+  const computed = getComputedStyle(element);
+  const direction =
+    computed.position === "relative"
+      ? relativePositionContainingBlockDirection(element, getComputedStyle)
+      : undefined;
+  return {
+    computedStyles: {
+      position: computed.position,
+      left: computed.left,
+      right: computed.right,
+      top: computed.top,
+      bottom: computed.bottom,
+      zIndex: computed.zIndex,
+    },
+    ...(computed.position === "relative"
+      ? { relativeContainingBlockDirection: direction }
+      : {}),
+  };
+}
+
+type RelativeInsetValues = {
+  left?: string;
+  right?: string;
+  top?: string;
+  bottom?: string;
+};
+
+type ParsedInset =
+  | { kind: "auto" }
+  | { kind: "missing" }
+  | { kind: "value"; value: number }
+  | null;
+
+function parsePixelInset(value: string | undefined): ParsedInset {
+  if (value === undefined) return { kind: "missing" };
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "auto" || normalized === "") {
+    return { kind: "auto" };
+  }
+  const match = normalized.match(/^([+-]?(?:\d+\.?\d*|\.\d+))(px)?$/);
+  if (!match) return null;
+  const parsed = Number(match[1]);
+  if (!match[2] && parsed !== 0) return null;
+  return Number.isFinite(parsed) ? { kind: "value", value: parsed } : null;
+}
+
+function resolveAxis(
+  startInset: string | undefined,
+  endInset: string | undefined,
+  startSign: 1 | -1,
+  endSign: 1 | -1,
+  direction?: string,
+): number | null {
+  const start = parsePixelInset(startInset);
+  const end = parsePixelInset(endInset);
+  if (!start || !end) return null;
+  if (
+    (start.kind === "missing" && end.kind !== "value") ||
+    (end.kind === "missing" && start.kind !== "value")
+  ) {
+    return null;
+  }
+  if (start.kind === "value" && end.kind === "value") {
+    if (direction !== "ltr" && direction !== "rtl") return null;
+    const useEnd = startSign === 1 && direction === "rtl";
+    return useEnd ? end.value * endSign : start.value * startSign;
+  }
+  if (start.kind === "value") return start.value * startSign;
+  if (end.kind === "value") return end.value * endSign;
+  return 0;
+}
+
+export function effectiveRelativePositionOffset(
+  insets: RelativeInsetValues,
+  parentDirection?: string,
+): RelativePositionOffset | null {
+  const x = resolveAxis(insets.left, insets.right, 1, -1, parentDirection);
+  const y = resolveAxis(insets.top, insets.bottom, 1, -1, "ltr");
+  if (x === null || y === null) return null;
+  return { x, y };
+}

package/corpus/templates/design/changelog/2026-10-15-dragged-layers-use-the-final-release-position.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-10-15
+---
+
+Dragged layers use the final pointer release position even when it differs from the last move event, and keep that position after saving and reloading.

package/corpus/templates/design/changelog/2026-10-15-repeated-pastes-preserve-relative-layer-offsets.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-10-15
+---
+
+Repeated pastes preserve relative layer offsets in right-to-left layouts and across Screens.

package/corpus/templates/design/changelog/2026-10-15-text-wrapping-hug-widths.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-10-15
+---
+
+Text layers retain their individual widths when wrapped in auto layout.

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

@@ -8616,7 +8616,8 @@ function applyWrapNodes(
     return frag;
   });
 
-  const autoLayoutStyle = "display: flex; flex-direction: column; gap: 8px";
+  const autoLayoutStyle =
+    "display: flex; flex-direction: column; align-items: flex-start; gap: 8px";
   const autoLayoutOrigin = autoLayout
     ? (targetGeometry ?? computeAbsoluteUnionOrigin(targetElements))
     : null;

package/corpus/templates/design/shared/relative-position-containing-block.ts

@@ -0,0 +1,40 @@
+type ElementWithParent<T> = {
+  parentElement: T | null;
+};
+
+type DisplayDirectionStyle = Pick<CSSStyleDeclaration, "display" | "direction">;
+
+export function relativePositionContainingBlockDirection<
+  T extends ElementWithParent<T>,
+>(
+  element: T,
+  getComputedStyle: (element: T) => DisplayDirectionStyle,
+): "ltr" | "rtl" | undefined {
+  let ancestor = element.parentElement;
+  while (ancestor) {
+    const styles = getComputedStyle(ancestor);
+    const display = styles.display;
+    if (display === "inline" || display === "contents") {
+      ancestor = ancestor.parentElement;
+      continue;
+    }
+    if (
+      display === "block" ||
+      display === "flow-root" ||
+      display === "list-item" ||
+      display === "inline-block" ||
+      display === "flex" ||
+      display === "inline-flex" ||
+      display === "grid" ||
+      display === "inline-grid" ||
+      display === "table-cell" ||
+      display === "table-caption"
+    ) {
+      return styles.direction === "ltr" || styles.direction === "rtl"
+        ? styles.direction
+        : undefined;
+    }
+    return undefined;
+  }
+  return undefined;
+}

package/corpus/templates/dispatch/.deploy-tmp/agent-native-provided-plugins.mjs

@@ -0,0 +1,10 @@
+// AUTO-GENERATED by @agent-native/core deploy build
+import { markDefaultPluginProvided } from "@agent-native/core/server/edge";
+
+const pluginStems = ["agent-chat","auth","core-routes","db","feature-flags","identity-sso","integrations","org-apps-directory","otel","setup-dispatch"];
+
+export default function markBuildDiscoveredPlugins(nitroApp) {
+  for (const stem of pluginStems) {
+    markDefaultPluginProvided(nitroApp, stem);
+  }
+}

package/corpus/templates/forms/.deploy-tmp/agent-native-provided-plugins.mjs

@@ -0,0 +1,10 @@
+// AUTO-GENERATED by @agent-native/core deploy build
+import { markDefaultPluginProvided } from "@agent-native/core/server/edge";
+
+const pluginStems = ["agent-chat","auth","core-routes","db","otel","transactional-emails"];
+
+export default function markBuildDiscoveredPlugins(nitroApp) {
+  for (const stem of pluginStems) {
+    markDefaultPluginProvided(nitroApp, stem);
+  }
+}

package/corpus/templates/mail/.deploy-tmp/agent-native-provided-plugins.mjs

@@ -0,0 +1,10 @@
+// AUTO-GENERATED by @agent-native/core deploy build
+import { markDefaultPluginProvided } from "@agent-native/core/server/edge";
+
+const pluginStems = ["agent-chat","auth","core-routes","db","integrations","mail-jobs","oauth-refresh","otel"];
+
+export default function markBuildDiscoveredPlugins(nitroApp) {
+  for (const stem of pluginStems) {
+    markDefaultPluginProvided(nitroApp, stem);
+  }
+}

package/corpus/templates/plan/.deploy-tmp/agent-native-provided-plugins.mjs

@@ -0,0 +1,10 @@
+// AUTO-GENERATED by @agent-native/core deploy build
+import { markDefaultPluginProvided } from "@agent-native/core/server/edge";
+
+const pluginStems = ["00-mcp","agent-chat","auth","collab","core-routes","db","labs","otel","plan-assets","transactional-emails"];
+
+export default function markBuildDiscoveredPlugins(nitroApp) {
+  for (const stem of pluginStems) {
+    markDefaultPluginProvided(nitroApp, stem);
+  }
+}

package/corpus/templates/slides/.deploy-tmp/agent-native-provided-plugins.mjs

@@ -0,0 +1,10 @@
+// AUTO-GENERATED by @agent-native/core deploy build
+import { markDefaultPluginProvided } from "@agent-native/core/server/edge";
+
+const pluginStems = ["_dev-upload-stub","agent-chat","auth","collab","config","core-routes","creative-context","db","feature-flags","labs","otel","transactional-emails"];
+
+export default function markBuildDiscoveredPlugins(nitroApp) {
+  for (const stem of pluginStems) {
+    markDefaultPluginProvided(nitroApp, stem);
+  }
+}