@agent-native/core 0.84.0 → 0.84.2

package/corpus/core/src/eval/runner.ts

@@ -78,6 +78,20 @@ export async function scoreEval(
   const threshold =
     opts.thresholdOverride ?? evalCase.threshold ?? DEFAULT_EVAL_THRESHOLD;
 
+  if (evalCase.skipReason) {
+    return {
+      eval: evalCase.name,
+      threshold,
+      scores: [],
+      status: "skipped",
+      skipReason: evalCase.skipReason,
+      // Keep the legacy boolean gate friendly: skipped rows do not fail CI.
+      passed: true,
+      avgScore: 0,
+      durationMs: 0,
+    };
+  }
+
   let run: AgentRunOutput;
   if (evalCase.run) {
     run = await evalCase.run({
@@ -104,6 +118,7 @@ export async function scoreEval(
     scores,
     // A run that errored, or any sub-threshold scorer, fails the case.
     passed: run.ok && scores.every((s) => s.passed),
+    status: run.ok && scores.every((s) => s.passed) ? "passed" : "failed",
     avgScore,
     durationMs: run.durationMs,
     error: run.ok ? undefined : run.error,
@@ -120,14 +135,18 @@ export async function runEvals(
   for (const evalCase of evals) {
     const row = await scoreEval(evalCase, runner, opts);
     results.push(row);
-    if (opts.persist) await persistEvalRow(row).catch(() => {});
+    if (opts.persist && row.status !== "skipped") {
+      await persistEvalRow(row).catch(() => {});
+    }
   }
 
   const passed = results.filter((r) => r.passed).length;
+  const skipped = results.filter((r) => r.status === "skipped").length;
   return {
     total: results.length,
     passed,
-    failed: results.length - passed,
+    failed: results.filter((r) => r.status !== "skipped" && !r.passed).length,
+    skipped,
     results,
   };
 }
@@ -301,12 +320,15 @@ export async function runEvalSuite(
     evals = loaded.evals;
   }
 
+  const needsRunner = evals.some((evalCase) => !evalCase.skipReason);
   const runner =
     opts.runner ??
-    (await createAgentRunner({
-      actions: opts.actions ?? (await discoverActions(cwd)),
-      systemPrompt: opts.systemPrompt,
-    }));
+    (needsRunner
+      ? await createAgentRunner({
+          actions: opts.actions ?? (await discoverActions(cwd)),
+          systemPrompt: opts.systemPrompt,
+        })
+      : createInertRunner());
 
   const report = await runEvals(evals, runner, {
     thresholdOverride: opts.thresholdOverride,
@@ -332,3 +354,16 @@ async function discoverActions(
     return {};
   }
 }
+
+function createInertRunner(): AgentRunner {
+  return {
+    engine: {} as AgentRunner["engine"],
+    model: "inert",
+    async runAgent() {
+      throw new Error("Eval unexpectedly requested the agent runner");
+    },
+    analyzeContext() {
+      throw new Error("Eval unexpectedly requested analyze context");
+    },
+  };
+}

package/corpus/core/src/eval/types.ts

@@ -133,6 +133,12 @@ export interface EvalRunContext {
 export interface Eval {
   name: string;
   input: EvalInput;
+  /**
+   * Skip this case without running the agent or scorers. Use for opt-in
+   * suites that need secrets, live provider credentials, or manual/nightly
+   * gates. Skipped rows are reported distinctly and do not fail the suite.
+   */
+  skipReason?: string;
   /**
    * Optional override for how the agent is run for this case. Defaults to the
    * runner's headless `runAgent`. Use this to do custom setup (seed data,
@@ -159,6 +165,10 @@ export interface EvalResultRow {
   eval: string;
   threshold: number;
   scores: ScorerResult[];
+  /** Explicit row status for reports. Older consumers can still read `passed`. */
+  status?: "passed" | "failed" | "skipped";
+  /** Human-readable reason when `status` is `skipped`. */
+  skipReason?: string;
   /** True only when every scorer passed. */
   passed: boolean;
   /** Mean of the scorer scores, for at-a-glance ranking. */
@@ -173,5 +183,6 @@ export interface EvalRunReport {
   total: number;
   passed: number;
   failed: number;
+  skipped?: number;
   results: EvalResultRow[];
 }

package/corpus/core/src/templates/workspace-core/.agents/skills/reliable-mutations/SKILL.md

@@ -2,9 +2,9 @@
 name: reliable-mutations
 description: >-
   How the agent must perform writes so they actually persist under the hosted
-  ~40s run budget. Use whenever you create, update, delete, or batch-write app
-  data — especially "do this for many items" loops, or any task where the user
-  expects N things to end up saved.
+  foreground run budget and long-running background handoffs. Use whenever you
+  create, update, delete, or batch-write app data — especially "do this for many
+  items" loops, or any task where the user expects N things to end up saved.
 ---
 
 # Reliable Mutations
@@ -18,15 +18,12 @@ tool ✓ alone.
 
 ## Why
 
-Hosted agent runs have a ~40s soft budget (it exists to hand off cleanly under
-the upstream gateway/function walls — it is correct and is not raisable; see the
-durable-agent-runs design doc). When you loop many sequential writes inside one
-turn, the budget can cut you off mid-loop. The run resumes in a new chunk, but
-the resume often re-does earlier steps instead of advancing, so the loop churns
-and the *saved* result ends up partial — or empty — even though each individual
-tool call appeared to succeed. The user gets told "done" while the data says
-otherwise. One atomic call commits or fails as a unit; verification turns a
-hopeful ✓ into a fact.
+Hosted foreground agent runs have a short soft budget so they can hand off
+cleanly under synchronous serverless walls. Durable background runs get a much
+longer budget, but they still should not rely on loops of many small writes:
+continuations can retry the same intent and leave partial state if each item is
+committed separately. One atomic call commits or fails as a unit; verification
+turns a hopeful ✓ into a fact.
 
 ## How
 
@@ -34,11 +31,12 @@ hopeful ✓ into a fact.
    many, set all, bulk update), pass the full batch in one call so it commits
    atomically. Check the action surface for a batch/plural form before reaching
    for a loop.
-2. **Do not loop many small writes under the run budget.** A sequence of N
-   per-item writes in one turn will race the ~40s cutoff and can leave partial
-   or no state. If no batch action exists, that is a gap in the action layer —
-   add or extend an action that accepts the batch (see the `actions` skill)
-   rather than papering over it with a loop.
+2. **Do not loop many small writes under any run budget.** A sequence of N
+   per-item writes can still leave partial or no state when a foreground run
+   hands off, a background run continues, or an upstream provider fails. If no
+   batch action exists, that is a gap in the action layer — add or extend an
+   action that accepts the batch (see the `actions` skill) rather than papering
+   over it with a loop.
 3. **Verify the end state after writing.** Re-read the data (a list/read action,
    a count query) and confirm the result matches intent — the right number of
    rows, the expected ids/fields. Do this before you tell the user it worked.

package/corpus/templates/content/AGENTS.md

@@ -121,7 +121,9 @@ cd templates/content && pnpm action <name> [args]
 | `validate-builder-source-execution`         | `--databaseId <id>` or `--documentId <id> --changeSetId <id> [--idempotencyKey <key>]`                                                                         | Validate/replay a prepared Builder execution gate locally as a dry run; never calls Builder                                             |
 | `execute-builder-source-execution`          | `--databaseId <id>` or `--documentId <id> --changeSetId <id> [--idempotencyKey <key>] [--pushModeConfirmation autosave\|draft\|publish]`                       | Execute a guarded live Builder write only when approved, validated, enabled, idempotent, and targeting `agent-native-blog-article-test` |
 | `add-database-item`                         | `--databaseId <id> [--title <text>] [--propertyValues <json>]`                                                                                                 | Add a page row to a database, optionally seeding property values                                                                        |
-| `duplicate-database-item`                   | `--itemId <id>` or `--documentId <id> [--title <text>]`                                                                                                        | Duplicate a database row page and its stored property values                                                                            |
+| `duplicate-database-item`                   | `--itemId <id>` or `--documentId <id> [--title <text>]`                                                                                                        | Duplicate exactly one database row page and its stored property values; for two or more rows, use `duplicate-database-items` once       |
+| `duplicate-database-items`                  | `--databaseId <id>` or `--documentId <databaseDocumentId> --itemIds <json-array>` or `--documentIds <json-array>`                                              | Preferred multi-row duplicate action; duplicate multiple database row pages atomically and return ordered duplicate item/document IDs   |
+| `delete-database-items`                     | `--databaseId <id>` or `--documentId <databaseDocumentId> --itemIds <json-array>` or `--documentIds <json-array>`                                              | Preferred multi-row delete action; delete multiple database row pages atomically while preserving `delete-document` admin semantics     |
 | `move-database-item`                        | `--itemId <id>` or `--documentId <id> --position <number>`                                                                                                     | Move a database row page to a new zero-based table position                                                                             |
 | `update-content-database-view`              | `--databaseId <id> --viewConfig <json>`                                                                                                                        | Persist database views, sorts, filters, hidden properties, and view settings                                                            |
 | `list-document-properties`                  | `--documentId <id> [--format json]`                                                                                                                            | List Notion-style property definitions and values for a document                                                                        |
@@ -568,11 +570,16 @@ multi-select, users can add a new board group from the board itself; this
 appends a new option to the grouped property definition.
 Use
 `create-content-database`, `get-content-database`,
-`add-database-item`, `duplicate-database-item`, `move-database-item`,
+`add-database-item`, `duplicate-database-item`, `duplicate-database-items`,
+`delete-database-items`, `move-database-item`,
 `update-content-database-view`, `list-document-properties`,
 `configure-document-property`, `set-document-property`,
 `duplicate-document-property`, and `delete-document-property`; do not edit
 property rows or view config via raw SQL when an action can do it.
+When targeting more than one database row, call `duplicate-database-items` or
+`delete-database-items` once with a native JSON array of `itemIds` or
+`documentIds`. Do not loop `duplicate-database-item` or `delete-document` for
+multi-row duplicate/delete requests.
 
 ## UI Components
 

package/corpus/templates/content/actions/_database-row-batch.ts

@@ -0,0 +1,230 @@
+import { and, asc, eq, inArray, isNull, or, sql } from "drizzle-orm";
+import { z } from "zod";
+
+import { getDb, schema } from "../server/db/index.js";
+
+export const DATABASE_ROW_BATCH_LIMIT = 100;
+
+export const databaseRowBatchSchema = z
+  .object({
+    databaseId: z.string().optional().describe("Content database ID"),
+    documentId: z
+      .string()
+      .optional()
+      .describe("Content database backing document ID"),
+    itemIds: z
+      .array(z.string())
+      .max(DATABASE_ROW_BATCH_LIMIT)
+      .optional()
+      .describe(
+        'Native JSON array of database row item IDs to mutate in one batch, for example ["item_1", "item_2"].',
+      ),
+    documentIds: z
+      .array(z.string())
+      .max(DATABASE_ROW_BATCH_LIMIT)
+      .optional()
+      .describe(
+        'Native JSON array of database row document IDs to mutate in one batch, for example ["doc_1", "doc_2"].',
+      ),
+  })
+  .superRefine((value, ctx) => {
+    if (!value.databaseId && !value.documentId) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "Either databaseId or documentId is required.",
+      });
+    }
+    const total =
+      (value.itemIds?.length ?? 0) + (value.documentIds?.length ?? 0);
+    if (total === 0) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "At least one itemId or documentId is required.",
+      });
+    }
+    if (total > DATABASE_ROW_BATCH_LIMIT) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `Database row batch is limited to ${DATABASE_ROW_BATCH_LIMIT} rows.`,
+      });
+    }
+  });
+
+export type DatabaseRowBatchInput = z.infer<typeof databaseRowBatchSchema>;
+
+export type DatabaseRowBatchRow = {
+  item: typeof schema.contentDatabaseItems.$inferSelect;
+  database: typeof schema.contentDatabases.$inferSelect;
+  document: typeof schema.documents.$inferSelect;
+};
+
+function findDuplicates(values: string[]) {
+  const seen = new Set<string>();
+  const duplicates = new Set<string>();
+  for (const value of values) {
+    if (seen.has(value)) duplicates.add(value);
+    seen.add(value);
+  }
+  return [...duplicates];
+}
+
+function positionCaseSql(
+  idColumn: unknown,
+  fallbackColumn: unknown,
+  orderedIds: string[],
+) {
+  const cases = orderedIds.map((id, index) => sql`WHEN ${id} THEN ${index}`);
+  return sql<number>`CASE ${idColumn} ${sql.join(cases, sql` `)} ELSE ${fallbackColumn} END`;
+}
+
+export async function resolveDatabaseRowsForBatch(
+  input: DatabaseRowBatchInput,
+): Promise<{
+  database: typeof schema.contentDatabases.$inferSelect;
+  rows: DatabaseRowBatchRow[];
+}> {
+  const itemIds = input.itemIds ?? [];
+  const documentIds = input.documentIds ?? [];
+  const requestedCount = itemIds.length + documentIds.length;
+  if (!input.databaseId && !input.documentId) {
+    throw new Error("Either databaseId or documentId is required.");
+  }
+  if (requestedCount === 0) {
+    throw new Error("At least one itemId or documentId is required.");
+  }
+  if (requestedCount > DATABASE_ROW_BATCH_LIMIT) {
+    throw new Error(
+      `Database row batch is limited to ${DATABASE_ROW_BATCH_LIMIT} rows.`,
+    );
+  }
+  const duplicateItemIds = findDuplicates(itemIds);
+  const duplicateDocumentIds = findDuplicates(documentIds);
+  if (duplicateItemIds.length > 0 || duplicateDocumentIds.length > 0) {
+    throw new Error("Duplicate database row IDs are not allowed in one batch.");
+  }
+
+  const db = getDb();
+  const [database] = await db
+    .select()
+    .from(schema.contentDatabases)
+    .where(
+      and(
+        input.databaseId
+          ? eq(schema.contentDatabases.id, input.databaseId)
+          : undefined,
+        input.documentId
+          ? eq(schema.contentDatabases.documentId, input.documentId)
+          : undefined,
+        isNull(schema.contentDatabases.deletedAt),
+      ),
+    );
+
+  if (!database) throw new Error("Database not found.");
+
+  const rowPredicates = [];
+  if (itemIds.length > 0) {
+    rowPredicates.push(inArray(schema.contentDatabaseItems.id, itemIds));
+  }
+  if (documentIds.length > 0) {
+    rowPredicates.push(
+      inArray(schema.contentDatabaseItems.documentId, documentIds),
+    );
+  }
+
+  const requestedRows = await db
+    .select({
+      item: schema.contentDatabaseItems,
+      database: schema.contentDatabases,
+      document: schema.documents,
+    })
+    .from(schema.contentDatabaseItems)
+    .innerJoin(
+      schema.contentDatabases,
+      eq(schema.contentDatabases.id, schema.contentDatabaseItems.databaseId),
+    )
+    .innerJoin(
+      schema.documents,
+      eq(schema.documents.id, schema.contentDatabaseItems.documentId),
+    )
+    .where(
+      and(
+        eq(schema.contentDatabaseItems.databaseId, database.id),
+        rowPredicates.length === 1 ? rowPredicates[0] : or(...rowPredicates),
+        isNull(schema.contentDatabases.deletedAt),
+      ),
+    )
+    .orderBy(asc(schema.contentDatabaseItems.position));
+
+  const itemIdMatches = new Set(requestedRows.map((row) => row.item.id));
+  const documentIdMatches = new Set(
+    requestedRows.map((row) => row.item.documentId),
+  );
+  const missingItemIds = itemIds.filter((id) => !itemIdMatches.has(id));
+  const missingDocumentIds = documentIds.filter(
+    (id) => !documentIdMatches.has(id),
+  );
+  if (missingItemIds.length > 0 || missingDocumentIds.length > 0) {
+    throw new Error("All requested rows must exist in the target database.");
+  }
+
+  if (requestedRows.length !== requestedCount) {
+    throw new Error("Duplicate database row references are not allowed.");
+  }
+
+  const rowIds = requestedRows.map((row) => row.item.id);
+  if (new Set(rowIds).size !== rowIds.length) {
+    throw new Error("Duplicate database row references are not allowed.");
+  }
+
+  return { database, rows: requestedRows };
+}
+
+export async function renumberDatabaseRows(
+  db: ReturnType<typeof getDb>,
+  database: typeof schema.contentDatabases.$inferSelect,
+  now: string,
+) {
+  const rows = await db
+    .select()
+    .from(schema.contentDatabaseItems)
+    .where(eq(schema.contentDatabaseItems.databaseId, database.id))
+    .orderBy(asc(schema.contentDatabaseItems.position));
+  if (rows.length === 0) return;
+
+  const itemIds = rows.map((row) => row.id);
+  const documentIds = rows.map((row) => row.documentId);
+  await db
+    .update(schema.contentDatabaseItems)
+    .set({
+      position: positionCaseSql(
+        schema.contentDatabaseItems.id,
+        schema.contentDatabaseItems.position,
+        itemIds,
+      ),
+      updatedAt: now,
+    })
+    .where(
+      and(
+        eq(schema.contentDatabaseItems.databaseId, database.id),
+        inArray(schema.contentDatabaseItems.id, itemIds),
+      ),
+    );
+
+  await db
+    .update(schema.documents)
+    .set({
+      position: positionCaseSql(
+        schema.documents.id,
+        schema.documents.position,
+        documentIds,
+      ),
+      updatedAt: now,
+    })
+    .where(
+      and(
+        eq(schema.documents.ownerEmail, database.ownerEmail),
+        eq(schema.documents.parentId, database.documentId),
+        inArray(schema.documents.id, documentIds),
+      ),
+    );
+}

