@agent-native/core 0.90.2 → 0.90.4

package/corpus/templates/clips/server/routes/api/uploads/[recordingId]/chunk.post.ts

@@ -596,7 +596,15 @@ export default defineEventHandler(async (event: H3Event) => {
             updatedAt: new Date().toISOString(),
           })
           .where(eq(schema.recordings.id, recordingId));
+        const failedUploadStateRaw = await readAppState(
+          `recording-upload-${recordingId}`,
+        ).catch(() => null);
+        const failedUploadState =
+          failedUploadStateRaw && typeof failedUploadStateRaw === "object"
+            ? (failedUploadStateRaw as Record<string, unknown>)
+            : {};
         await writeAppState(`recording-upload-${recordingId}`, {
+          ...failedUploadState,
           recordingId,
           status: "failed",
           failureReason: err instanceof Error ? err.message : "Finalize failed",

package/corpus/templates/clips/server/routes/api/video/[recordingId].get.ts

@@ -177,13 +177,13 @@ function rememberCompressedBuilderMediaMiss(compressedSourceUrl: string): void {
 function shouldFallbackToOriginalMedia(
   upstream: Response | { error: string; status: number },
 ): boolean {
-  return [403, 404, 416].includes(upstream.status);
+  return upstream.status >= 500 || [403, 404, 416].includes(upstream.status);
 }
 
 function shouldRememberCompressedBuilderMediaMiss(
   upstream: Response | { error: string; status: number },
 ): boolean {
-  return [403, 404].includes(upstream.status);
+  return upstream.status >= 500 || [403, 404].includes(upstream.status);
 }
 
 async function fetchProviderMedia(
@@ -497,10 +497,17 @@ export default defineEventHandler(async (event: H3Event) => {
             compressedSourceUrl &&
             !shouldSkipCompressedBuilderMediaProbe(compressedSourceUrl)
           ) {
-            upstream = await fetchProviderMedia(
-              compressedSourceUrl,
-              rangeHeader,
-            );
+            try {
+              upstream = await fetchProviderMedia(
+                compressedSourceUrl,
+                rangeHeader,
+              );
+            } catch (err) {
+              upstream = {
+                status: statusCodeForProviderFetchError(err),
+                error: messageForProviderFetchError(err),
+              };
+            }
             if (shouldRememberCompressedBuilderMediaMiss(upstream)) {
               rememberCompressedBuilderMediaMiss(compressedSourceUrl);
             }

package/corpus/templates/clips/shared/clips-ai-prefs.ts

@@ -0,0 +1,81 @@
+/**
+ * Clips user preferences that affect AI video tools.
+ *
+ * Stored under the shared `clips-user-prefs` user-setting key so Settings and
+ * the AI tools popover both read/write the same object.
+ */
+
+export const CLIPS_USER_PREFS_KEY = "clips-user-prefs";
+
+/**
+ * Preferred chat model when Include full video is on. Full-recording video
+ * input only works with Gemini (Builder Gemini or Google/Gemini BYOK) —
+ * Claude and OpenAI cannot ingest the MP4/WebM.
+ */
+export const CLIPS_FULL_VIDEO_AI_ENGINE = "builder";
+export const CLIPS_FULL_VIDEO_AI_MODEL = "gemini-3-5-flash";
+
+export type ClipsAiPrefs = {
+  /**
+   * When true, Clips AI tools (default title/description, regenerate title/
+   * description/chapters, workflows) must watch the full recording — not just
+   * the transcript — before writing results. Off by default for cost/latency.
+   * Sending the full video requires a Gemini model.
+   */
+  includeFullVideoInAi?: boolean;
+};
+
+export type ClipsUserPrefs = ClipsAiPrefs & {
+  defaultPlaybackSpeed?: string;
+  emailNotifications?: boolean;
+  displayName?: string;
+  transcriptCleanupEnabled?: boolean;
+};
+
+export function isIncludeFullVideoInAiEnabled(
+  prefs: ClipsAiPrefs | Record<string, unknown> | null | undefined,
+): boolean {
+  return prefs?.includeFullVideoInAi === true;
+}
+
+/**
+ * Extra agent instructions when the user wants AI tools to watch the clip,
+ * not just read the audio transcript. Full-video understanding requires Gemini.
+ */
+export function buildFullVideoAiInstructions(recordingId: string): string {
+  return (
+    `The user enabled "Include full video" for Clips AI. Do NOT rely on the ` +
+    `transcript alone — audio is often incomplete for accurate titles, ` +
+    `descriptions, chapters, and workflow docs. ` +
+    `IMPORTANT: sending / understanding the full recording only works with ` +
+    `Gemini (Builder Gemini or a Google Gemini key). Use a Gemini model for ` +
+    `this turn — Claude and OpenAI cannot ingest the full video file. ` +
+    `Prefer attaching or uploading the recording video itself to Gemini when ` +
+    `available. Otherwise use \`get-recording-player-data --recordingId=${recordingId}\` ` +
+    `(preferred in-app) or \`create-recording-agent-link --recordingId=${recordingId}\` ` +
+    `and fetch that context URL, then sample the timeline via recommendedFrames / ` +
+    `the frame API. Combine on-screen UI text, product names, and visual context ` +
+    `with any transcript. If the transcript is thin or missing, lean harder on ` +
+    `the video.`
+  );
+}
+
+export function withFullVideoAiInstructions(
+  message: string,
+  recordingId: string,
+  includeFullVideo: boolean,
+): string {
+  if (!includeFullVideo) return message;
+  return `${message} ${buildFullVideoAiInstructions(recordingId)}`;
+}
+
+/** Model selection for sendToAgentChat when Include full video is enabled. */
+export function fullVideoAiModelSelection(): {
+  engine: string;
+  model: string;
+} {
+  return {
+    engine: CLIPS_FULL_VIDEO_AI_ENGINE,
+    model: CLIPS_FULL_VIDEO_AI_MODEL,
+  };
+}

package/corpus/templates/clips/shared/finalize-recovery.ts

@@ -48,6 +48,18 @@ function sleep(ms: number, signal?: AbortSignal): Promise<void> {
   });
 }
 
+export function isStoredButUnservableFinalizeError(value: unknown): boolean {
+  const message =
+    typeof value === "string"
+      ? value
+      : value instanceof Error
+        ? value.message
+        : value && typeof value === "object" && "message" in value
+          ? String((value as { message?: unknown }).message ?? "")
+          : "";
+  return /\bstored-but-unservable\b/i.test(message);
+}
+
 function absoluteUploadUrl(uploadUrl: string): URL {
   if (/^[a-z][a-z0-9+.-]*:/i.test(uploadUrl)) return new URL(uploadUrl);
   const origin =

package/corpus/templates/content/actions/delete-document.ts

@@ -1,78 +1,363 @@
 import { defineAction } from "@agent-native/core";
 import { writeAppState } from "@agent-native/core/application-state";
 import { assertAccess } from "@agent-native/core/sharing";
-import { and, eq } from "drizzle-orm";
+import { and, eq, inArray } from "drizzle-orm";
 import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
-import { deleteDatabaseDataForDocument } from "./_database-utils.js";
 import {
   deleteLocalFileDocument,
   isLocalDocumentId,
   isContentLocalFileMode,
 } from "./_local-file-documents.js";
 
-export async function deleteDocumentRecursive(
+const DELETE_BATCH_SIZE = 90;
+
+function chunks<T>(items: T[], size = DELETE_BATCH_SIZE): T[][] {
+  const out: T[][] = [];
+  for (let index = 0; index < items.length; index += size) {
+    out.push(items.slice(index, index + size));
+  }
+  return out;
+}
+
+async function selectDocumentChildren(
   db: ReturnType<typeof getDb>,
-  id: string,
+  parentIds: string[],
   ownerEmail: string,
-): Promise<string[]> {
-  const children = await db
-    .select({ id: schema.documents.id })
-    .from(schema.documents)
-    .where(
-      and(
-        eq(schema.documents.parentId, id),
-        eq(schema.documents.ownerEmail, ownerEmail),
-      ),
+) {
+  const rows: Array<{ id: string }> = [];
+  for (const batch of chunks(parentIds)) {
+    rows.push(
+      ...(await db
+        .select({ id: schema.documents.id })
+        .from(schema.documents)
+        .where(
+          and(
+            inArray(schema.documents.parentId, batch),
+            eq(schema.documents.ownerEmail, ownerEmail),
+          ),
+        )),
     );
+  }
+  return rows;
+}
 
-  const deleted: string[] = [];
-  for (const child of children) {
-    deleted.push(...(await deleteDocumentRecursive(db, child.id, ownerEmail)));
+async function selectOwnedDatabaseIds(
+  db: ReturnType<typeof getDb>,
+  documentIds: string[],
+  ownerEmail: string,
+) {
+  const rows: Array<{ id: string }> = [];
+  for (const batch of chunks(documentIds)) {
+    rows.push(
+      ...(await db
+        .select({ id: schema.contentDatabases.id })
+        .from(schema.contentDatabases)
+        .where(
+          and(
+            inArray(schema.contentDatabases.documentId, batch),
+            eq(schema.contentDatabases.ownerEmail, ownerEmail),
+          ),
+        )),
+    );
   }
+  return rows;
+}
 
-  // Delete database membership/schema, sync links, versions, shares, then document.
-  await deleteDatabaseDataForDocument(id, ownerEmail, db);
-  await db
-    .delete(schema.documentSyncLinks)
-    .where(
-      and(
-        eq(schema.documentSyncLinks.documentId, id),
-        eq(schema.documentSyncLinks.ownerEmail, ownerEmail),
-      ),
+async function selectDatabaseItemDocuments(
+  db: ReturnType<typeof getDb>,
+  databaseIds: string[],
+  ownerEmail: string,
+) {
+  const rows: Array<{ documentId: string }> = [];
+  for (const batch of chunks(databaseIds)) {
+    rows.push(
+      ...(await db
+        .select({ documentId: schema.contentDatabaseItems.documentId })
+        .from(schema.contentDatabaseItems)
+        .where(
+          and(
+            inArray(schema.contentDatabaseItems.databaseId, batch),
+            eq(schema.contentDatabaseItems.ownerEmail, ownerEmail),
+          ),
+        )),
     );
-  await db
-    .delete(schema.documentVersions)
-    .where(
-      and(
-        eq(schema.documentVersions.documentId, id),
-        eq(schema.documentVersions.ownerEmail, ownerEmail),
-      ),
+  }
+  if (rows.length === 0) return rows;
+
+  const ownedRows: Array<{ id: string }> = [];
+  for (const batch of chunks(rows.map((row) => row.documentId))) {
+    ownedRows.push(
+      ...(await db
+        .select({ id: schema.documents.id })
+        .from(schema.documents)
+        .where(
+          and(
+            inArray(schema.documents.id, batch),
+            eq(schema.documents.ownerEmail, ownerEmail),
+          ),
+        )),
     );
-  await db
-    .delete(schema.builderDocSidecars)
-    .where(
-      and(
-        eq(schema.builderDocSidecars.documentId, id),
-        eq(schema.builderDocSidecars.ownerEmail, ownerEmail),
-      ),
+  }
+
+  return ownedRows.map((row) => ({ documentId: row.id }));
+}
+
+async function collectDocumentSubtreeForDelete(
+  db: ReturnType<typeof getDb>,
+  rootId: string,
+  ownerEmail: string,
+) {
+  const documentIds = new Set([rootId]);
+  const ownedDatabaseIds = new Set<string>();
+  let frontier = [rootId];
+
+  while (frontier.length > 0) {
+    const next = new Set<string>();
+
+    for (const child of await selectDocumentChildren(
+      db,
+      frontier,
+      ownerEmail,
+    )) {
+      if (!documentIds.has(child.id)) {
+        documentIds.add(child.id);
+        next.add(child.id);
+      }
+    }
+
+    const ownedDatabases = await selectOwnedDatabaseIds(
+      db,
+      frontier,
+      ownerEmail,
+    );
+    const newDatabaseIds = ownedDatabases
+      .map((database) => database.id)
+      .filter((databaseId) => {
+        if (ownedDatabaseIds.has(databaseId)) return false;
+        ownedDatabaseIds.add(databaseId);
+        return true;
+      });
+
+    if (newDatabaseIds.length > 0) {
+      const itemDocuments = await selectDatabaseItemDocuments(
+        db,
+        newDatabaseIds,
+        ownerEmail,
+      );
+      for (const item of itemDocuments) {
+        if (!documentIds.has(item.documentId)) {
+          documentIds.add(item.documentId);
+          next.add(item.documentId);
+        }
+      }
+    }
+
+    frontier = [...next];
+  }
+
+  return {
+    documentIds: [...documentIds],
+    ownedDatabaseIds: [...ownedDatabaseIds],
+  };
+}
+
+async function deleteWhereIn<T>(
+  items: T[],
+  run: (batch: T[]) => Promise<unknown>,
+) {
+  for (const batch of chunks(items)) {
+    if (batch.length > 0) await run(batch);
+  }
+}
+
+export async function deleteDocumentRecursive(
+  db: ReturnType<typeof getDb>,
+  id: string,
+  ownerEmail: string,
+): Promise<string[]> {
+  const { documentIds, ownedDatabaseIds } =
+    await collectDocumentSubtreeForDelete(db, id, ownerEmail);
+
+  const propertyDefinitionIds: string[] = [];
+  await deleteWhereIn(ownedDatabaseIds, async (databaseIdBatch) => {
+    propertyDefinitionIds.push(
+      ...(
+        await db
+          .select({ id: schema.documentPropertyDefinitions.id })
+          .from(schema.documentPropertyDefinitions)
+          .where(
+            inArray(
+              schema.documentPropertyDefinitions.databaseId,
+              databaseIdBatch,
+            ),
+          )
+      ).map((definition) => definition.id),
     );
-  await db
-    .delete(schema.documentComments)
-    .where(
-      and(
-        eq(schema.documentComments.documentId, id),
-        eq(schema.documentComments.ownerEmail, ownerEmail),
-      ),
+  });
+
+  const sourceIds: string[] = [];
+  await deleteWhereIn(ownedDatabaseIds, async (databaseIdBatch) => {
+    sourceIds.push(
+      ...(
+        await db
+          .select({ id: schema.contentDatabaseSources.id })
+          .from(schema.contentDatabaseSources)
+          .where(
+            inArray(schema.contentDatabaseSources.databaseId, databaseIdBatch),
+          )
+      ).map((source) => source.id),
     );
-  await db
-    .delete(schema.documentShares)
-    .where(eq(schema.documentShares.resourceId, id));
-  await db.delete(schema.documents).where(eq(schema.documents.id, id));
-  deleted.push(id);
+  });
+
+  // Delete database membership/schema, sync links, versions, shares, then documents.
+  await deleteWhereIn(sourceIds, async (sourceIdBatch) => {
+    await db
+      .delete(schema.contentDatabaseBodyHydrationQueue)
+      .where(
+        inArray(
+          schema.contentDatabaseBodyHydrationQueue.sourceId,
+          sourceIdBatch,
+        ),
+      );
+    await db
+      .delete(schema.contentDatabaseSourceExecutions)
+      .where(
+        inArray(schema.contentDatabaseSourceExecutions.sourceId, sourceIdBatch),
+      );
+    await db
+      .delete(schema.contentDatabaseSourceChangeReviews)
+      .where(
+        inArray(
+          schema.contentDatabaseSourceChangeReviews.sourceId,
+          sourceIdBatch,
+        ),
+      );
+    await db
+      .delete(schema.contentDatabaseSourceChangeSets)
+      .where(
+        inArray(schema.contentDatabaseSourceChangeSets.sourceId, sourceIdBatch),
+      );
+    await db
+      .delete(schema.contentDatabaseSourceRows)
+      .where(inArray(schema.contentDatabaseSourceRows.sourceId, sourceIdBatch));
+    await db
+      .delete(schema.contentDatabaseSourceFields)
+      .where(
+        inArray(schema.contentDatabaseSourceFields.sourceId, sourceIdBatch),
+      );
+  });
+
+  await deleteWhereIn(propertyDefinitionIds, async (propertyIdBatch) => {
+    await db
+      .delete(schema.documentPropertyValues)
+      .where(
+        inArray(schema.documentPropertyValues.propertyId, propertyIdBatch),
+      );
+    await db
+      .delete(schema.documentBlockFieldContents)
+      .where(
+        inArray(schema.documentBlockFieldContents.propertyId, propertyIdBatch),
+      );
+  });
+
+  await deleteWhereIn(documentIds, async (documentIdBatch) => {
+    await db
+      .delete(schema.contentDatabaseBodyHydrationQueue)
+      .where(
+        inArray(
+          schema.contentDatabaseBodyHydrationQueue.documentId,
+          documentIdBatch,
+        ),
+      );
+    await db
+      .delete(schema.documentPropertyValues)
+      .where(
+        and(
+          inArray(schema.documentPropertyValues.documentId, documentIdBatch),
+          eq(schema.documentPropertyValues.ownerEmail, ownerEmail),
+        ),
+      );
+    await db
+      .delete(schema.documentBlockFieldContents)
+      .where(
+        inArray(schema.documentBlockFieldContents.documentId, documentIdBatch),
+      );
+    await db
+      .delete(schema.contentDatabaseItems)
+      .where(inArray(schema.contentDatabaseItems.documentId, documentIdBatch));
+  });
+
+  await deleteWhereIn(ownedDatabaseIds, async (databaseIdBatch) => {
+    await db
+      .delete(schema.contentDatabaseItems)
+      .where(inArray(schema.contentDatabaseItems.databaseId, databaseIdBatch));
+    await db
+      .delete(schema.contentDatabaseSources)
+      .where(
+        inArray(schema.contentDatabaseSources.databaseId, databaseIdBatch),
+      );
+    await db
+      .delete(schema.documentPropertyDefinitions)
+      .where(
+        inArray(schema.documentPropertyDefinitions.databaseId, databaseIdBatch),
+      );
+    await db
+      .delete(schema.contentDatabases)
+      .where(inArray(schema.contentDatabases.id, databaseIdBatch));
+  });
+
+  await deleteWhereIn(documentIds, async (documentIdBatch) => {
+    await db
+      .delete(schema.documentSyncLinks)
+      .where(
+        and(
+          inArray(schema.documentSyncLinks.documentId, documentIdBatch),
+          eq(schema.documentSyncLinks.ownerEmail, ownerEmail),
+        ),
+      );
+    await db
+      .delete(schema.documentVersions)
+      .where(
+        and(
+          inArray(schema.documentVersions.documentId, documentIdBatch),
+          eq(schema.documentVersions.ownerEmail, ownerEmail),
+        ),
+      );
+    await db
+      .delete(schema.builderDocSidecars)
+      .where(
+        and(
+          inArray(schema.builderDocSidecars.documentId, documentIdBatch),
+          eq(schema.builderDocSidecars.ownerEmail, ownerEmail),
+        ),
+      );
+    await db
+      .delete(schema.documentComments)
+      .where(
+        and(
+          inArray(schema.documentComments.documentId, documentIdBatch),
+          eq(schema.documentComments.ownerEmail, ownerEmail),
+        ),
+      );
+    await db
+      .delete(schema.documentShares)
+      .where(inArray(schema.documentShares.resourceId, documentIdBatch));
+  });
+
+  await deleteWhereIn(documentIds, async (documentIdBatch) => {
+    await db
+      .delete(schema.documents)
+      .where(
+        and(
+          inArray(schema.documents.id, documentIdBatch),
+          eq(schema.documents.ownerEmail, ownerEmail),
+        ),
+      );
+  });
 
-  return deleted;
+  return documentIds;
 }
 
 export default defineAction({

package/corpus/templates/content/changelog/2026-07-07-permanently-deleting-trashed-databases-now-finishes-reliably.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-07
+---
+
+Permanently deleting trashed databases now finishes reliably instead of timing out.

package/corpus/templates/design/.agents/skills/visual-edit/SKILL.md

@@ -21,6 +21,19 @@ iframe-backed screens on the infinite canvas.
 - Each screen is a URL-backed iframe, not copied HTML.
 - Each screen keeps its own URL metadata: `connectionId`, `routeId`, `path`,
   `url`, `bridgeUrl`, title, and viewport size.
+- Localhost Edit mode renders the running app through the local bridge as a live
+  iframe with the same editor bridge used by HTML designs. It is not a frozen
+  static DOM snapshot.
+- The live editor is same-origin through the local bridge proxy. This boots
+  CSR apps and root-relative assets, but it is still a localhost editing proxy:
+  app-origin cookies, WebSockets/HMR, SSE, and non-GET app API calls may need a
+  future dev-server/plugin integration for perfect parity with the app's own
+  origin.
+- Interact mode renders the app's normal URL so app navigation, scrolling,
+  links, and form controls behave as they would in the browser.
+- While a localhost screen has pending live visual edits, do not switch back to
+  Interact until the user either applies the edits to source or explicitly
+  aborts/discards the preview.
 - Start in Design's screen overview mode. The user can edit/select/drop on any
   visible screen from the overview canvas.
 - In overview, screens are static like Figma frames: no iframe scrolling or app
@@ -168,7 +181,9 @@ explicitly asks to freeze a snapshot.
 Once a connection is registered, the design editor's Code panel (left rail →
 Code, or `navigate --view editor --designId <id> --leftPanel code`) shows a
 local-files workspace root for that connection next to the design's own files.
-It lists the connected app's text/code files through the bridge
+Treat that root like VS Code opened at the connected project directory: file
+tree, search, open/edit, and save are backed by the real local files. It lists
+the connected app's text/code files through the bridge
 (`list-local-files` / `read-local-file`); build output, `node_modules`,
 `.git`, and secret-looking paths (`.env*`, key files) are always excluded.
 

package/corpus/templates/design/actions/add-localhost-screens.ts

@@ -468,6 +468,7 @@ export default defineAction({
         sourceFile: screen.sourceFile,
         path: screen.path,
         bridgeUrl: connection.bridgeUrl ?? undefined,
+        bridgeToken: connection.bridgeToken ?? undefined,
       };
       previousMetadata[screen.id] = metadata;
       previousLocalhostScreens[screen.id] = metadata;