@agent-native/core 0.157.2 → 0.157.4

package/corpus/templates/clips/server/lib/emails.ts

@@ -52,12 +52,39 @@ const CLIPS_SENDER =
   'From is the configured EMAIL_FROM with the display name "Agent-Native Clips"; on first-party agent-native.com deployments it becomes clips@agent-native.com. Reply-to is hello@agent-native.com.';
 
 let registered = false;
+const GLOBAL_REGISTRATION_KEY =
+  "__agentNativeClipsTransactionalEmailCatalogRegistered";
+const globalRegistrationState = globalThis as typeof globalThis &
+  Record<string, boolean | undefined>;
+
+function defineClipsTransactionalEmail(
+  definition: Parameters<typeof defineTransactionalEmail>[0],
+): boolean {
+  try {
+    defineTransactionalEmail(definition);
+    return true;
+  } catch (error) {
+    if (
+      error instanceof Error &&
+      error.message.startsWith('Duplicate transactional email id "clips.')
+    ) {
+      // The same Clips catalog can be evaluated twice by Nitro/Vite. The
+      // first definition is canonical, so a duplicate is already registered.
+      return false;
+    }
+    throw error;
+  }
+}
 
 export function registerClipsEmails(): void {
-  if (registered) return;
+  // Nitro/Vite can evaluate the same server module through two module
+  // instances during dev reloads. Keep the catalog registration process-wide
+  // so those instances cannot submit the same id twice.
+  if (registered || globalRegistrationState[GLOBAL_REGISTRATION_KEY]) return;
   registered = true;
+  globalRegistrationState[GLOBAL_REGISTRATION_KEY] = true;
 
-  defineTransactionalEmail({
+  defineClipsTransactionalEmail({
     id: CLIPS_ACCESS_REQUEST_EMAIL_ID,
     name: "Clip access request",
     trigger:
@@ -73,10 +100,12 @@ export function registerClipsEmails(): void {
         requesterEmail: "sam.rivera@example.com",
         recordingTitle: SAMPLE_TITLE,
         url: "https://example.com/share/rec_sample",
+        allowAccessUrl:
+          "https://example.com/access-request/approve?recordingId=rec_sample&token=preview-token",
       }),
   });
 
-  defineTransactionalEmail({
+  defineClipsTransactionalEmail({
     id: CLIPS_FIRST_VIEW_EMAIL_ID,
     name: "First view on a Clip",
     trigger:
@@ -96,7 +125,7 @@ export function registerClipsEmails(): void {
       }),
   });
 
-  defineTransactionalEmail({
+  defineClipsTransactionalEmail({
     id: CLIPS_UNVIEWED_REMINDER_EMAIL_ID,
     name: "Unviewed Clip reminder",
     trigger:
@@ -118,7 +147,7 @@ export function registerClipsEmails(): void {
       }),
   });
 
-  defineTransactionalEmail({
+  defineClipsTransactionalEmail({
     id: CLIPS_FIRST_AGENT_VIEW_EMAIL_ID,
     name: "First agent read of a Clip",
     trigger:
@@ -138,7 +167,7 @@ export function registerClipsEmails(): void {
       }),
   });
 
-  defineTransactionalEmail({
+  defineClipsTransactionalEmail({
     id: CLIPS_FIRST_IMPORT_EMAIL_ID,
     name: "First imported video is ready",
     trigger:
@@ -157,7 +186,7 @@ export function registerClipsEmails(): void {
       }),
   });
 
-  defineTransactionalEmail({
+  defineClipsTransactionalEmail({
     id: CLIPS_MONTHLY_RECAP_EMAIL_ID,
     name: "Monthly Clips recap",
     trigger:
@@ -191,7 +220,7 @@ export function registerClipsEmails(): void {
       }),
   });
 
-  defineTransactionalEmail({
+  defineClipsTransactionalEmail({
     id: CLIPS_TWO_CLIPS_EMAIL_ID,
     name: "Two Clips received",
     trigger:
@@ -210,7 +239,7 @@ export function registerClipsEmails(): void {
       }),
   });
 
-  defineTransactionalEmail({
+  defineClipsTransactionalEmail({
     id: CLIPS_ACTIVITY_COMMENT_EMAIL_ID,
     name: "Clip comment",
     trigger:
@@ -234,7 +263,7 @@ export function registerClipsEmails(): void {
       }),
   });
 
-  defineTransactionalEmail({
+  defineClipsTransactionalEmail({
     id: CLIPS_ACTIVITY_REACTION_EMAIL_ID,
     name: "Clip reaction",
     trigger: "A viewer reacts with an emoji on a Clip.",
@@ -256,7 +285,7 @@ export function registerClipsEmails(): void {
       }),
   });
 
-  defineTransactionalEmail({
+  defineClipsTransactionalEmail({
     id: CLIPS_ORGANIZATION_INVITE_EMAIL_ID,
     name: "Organization invitation",
     trigger:

package/corpus/templates/clips/shared/recording-link.ts

@@ -12,15 +12,46 @@
  */
 import { withShareAttribution } from "./share-attribution";
 
-/** Short-lived capability used by a signed-in private share viewer to request access. */
+/** Short-lived capability used by a private share viewer to request access. */
 export const CLIPS_ACCESS_REQUEST_TOKEN_PREFIX = "clips-access-request";
 export const CLIPS_ACCESS_REQUEST_TOKEN_TTL_SECONDS = 10 * 60;
 
+/** Signed capability embedded in the owner's access-request email. */
+export const CLIPS_ACCESS_APPROVAL_TOKEN_PREFIX = "clips-access-approval";
+export const CLIPS_ACCESS_APPROVAL_TOKEN_TTL_SECONDS = 7 * 24 * 60 * 60;
+export const CLIPS_ACCESS_APPROVAL_SESSION_KEY_PREFIX =
+  "clips-access-approval-token:";
+
 /** Public share path for a recording, relative to the app base path. */
 export function recordingSharePath(recordingId: string): string {
   return `/share/${encodeURIComponent(recordingId)}`;
 }
 
+/** Owner-only route used by the one-click approval button in access emails. */
+export function recordingAccessApprovalPath(
+  recordingId: string,
+  approvalToken: string,
+): string {
+  const params = new URLSearchParams({
+    recordingId,
+    token: approvalToken,
+  });
+  return `/access-request/approve?${params.toString()}`;
+}
+
+/** Token-free continuation used after the approver signs in. */
+export function recordingAccessApprovalContinuationPath(
+  recordingId: string,
+): string {
+  const params = new URLSearchParams({ recordingId });
+  return `/access-request/approve?${params.toString()}`;
+}
+
+/** Tab-scoped key for carrying an approval token across the sign-in redirect. */
+export function recordingAccessApprovalSessionKey(recordingId: string): string {
+  return `${CLIPS_ACCESS_APPROVAL_SESSION_KEY_PREFIX}${encodeURIComponent(recordingId)}`;
+}
+
 export interface RecordingShareUrlParams {
   recordingId: string;
   /** Absolute origin, e.g. `https://clips.example.com` or a desktop serverUrl. */

package/corpus/templates/clips/shared/share-attribution.ts

@@ -51,6 +51,19 @@ export type ShareAttribution = {
   via: string | undefined;
 };
 
+/**
+ * Keep only non-sensitive attribution state when a share page redirects to
+ * sign-in. Passwords and capability tokens must never enter auth URLs.
+ */
+export function buildShareContinuationQuery(
+  attribution: ShareAttribution,
+): string {
+  const params = new URLSearchParams();
+  if (attribution.ref) params.set(REF_PARAM, attribution.ref);
+  if (attribution.via) params.set(VIA_PARAM, attribution.via);
+  return params.toString();
+}
+
 /**
  * Read `ref`/`via` from a query string (e.g. `window.location.search`). Falls
  * back to `ref=clip_share` so downstream attribution stays meaningful even when

package/corpus/templates/content/.agents/skills/agent-native-toolkit/SKILL.md

@@ -182,6 +182,11 @@ in the moment of agent use.
   five-item sidebar preview and a footer row with New chat followed by an
   ellipsis disclosure up to fifteen. Apps inject routing, labels, and domain
   actions.
+- **Data grid kit**: provider-agnostic spreadsheet mechanics belong in
+  `@agent-native/toolkit/data-grid`. Apps provide rows, typed columns, editor
+  slots, selection and width state, persistence callbacks, and product-level
+  row/body slots. Keep database models, access checks, grouping, drag/drop,
+  and domain actions in the app adapter.
 - **Agent page kit**: the full-page `/agent` surface (`AgentTabsPage` from
   `@agent-native/core/client`) with Context, Files, Connections, Jobs, and
   Access tabs plus a Personal/Organization scope toggle. The canonical home

package/corpus/templates/content/.agents/skills/sharing/SKILL.md

@@ -184,6 +184,27 @@ import { ShareButton } from "@agent-native/core/client/sharing";
 
 For list views, show `<VisibilityBadge visibility={row.visibility} />` next to each resource.
 
+## Standard share surface
+
+All app share popovers should use the same compact surface contract:
+
+- Use the text-only `ShareTrigger` from `@agent-native/toolkit/sharing`.
+- Render ordinary links with `ShareCopyRow`, which exposes a Copy action without
+  printing the raw URL.
+- Keep general access and individual people access in the standard Core sharing
+  flow. The people flow supports email invites, roles, notifications, and
+  removal through the shared share actions.
+- Add `ShareAgentsSection` only when the resource has a real agent-readable
+  link or prompt. Keep it collapsed by default and supply domain-specific
+  content through the shared section shell.
+- App-specific tabs or controls may remain when they represent a real domain
+  action (for example, an embed-code editor), but they should retain the same
+  trigger, copy-row, access, and spacing language.
+
+`ShareDisclosureSection` is the toolkit-owned shell for optional expandable
+share details; use its `ShareAgentsSection` or `SharePeopleSection` wrappers
+instead of creating another collapsible share panel in a template.
+
 ## Actions available everywhere
 
 The framework auto-mounts these actions in every template — no per-template boilerplate:

package/corpus/templates/content/actions/add-database-item.ts

@@ -26,6 +26,15 @@ const schema = databaseMutationEnvelopeSchema.extend({
 export default defineAction({
   description:
     "Create one row in an exact ordinary Content database using its discovered schema revision. Strictly validates every non-Blocks property, applies the side effect once per idempotency key, and returns a verified receipt with stable row identity.",
+  publicAgent: {
+    expose: true,
+    readOnly: false,
+    requiresAuth: true,
+    isConsequential: true,
+    title: "Add Content Database Item",
+    description:
+      "Delegate creation of one page item in an existing Content database.",
+  },
   schema,
   audit: {
     recordInputs: false,

package/corpus/templates/content/actions/describe-content-database.ts

@@ -0,0 +1,92 @@
+import { defineAction } from "@agent-native/core";
+import { accessFilter } from "@agent-native/core/sharing";
+import { and, eq } from "drizzle-orm";
+import { z } from "zod";
+
+import { getDb, schema } from "../server/db/index.js";
+import { getDocumentContextPath } from "../server/lib/document-context.js";
+import type {
+  ContentDatabaseDescriptionResponse,
+  ContentDatabaseUnavailableResponse,
+} from "../shared/api.js";
+import { resolveContentDatabaseRead } from "./_database-utils.js";
+import {
+  listPropertiesForDatabase,
+  serializeDatabase,
+} from "./_property-utils.js";
+import listContentDatabases, {
+  ContentDatabaseResolutionError,
+} from "./list-content-databases.js";
+
+export default defineAction({
+  description:
+    "Describe one exact ordinary Content database, including its live metadata, views, and property schema but not its rows. Resolve the stable database or document ID with list-content-databases first.",
+  schema: z
+    .object({
+      databaseId: z.string().min(1).optional().describe("Exact database ID"),
+      documentId: z
+        .string()
+        .min(1)
+        .optional()
+        .describe("Exact database document/page ID"),
+    })
+    .refine(
+      (input) => Boolean(input.databaseId) !== Boolean(input.documentId),
+      "Provide exactly one of databaseId or documentId.",
+    ),
+  http: { method: "GET" },
+  readOnly: true,
+  publicAgent: { expose: true, readOnly: true, requiresAuth: true },
+  run: async ({
+    databaseId,
+    documentId,
+  }): Promise<
+    ContentDatabaseDescriptionResponse | ContentDatabaseUnavailableResponse
+  > => {
+    let selection: Awaited<ReturnType<typeof listContentDatabases.run>>;
+    try {
+      selection = await listContentDatabases.run({ databaseId, documentId });
+    } catch (error) {
+      if (!(error instanceof ContentDatabaseResolutionError)) throw error;
+      throw new Error("Content database not found.");
+    }
+    const selected = selection.databases[0];
+    if (!selected) throw new Error("Content database not found.");
+
+    const resolved = await resolveContentDatabaseRead({
+      databaseId: selected.databaseId,
+    });
+    if (!resolved.available) return resolved;
+    if (resolved.database.systemRole) {
+      throw new Error("Content database not found.");
+    }
+
+    const db = getDb();
+    const [databaseDocument] = await db
+      .select({
+        id: schema.documents.id,
+        parentId: schema.documents.parentId,
+      })
+      .from(schema.documents)
+      .where(
+        and(
+          eq(schema.documents.id, selected.documentId),
+          accessFilter(schema.documents, schema.documentShares),
+        ),
+      );
+    if (!databaseDocument) throw new Error("Content database not found.");
+
+    const [properties, contextPath] = await Promise.all([
+      listPropertiesForDatabase(resolved.database.id),
+      getDocumentContextPath(databaseDocument),
+    ]);
+    return {
+      database: serializeDatabase(
+        { ...resolved.database, title: selected.title },
+        selected.description,
+      ),
+      contextPath,
+      properties,
+    };
+  },
+});

package/corpus/templates/content/actions/list-content-databases.ts

@@ -1,20 +1,55 @@
 import { defineAction } from "@agent-native/core";
 import { accessFilter } from "@agent-native/core/sharing";
-import { and, asc, eq, isNull, ne, sql } from "drizzle-orm";
+import {
+  and,
+  asc,
+  eq,
+  inArray,
+  isNull,
+  notInArray,
+  or,
+  sql,
+} from "drizzle-orm";
 import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
 import { documentDiscoveryFilter } from "../server/lib/documents.js";
 import type { ListContentDatabasesResponse } from "../shared/api.js";
+import { documentDiscoveryPagination } from "./_document-discovery-query.js";
+
+const DEFAULT_CONTENT_DATABASE_DISCOVERY_LIMIT = 50;
 
 function escapeLike(s: string): string {
   return s.replace(/([\\%_])/g, "\\$1");
 }
 
+export class ContentDatabaseResolutionError extends Error {}
+
 export default defineAction({
   description:
-    "List the content databases the user can access (owned, shared, or org-shared — matching the sidebar) so any of them can be used as a local-table source. Optionally filters by title or excludes one database (e.g. the one being configured).",
+    "Discover one bounded page of ordinary Content databases the user can access from their live title and user-authored description. Returns stable database, document, and space IDs with explicit pagination; follow nextOffset until hasMore is false. Use exact filters before reading a selected database's schema.",
   schema: z.object({
+    spaceId: z
+      .string()
+      .min(1)
+      .optional()
+      .describe("Exact Content space ID to search within."),
+    databaseId: z
+      .string()
+      .min(1)
+      .optional()
+      .describe("Exact Content database ID to resolve."),
+    documentId: z
+      .string()
+      .min(1)
+      .optional()
+      .describe("Exact Content database document/page ID to resolve."),
+    title: z
+      .string()
+      .trim()
+      .min(1)
+      .optional()
+      .describe("Exact live database title to resolve, case-insensitively."),
     excludeDatabaseId: z
       .string()
       .optional()
@@ -23,63 +58,43 @@ export default defineAction({
       .array(z.string())
       .optional()
       .describe("Database ids to omit from the results."),
-    query: z.string().optional().describe("Optional title search text."),
+    query: z
+      .string()
+      .optional()
+      .describe("Optional title or user-authored description search text."),
     limit: z.coerce
       .number()
       .int()
       .min(1)
       .max(50)
-      .optional()
-      .describe("Maximum number of databases to return."),
+      .default(DEFAULT_CONTENT_DATABASE_DISCOVERY_LIMIT)
+      .describe("Maximum number of databases to return. Defaults to 50."),
+    offset: z.coerce
+      .number()
+      .int()
+      .min(0)
+      .default(0)
+      .describe("Zero-based continuation offset."),
   }),
   http: { method: "GET" },
   readOnly: true,
+  publicAgent: { expose: true, readOnly: true, requiresAuth: true },
   run: async (args): Promise<ListContentDatabasesResponse> => {
     const db = getDb();
     const query = args.query?.trim();
     const pattern = query ? `%${escapeLike(query.toLowerCase())}%` : null;
+    const exactTitle = args.title?.toLowerCase();
+    const resolvesExactly = !!(
+      args.databaseId ||
+      args.documentId ||
+      exactTitle
+    );
     const excludedDatabaseIds = new Set(
       [
         args.excludeDatabaseId?.trim(),
         ...(args.excludeDatabaseIds ?? []).map((id) => id.trim()),
       ].filter((id): id is string => !!id),
     );
-    // The same access + discovery filter the sidebar uses, so the picker shows
-    // owned AND shared/org databases and never a trashed/hidden one.
-    const queryBuilder = db
-      .select({
-        id: schema.contentDatabases.id,
-        documentId: schema.contentDatabases.documentId,
-        title: schema.documents.title,
-      })
-      .from(schema.contentDatabases)
-      .innerJoin(
-        schema.documents,
-        eq(schema.contentDatabases.documentId, schema.documents.id),
-      )
-      .where(
-        and(
-          accessFilter(schema.documents, schema.documentShares),
-          isNull(schema.documents.trashedAt),
-          documentDiscoveryFilter(),
-          isNull(schema.contentDatabases.deletedAt),
-          excludedDatabaseIds.size === 1
-            ? ne(
-                schema.contentDatabases.id,
-                Array.from(excludedDatabaseIds)[0]!,
-              )
-            : undefined,
-          pattern
-            ? sql`lower(${schema.documents.title}) LIKE ${pattern} ESCAPE '\\'`
-            : undefined,
-        ),
-      )
-      .orderBy(asc(schema.documents.position));
-
-    const rows = args.limit
-      ? await queryBuilder.limit(args.limit)
-      : await queryBuilder;
-
     const localTableSources =
       excludedDatabaseIds.size > 0
         ? await db
@@ -90,39 +105,165 @@ export default defineAction({
             .from(schema.contentDatabaseSources)
             .where(eq(schema.contentDatabaseSources.sourceType, "local-table"))
         : [];
-    const localTableTargetByDatabaseId = new Map(
-      localTableSources.map((source) => [
-        source.databaseId,
-        source.sourceTable,
-      ]),
-    );
-    const sourceChainIncludesExcludedDatabase = (databaseId: string) => {
-      const seen = new Set<string>();
-      let current: string | undefined = databaseId;
-      while (current && !seen.has(current)) {
-        if (excludedDatabaseIds.has(current)) return true;
-        seen.add(current);
-        current = localTableTargetByDatabaseId.get(current);
+    const excludedDatabaseRows =
+      excludedDatabaseIds.size > 0
+        ? await db
+            .select({ id: schema.contentDatabases.id })
+            .from(schema.contentDatabases)
+            .innerJoin(
+              schema.documents,
+              eq(schema.contentDatabases.documentId, schema.documents.id),
+            )
+            .where(
+              and(
+                accessFilter(schema.documents, schema.documentShares),
+                or(
+                  inArray(
+                    schema.contentDatabases.id,
+                    Array.from(excludedDatabaseIds),
+                  ),
+                  inArray(
+                    schema.contentDatabases.documentId,
+                    Array.from(excludedDatabaseIds),
+                  ),
+                ),
+              ),
+            )
+        : [];
+    const excludedSourceChainDatabaseIds = new Set([
+      ...excludedDatabaseIds,
+      ...excludedDatabaseRows.map((row) => row.id),
+    ]);
+    let expandedSourceChain = true;
+    while (expandedSourceChain) {
+      expandedSourceChain = false;
+      for (const source of localTableSources) {
+        if (
+          excludedSourceChainDatabaseIds.has(source.sourceTable) &&
+          !excludedSourceChainDatabaseIds.has(source.databaseId)
+        ) {
+          excludedSourceChainDatabaseIds.add(source.databaseId);
+          expandedSourceChain = true;
+        }
       }
-      return false;
-    };
+    }
 
-    const databases = rows
-      // Exclusion ids may be database ids OR database document ids — the
-      // settings panel only has the document id before any source exists.
-      .filter(
-        (row) =>
-          !excludedDatabaseIds.has(row.documentId) &&
-          !sourceChainIncludesExcludedDatabase(row.id),
-      )
-      .map((row) => ({
-        databaseId: row.id,
-        documentId: row.documentId,
-        // The document's live title (matches the sidebar) rather than the
-        // possibly-stale content_databases.title.
-        title: row.title ?? "Untitled database",
-      }));
+    // The same access + discovery filter the sidebar uses, so the picker shows
+    // owned AND shared/org databases and never a trashed/hidden one. Resolve
+    // source-chain exclusions before limiting so every page is truthfully full.
+    const where = and(
+      accessFilter(schema.documents, schema.documentShares),
+      isNull(schema.documents.trashedAt),
+      documentDiscoveryFilter(),
+      or(
+        eq(schema.documents.hideFromSearch, 0),
+        isNull(schema.documents.hideFromSearch),
+      ),
+      isNull(schema.contentDatabases.deletedAt),
+      isNull(schema.contentDatabases.systemRole),
+      args.spaceId
+        ? eq(schema.contentDatabases.spaceId, args.spaceId)
+        : undefined,
+      args.databaseId
+        ? eq(schema.contentDatabases.id, args.databaseId)
+        : undefined,
+      args.documentId
+        ? eq(schema.contentDatabases.documentId, args.documentId)
+        : undefined,
+      exactTitle
+        ? sql`lower(${schema.documents.title}) = ${exactTitle}`
+        : undefined,
+      excludedSourceChainDatabaseIds.size > 0
+        ? notInArray(
+            schema.contentDatabases.id,
+            Array.from(excludedSourceChainDatabaseIds),
+          )
+        : undefined,
+      excludedDatabaseIds.size > 0
+        ? notInArray(
+            schema.contentDatabases.documentId,
+            Array.from(excludedDatabaseIds),
+          )
+        : undefined,
+      pattern
+        ? or(
+            sql`lower(${schema.documents.title}) LIKE ${pattern} ESCAPE '\\'`,
+            sql`lower(${schema.documents.description}) LIKE ${pattern} ESCAPE '\\'`,
+          )
+        : undefined,
+    );
+    const baseQuery = () =>
+      db
+        .select({
+          id: schema.contentDatabases.id,
+          documentId: schema.contentDatabases.documentId,
+          title: schema.documents.title,
+          description: schema.documents.description,
+          spaceId: schema.contentDatabases.spaceId,
+        })
+        .from(schema.contentDatabases)
+        .innerJoin(
+          schema.documents,
+          eq(schema.contentDatabases.documentId, schema.documents.id),
+        )
+        .where(where)
+        .orderBy(
+          asc(schema.documents.position),
+          asc(schema.contentDatabases.id),
+        );
+
+    // Two visible matches are sufficient to reject an exact selector without
+    // materializing every duplicate-title row.
+    const rows = resolvesExactly
+      ? await baseQuery().limit(2)
+      : await baseQuery().limit(args.limit).offset(args.offset);
+
+    if (resolvesExactly && rows.length !== 1) {
+      const selector = args.databaseId
+        ? `database ID "${args.databaseId}"`
+        : args.documentId
+          ? `document ID "${args.documentId}"`
+          : `title "${args.title?.trim()}"`;
+      throw new ContentDatabaseResolutionError(
+        rows.length === 0
+          ? `No accessible Content database matched exact ${selector}.`
+          : `Exact ${selector} is ambiguous across multiple accessible Content databases.`,
+      );
+    }
 
-    return { databases };
+    const databases = rows.map((row) => ({
+      databaseId: row.id,
+      documentId: row.documentId,
+      spaceId: row.spaceId,
+      // The document's live title (matches the sidebar) rather than the
+      // possibly-stale content_databases.title.
+      title: row.title ?? "Untitled database",
+      description: row.description,
+    }));
+
+    const totalItems = resolvesExactly
+      ? databases.length
+      : Number(
+          (
+            await db
+              .select({ count: sql<number>`count(*)` })
+              .from(schema.contentDatabases)
+              .innerJoin(
+                schema.documents,
+                eq(schema.contentDatabases.documentId, schema.documents.id),
+              )
+              .where(where)
+          )[0]?.count ?? 0,
+        );
+
+    return {
+      databases,
+      pagination: documentDiscoveryPagination({
+        offset: resolvesExactly ? 0 : args.offset,
+        limit: args.limit,
+        totalItems,
+        returnedItems: databases.length,
+      }),
+    };
   },
 });