package/corpus/templates/content/actions/_database-utils.ts

@@ -285,8 +285,8 @@ export async function isSoftDeletedDatabaseDocument(documentId: string) {
 export async function getDatabaseByDocumentId(
   documentId: string,
   options: { includeDeleted?: boolean } = {},
+  db = getDb(),
 ) {
-  const db = getDb();
   const clauses = [eq(schema.contentDatabases.documentId, documentId)];
   if (!options.includeDeleted) {
     clauses.push(isNull(schema.contentDatabases.deletedAt));
@@ -301,8 +301,8 @@ export async function getDatabaseByDocumentId(
 export async function getDatabaseItemByDocumentId(
   documentId: string,
   options: { includeDeleted?: boolean } = {},
+  db = getDb(),
 ) {
-  const db = getDb();
   const clauses = [eq(schema.contentDatabaseItems.documentId, documentId)];
   if (!options.includeDeleted) {
     clauses.push(isNull(schema.contentDatabases.deletedAt));
@@ -332,11 +332,15 @@ export async function getDatabaseItemByDocumentId(
 export async function deleteDatabaseDataForDocument(
   documentId: string,
   ownerEmail: string,
+  db = getDb(),
 ) {
-  const db = getDb();
-  const database = await getDatabaseByDocumentId(documentId, {
-    includeDeleted: true,
-  });
+  const database = await getDatabaseByDocumentId(
+    documentId,
+    {
+      includeDeleted: true,
+    },
+    db,
+  );
   if (database) {
     const definitions = await db
       .select({ id: schema.documentPropertyDefinitions.id })
@@ -395,9 +399,13 @@ export async function deleteDatabaseDataForDocument(
       .where(eq(schema.contentDatabases.id, database.id));
   }
 
-  const item = await getDatabaseItemByDocumentId(documentId, {
-    includeDeleted: true,
-  });
+  const item = await getDatabaseItemByDocumentId(
+    documentId,
+    {
+      includeDeleted: true,
+    },
+    db,
+  );
   if (item) {
     await db
       .delete(schema.contentDatabaseBodyHydrationQueue)

package/corpus/templates/content/actions/_notion-action-utils.ts

@@ -0,0 +1,26 @@
+import {
+  getRequestOrgId,
+  getRequestUserEmail,
+} from "@agent-native/core/server";
+import { assertAccess } from "@agent-native/core/sharing";
+
+export function getCurrentNotionOwner() {
+  const owner = getRequestUserEmail();
+  if (!owner) throw new Error("no authenticated user");
+  return owner;
+}
+
+export async function getNotionDocumentOwner(documentId: string) {
+  const userEmail = getCurrentNotionOwner();
+  await assertAccess("document", documentId, "editor", {
+    userEmail,
+    orgId: getRequestOrgId(),
+  });
+  return userEmail;
+}
+
+export function resolveDocumentId(args: { documentId?: string; id?: string }) {
+  const documentId = args.documentId || args.id;
+  if (!documentId) throw new Error("documentId is required");
+  return documentId;
+}

package/corpus/templates/content/actions/connect-notion-status.ts

@@ -1,21 +1,30 @@
 import { defineAction } from "@agent-native/core";
-import { getRequestUserEmail } from "@agent-native/core/server";
+import { resolveSecret } from "@agent-native/core/server";
 import { z } from "zod";
 
 import { getNotionConnectionForOwner } from "../server/lib/notion.js";
+import { getCurrentNotionOwner } from "./_notion-action-utils.js";
 
 export default defineAction({
   description: "Check Notion connection status for the current user.",
   schema: z.object({}),
-  http: false,
+  http: { method: "GET" },
   run: async () => {
-    const owner = getRequestUserEmail();
-    if (!owner) throw new Error("no authenticated user");
+    const owner = getCurrentNotionOwner();
     const connection = await getNotionConnectionForOwner(owner);
+    const hasOAuthCredentials = Boolean(
+      (await resolveSecret("NOTION_CLIENT_ID")) &&
+      (await resolveSecret("NOTION_CLIENT_SECRET")),
+    );
+
     return {
       connected: Boolean(connection),
       workspaceName: connection?.workspaceName ?? null,
       workspaceId: connection?.workspaceId ?? null,
+      authUrl: null,
+      error:
+        connection || hasOAuthCredentials ? undefined : "missing_credentials",
+      mode: connection ? ("oauth" as const) : null,
     };
   },
 });

package/corpus/templates/content/actions/create-and-link-notion-page.ts

@@ -0,0 +1,23 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+
+import { createAndLinkNotionPage } from "../server/lib/notion-sync.js";
+import {
+  getNotionDocumentOwner,
+  resolveDocumentId,
+} from "./_notion-action-utils.js";
+
+export default defineAction({
+  description: "Create a Notion page from a Content document and link it.",
+  schema: z.object({
+    documentId: z.string().optional().describe("Document ID (required)"),
+    id: z.string().optional().describe("Alias for --documentId"),
+    parentPageIdOrUrl: z.string().optional(),
+  }),
+  http: { method: "POST" },
+  run: async (args) => {
+    const documentId = resolveDocumentId(args);
+    const owner = await getNotionDocumentOwner(documentId);
+    return createAndLinkNotionPage(owner, documentId, args.parentPageIdOrUrl);
+  },
+});

package/corpus/templates/content/actions/delete-database-items.ts

@@ -0,0 +1,55 @@
+import { defineAction } from "@agent-native/core";
+import { writeAppState } from "@agent-native/core/application-state";
+import { assertAccess } from "@agent-native/core/sharing";
+
+import { getDb } from "../server/db/index.js";
+import {
+  databaseRowBatchSchema,
+  renumberDatabaseRows,
+  resolveDatabaseRowsForBatch,
+} from "./_database-row-batch.js";
+import { getContentDatabaseResponse } from "./_database-utils.js";
+import { deleteDocumentRecursive } from "./delete-document.js";
+
+export default defineAction({
+  description:
+    "Delete multiple page rows from a content database in one atomic batch. Use this for two or more selected/named rows instead of looping delete-document.",
+  schema: databaseRowBatchSchema,
+  run: async (args) => {
+    const db = getDb();
+    const { database, rows } = await resolveDatabaseRowsForBatch(args);
+
+    await assertAccess("document", database.documentId, "editor");
+    for (const row of rows) {
+      await assertAccess("document", row.document.id, "admin");
+    }
+
+    const deletedItemIds = rows.map((row) => row.item.id);
+    const deletedDocumentIds = rows.map((row) => row.document.id);
+    const now = new Date().toISOString();
+
+    await db.transaction(async (tx) => {
+      for (const row of rows) {
+        await deleteDocumentRecursive(
+          tx as unknown as ReturnType<typeof getDb>,
+          row.document.id,
+          row.document.ownerEmail,
+        );
+      }
+      await renumberDatabaseRows(
+        tx as unknown as ReturnType<typeof getDb>,
+        database,
+        now,
+      );
+    });
+
+    await writeAppState("refresh-signal", { ts: Date.now() });
+
+    return {
+      ...(await getContentDatabaseResponse(database.id)),
+      deletedItemIds,
+      deletedDocumentIds,
+      deletedCount: deletedItemIds.length,
+    };
+  },
+});

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

@@ -12,7 +12,7 @@ import {
   isContentLocalFileMode,
 } from "./_local-file-documents.js";
 
-async function deleteRecursive(
+export async function deleteDocumentRecursive(
   db: ReturnType<typeof getDb>,
   id: string,
   ownerEmail: string,
@@ -29,11 +29,11 @@ async function deleteRecursive(
 
   const deleted: string[] = [];
   for (const child of children) {
-    deleted.push(...(await deleteRecursive(db, child.id, ownerEmail)));
+    deleted.push(...(await deleteDocumentRecursive(db, child.id, ownerEmail)));
   }
 
   // Delete database membership/schema, sync links, versions, shares, then document.
-  await deleteDatabaseDataForDocument(id, ownerEmail);
+  await deleteDatabaseDataForDocument(id, ownerEmail, db);
   await db
     .delete(schema.documentSyncLinks)
     .where(
@@ -86,7 +86,7 @@ export default defineAction({
     const existing = access.resource;
 
     const db = getDb();
-    const deleted = await deleteRecursive(
+    const deleted = await deleteDocumentRecursive(
       db,
       id,
       existing.ownerEmail as string,