@opengeni/core 3.0.1 → 3.1.2

package/src/domain/insights.ts

@@ -11,6 +11,7 @@ import {
   countSessionsAttachedToGroups,
   enumerateUtcDays,
   enumerateUtcHours,
+  getSessionAccessProjection,
   listFloorSessions,
   listLiveWarmLeases,
   listScheduledTasks,
@@ -20,24 +21,42 @@ import {
   type Database,
 } from "@opengeni/db";
 
+import { measureInsightsPhase, type InsightsPhaseObserver } from "./insights-timing";
+export { measureInsightsPhase, workspaceInsightsPhaseMetricObserver } from "./insights-timing";
+export type { InsightsPhaseObservation, InsightsPhaseObserver } from "./insights-timing";
 const MACHINE_HEARTBEAT_FRESH_MS = 120_000;
 export const WORKSPACE_INSIGHTS_PROVIDER_FILTER_MAX_UTF8_BYTES = 256;
 export const WORKSPACE_INSIGHTS_MODEL_FILTER_MAX_UTF8_BYTES = 512;
 
-export type WorkspaceInsightsFilterField = "provider" | "model";
+export type WorkspaceInsightsFilterField = "provider" | "model" | "rootSessionId" | "sessionId";
 
 export class WorkspaceInsightsFilterValidationError extends Error {
   readonly field: WorkspaceInsightsFilterField;
   readonly maxUtf8Bytes: number;
 
-  constructor(field: WorkspaceInsightsFilterField, maxUtf8Bytes: number) {
-    super(`${field} must be at most ${maxUtf8Bytes} UTF-8 bytes`);
+  constructor(field: WorkspaceInsightsFilterField, maxUtf8Bytes: number, message?: string) {
+    super(message ?? `${field} must be at most ${maxUtf8Bytes} UTF-8 bytes`);
     this.name = "WorkspaceInsightsFilterValidationError";
     this.field = field;
     this.maxUtf8Bytes = maxUtf8Bytes;
   }
 }
 
+const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
+/** Normalize a session drilldown scope; only exact UUIDs are accepted. */
+export function normalizeWorkspaceInsightsSessionScope(
+  value: string | null | undefined,
+  field: "rootSessionId" | "sessionId",
+): string | null {
+  const normalized = value?.trim() || null;
+  if (normalized === null || normalized === "all") return null;
+  if (!UUID_PATTERN.test(normalized)) {
+    throw new WorkspaceInsightsFilterValidationError(field, 36, `${field} must be a UUID`);
+  }
+  return normalized.toLowerCase();
+}
+
 /** Normalize the public filter sentinel and enforce the database authority envelope. */
 export function normalizeWorkspaceInsightsFilter(
   value: string | null | undefined,
@@ -60,6 +79,14 @@ export type GetWorkspaceInsightsInput = {
   range: InsightsRange;
   provider?: string | null;
   model?: string | null;
+  rootSessionId?: string | null;
+  sessionId?: string | null;
+  /**
+   * Resolves the reading person, only once the rollup runs. The per-schedule
+   * list leaves out other people's Only me schedules; their usage stays in the
+   * per-person private totals.
+   */
+  viewerSubjectId?: () => Promise<string | null>;
   now?: Date;
 };
 
@@ -206,46 +233,100 @@ export function insightsSessionLabel(input: {
   return `${(input.depth ?? 0) > 0 ? "Agent" : "Session"} ${input.id.slice(0, 8)}`;
 }
 
+export function insightsProjectLabel(input: {
+  kind: "project" | "other" | "unfiled" | "unavailable" | "deleted";
+  name: string | null;
+  projects: number;
+}): string {
+  switch (input.kind) {
+    case "project":
+      return input.name?.trim() || "Untitled project";
+    case "other":
+      return `${input.projects.toLocaleString("en-US")} other ${input.projects === 1 ? "project" : "projects"}`;
+    case "unfiled":
+      return "No project";
+    case "unavailable":
+      return "Root session not visible";
+    case "deleted":
+      return "Deleted chats";
+  }
+}
+
 export async function getWorkspaceInsights(
   db: Database,
   settings: Settings,
   input: GetWorkspaceInsightsInput,
+  observePhase?: InsightsPhaseObserver,
 ): Promise<WorkspaceInsightsResponse> {
   const provider = normalizeWorkspaceInsightsFilter(input.provider, "provider");
   const model = normalizeWorkspaceInsightsFilter(input.model, "model");
-  await requireWorkspace(db, input.workspaceId);
+  const rootSessionId = normalizeWorkspaceInsightsSessionScope(
+    input.rootSessionId,
+    "rootSessionId",
+  );
+  const sessionId = normalizeWorkspaceInsightsSessionScope(input.sessionId, "sessionId");
+  await measureInsightsPhase(observePhase, "require_workspace", () =>
+    requireWorkspace(db, input.workspaceId),
+  );
+  const [visibleRootScope, visibleSessionScope] = await Promise.all([
+    rootSessionId ? getSessionAccessProjection(db, input.workspaceId, rootSessionId) : null,
+    sessionId ? getSessionAccessProjection(db, input.workspaceId, sessionId) : null,
+  ]);
   const now = input.now ?? new Date();
   const window = resolveRangeWindow(input.range, now);
   const modelFilterActive = Boolean(provider || model);
-  const filter = { provider, model };
+  const scopeActive = Boolean(rootSessionId || sessionId);
+  const filter = { provider, model, rootSessionId, sessionId };
 
   const [modelBundle, usageBundle, liveWarm, tasks, depth, floorRows, machinesOnline] =
     await Promise.all([
-      readWorkspaceInsightsModelBundle(db, {
-        workspaceId: input.workspaceId,
-        since: window.since,
-        until: window.until,
-        priorSince: window.priorSince,
-        priorUntil: window.priorUntil,
-        granularity: input.range === "today" ? "hour" : "day",
-        ...filter,
-      }),
-      readWorkspaceInsightsUsageBundle(db, {
-        workspaceId: input.workspaceId,
-        since: window.since,
-        until: window.until,
-        priorSince: window.priorSince,
-        priorUntil: window.priorUntil,
-        monthSince: startOfUtcMonth(now),
-        granularity: input.range === "today" ? "hour" : "day",
-        warmGroupLimit: 24,
-      }),
-      listLiveWarmLeases(db, input.workspaceId),
-      listScheduledTasks(db, input.workspaceId, 100),
-      aggregateSessionDepth(db, input.workspaceId),
-      listFloorSessions(db, input.workspaceId, 24),
+      measureInsightsPhase(observePhase, "model_bundle", () =>
+        readWorkspaceInsightsModelBundle(db, {
+          workspaceId: input.workspaceId,
+          since: window.since,
+          until: window.until,
+          priorSince: window.priorSince,
+          priorUntil: window.priorUntil,
+          granularity: input.range === "today" ? "hour" : "day",
+          ...filter,
+        }),
+      ),
+      measureInsightsPhase(observePhase, "usage_bundle", () =>
+        readWorkspaceInsightsUsageBundle(db, {
+          workspaceId: input.workspaceId,
+          since: window.since,
+          until: window.until,
+          priorSince: window.priorSince,
+          priorUntil: window.priorUntil,
+          monthSince: startOfUtcMonth(now),
+          granularity: input.range === "today" ? "hour" : "day",
+          warmGroupLimit: 24,
+        }),
+      ),
+      measureInsightsPhase(observePhase, "live_warm", () =>
+        listLiveWarmLeases(db, input.workspaceId),
+      ),
+      measureInsightsPhase(observePhase, "scheduled_tasks", () =>
+        (async () =>
+          await listScheduledTasks(
+            db,
+            input.workspaceId,
+            100,
+            0,
+            undefined,
+            input.viewerSubjectId ? await input.viewerSubjectId() : null,
+          ))(),
+      ),
+      measureInsightsPhase(observePhase, "session_depth", () =>
+        aggregateSessionDepth(db, input.workspaceId),
+      ),
+      measureInsightsPhase(observePhase, "floor_sessions", () =>
+        listFloorSessions(db, input.workspaceId, 24),
+      ),
       settings.sandboxSelfhostedEnabled
-        ? countOnlineMachines(db, input.workspaceId, MACHINE_HEARTBEAT_FRESH_MS, now)
+        ? measureInsightsPhase(observePhase, "online_machines", () =>
+            countOnlineMachines(db, input.workspaceId, MACHINE_HEARTBEAT_FRESH_MS, now),
+          )
         : Promise.resolve(0),
     ]);
 
@@ -255,10 +336,18 @@ export async function getWorkspaceInsights(
     factBuckets: factDays,
     rootDrivers,
     priorRootDrivers,
+    projects,
+    privateChats,
+    privateChatsTruncated,
     scheduleFacts,
     facets,
     recentCalls,
     promptContributions,
+    dataThrough,
+    driverGroups,
+    driversTruncated,
+    facetsTruncated,
+    recentCallsTruncated,
   } = modelBundle;
   const {
     workspaceCreditMicros,
@@ -271,17 +360,21 @@ export async function getWorkspaceInsights(
     agentRunsUsed,
   } = usageBundle;
   const [attached, fireCounts] = await Promise.all([
-    countSessionsAttachedToGroups(
-      db,
-      input.workspaceId,
-      warmGroups.map((group) => group.groupId),
+    measureInsightsPhase(observePhase, "attached_sessions", () =>
+      countSessionsAttachedToGroups(
+        db,
+        input.workspaceId,
+        warmGroups.map((group) => group.groupId),
+      ),
+    ),
+    measureInsightsPhase(observePhase, "scheduled_fires", () =>
+      countScheduledTaskFires(db, {
+        workspaceId: input.workspaceId,
+        since: window.since,
+        until: window.until,
+        taskIds: tasks.map((task) => task.id),
+      }),
     ),
-    countScheduledTaskFires(db, {
-      workspaceId: input.workspaceId,
-      since: window.since,
-      until: window.until,
-      taskIds: tasks.map((task) => task.id),
-    }),
   ]);
   const backendByGroup = new Map(liveWarm.map((lease) => [lease.groupId, lease.backend]));
   const warmSecondsByGroup = new Map(warmGroups.map((group) => [group.groupId, group.warmSeconds]));
@@ -345,6 +438,8 @@ export async function getWorkspaceInsights(
     0,
   );
   const modelCalls = modelRows.reduce((sum, row) => sum + row.calls, 0);
+  const cachedTokens = modelRows.reduce((sum, row) => sum + row.cachedTokens, 0);
+  const cacheInputTokens = modelRows.reduce((sum, row) => sum + row.cacheInputTokens, 0);
   const priorInputTokens = priorModelRows.reduce((sum, row) => sum + row.inputTokens, 0);
   const priorTotalTokens = priorModelRows.reduce((sum, row) => sum + row.totalTokens, 0);
   const priorCachedTokens = priorModelRows.reduce((sum, row) => sum + row.cachedTokens, 0);
@@ -373,9 +468,10 @@ export async function getWorkspaceInsights(
       cacheKnownCalls: 0,
       calls: 0,
     };
-    const modelCostMicros = modelFilterActive
-      ? facts.costMicros
-      : (usageBuckets.get(bucket)?.costMicros ?? facts.costMicros);
+    const modelCostMicros =
+      modelFilterActive || scopeActive
+        ? facts.costMicros
+        : (usageBuckets.get(bucket)?.costMicros ?? facts.costMicros);
     return {
       label: input.range === "today" ? bucket.slice(11) : bucket.slice(5),
       modelCostUsd: microsToUsd(modelCostMicros),
@@ -428,6 +524,20 @@ export async function getWorkspaceInsights(
     };
   });
 
+  const projectRows = projects.map((row) => ({
+    id: row.kind === "project" && row.channelId ? `project:${row.channelId}` : row.kind,
+    kind: row.kind,
+    label: insightsProjectLabel(row),
+    projects: row.projects,
+    rootSessions: row.rootSessions,
+    calls: row.calls,
+    creditUsd: microsToUsd(row.pricedCostMicros),
+    estimatedProviderUsd: microsToUsd(row.estimatedProviderCostMicros),
+    estimatedProviderCostKnownCalls: row.estimatedProviderCostKnownCalls,
+    tokens: row.totalTokens,
+    cacheHitPct: cacheHitPct(row.cachedTokens, row.cacheInputTokens),
+  }));
+
   const scheduleFactById = new Map(scheduleFacts.map((row) => [row.scheduledTaskId, row] as const));
   const schedules = tasks.map((task) => {
     const fact = scheduleFactById.get(task.id);
@@ -488,6 +598,9 @@ export async function getWorkspaceInsights(
       sessions: bucket.sessions,
     })),
     drivers,
+    projects: projectRows,
+    privateChats,
+    privateChatsTruncated,
     schedules,
     recentCalls: recentCalls.map((row) => ({
       id: row.id,
@@ -558,6 +671,7 @@ export async function getWorkspaceInsights(
     priorInputTokens,
     priorTotalTokens,
     priorCacheHitPct: cacheHitPct(priorCachedTokens, priorCacheInputTokens),
+    priorCacheInputTokens,
     priorCalls,
     goalsActive: depth.goalsActive,
     goalsCompleted: depth.goalsCompleted,
@@ -577,7 +691,17 @@ export async function getWorkspaceInsights(
     billableTokenCap: limits.maxMonthlyTokensPerWorkspace ?? null,
     agentRunsUsed,
     agentRunCap: limits.maxMonthlyAgentRunsPerWorkspace ?? null,
-    modelFilterActive,
+    modelFilterActive: modelFilterActive || scopeActive,
+    dataThrough: dataThrough?.toISOString() ?? null,
+    cacheHitPct: cacheHitPct(cachedTokens, cacheInputTokens),
+    scope: {
+      rootSessionId: visibleRootScope ? rootSessionId : null,
+      sessionId: visibleSessionScope ? sessionId : null,
+    },
+    driverGroups,
+    driversTruncated,
+    facetsTruncated,
+    recentCallsTruncated,
   });
 
   return { snapshot };

package/src/domain/knowledge-files.ts

@@ -12,6 +12,7 @@ export async function prepareKnowledgeFile(
   deps: Pick<ApiRouteDeps, "db" | "objectStorage" | "getDocumentServices">,
   context: KnowledgeContext,
   fileId: string,
+  purpose: "evidence" | "reference" = "evidence",
 ) {
   const inspected = await inspectKnowledgeFilePreparation(deps.db, context, fileId);
   if (inspected.status !== "prepare") return inspected;
@@ -27,13 +28,19 @@ export async function prepareKnowledgeFile(
   ) {
     throw new Error("The original file no longer matches its retained metadata");
   }
-  const parsed = await deps.getDocumentServices().parser.parse(object.bytes, inspected.file);
-  // Empty extraction is a visible failure, not a searchable-ready receipt.
-  if (!parsed.text.trim()) throw new Error("No searchable text could be extracted from this file");
+  // A screenshot/diagram can support a visual finding without containing text.
+  // Keep its exact original; OCR is neither required evidence nor the finding.
+  const originalOnly = purpose === "evidence" && inspected.file.contentType.startsWith("image/");
+  const parsed = originalOnly
+    ? { text: "" }
+    : await deps.getDocumentServices().parser.parse(object.bytes, inspected.file);
+  if (!originalOnly && !parsed.text.trim())
+    throw new Error("No searchable text could be extracted from this file");
   return completeKnowledgeFilePreparation(deps.db, context, {
     fileId,
     title: inspected.file.filename,
     sourceVersion,
     content: parsed.text,
+    purpose,
   });
 }

package/src/domain/knowledge-messages.ts

@@ -82,6 +82,7 @@ export async function retainKnowledgeMessage(
         content: text,
         source: {
           kind: "conversation",
+          purpose: "evidence",
           sessionId: event.sessionId,
           externalId: event.id,
           capturedAt: event.occurredAt,

package/src/domain/knowledge-preparation.test.ts

@@ -0,0 +1,276 @@
+import { expect, test } from "bun:test";
+import type { KnowledgeEntryRecord, KnowledgeEntrySummary } from "@opengeni/contracts";
+import { prepareKnowledgeSave } from "./knowledge-preparation";
+
+const context = {
+  accountId: "account",
+  workspaceId: "workspace",
+  actor: { kind: "human", review: true },
+} as never;
+const db = {} as never;
+const embedder = () => {
+  throw new Error("not used by fake search");
+};
+function group(title: string, parentIds: string[] = []): KnowledgeEntryRecord {
+  const id = crypto.randomUUID();
+  return {
+    id,
+    scope: "workspace",
+    version: 1,
+    publishedRevisionId: id,
+    latestRevisionId: id,
+    archived: false,
+    createdAt: "2026-09-14T00:00:00Z",
+    updatedAt: "2026-09-14T00:00:00Z",
+    revision: {
+      id,
+      entryId: id,
+      number: 1,
+      change: "upsert",
+      previousRevisionId: null,
+      restoredFromRevisionId: null,
+      createdAt: "2026-09-14T00:00:00Z",
+      createdBySessionId: null,
+      reviewBatchId: null,
+      outcome: "published",
+      entry: {
+        title,
+        kind: "group",
+        content: `Description of ${title}`,
+        groupIds: parentIds,
+        evidence: [],
+        relationships: [],
+      },
+    },
+  };
+}
+const summary = (record: KnowledgeEntryRecord) =>
+  ({
+    ...record,
+    revision: {
+      ...record.revision,
+      title: record.revision.entry.title,
+      kind: "group",
+      preview: "preview",
+      groupIds: record.revision.entry.groupIds,
+      sourceKind: null,
+    },
+    excerpts: [],
+  }) as KnowledgeEntrySummary;
+
+test("one read returns the complete paginated hierarchy and separately labeled duplicate candidates", async () => {
+  const parent = group("Engineering");
+  const child = group("Product UI", [parent.id]);
+  const pending = group("Proposed collection");
+  pending.revision.outcome = "pending";
+  const revoked = group("Revoked");
+  const calls: unknown[] = [];
+  const result = await prepareKnowledgeSave(
+    db,
+    context,
+    { query: "plugin setup consistency" },
+    embedder,
+    {
+      list: async (actualDb, actualContext, request) => {
+        expect(actualDb).toBe(db);
+        expect(actualContext).toBe(context);
+        calls.push(request);
+        if (request?.view === "needs_review")
+          return { entries: [summary(pending)], nextCursor: null };
+        return request?.cursor
+          ? { entries: [summary(child), summary(revoked)], nextCursor: null }
+          : { entries: [summary(parent)], nextCursor: "page2" };
+      },
+      get: async (_db, _context, id, options) => {
+        expect(options?.revisionId).toBeUndefined();
+        return [parent, child, pending].find((record) => record.id === id) ?? null;
+      },
+      search: async (_db, actualContext, request) => {
+        expect(actualContext).toBe(context);
+        expect(request.query).toBe("plugin setup consistency");
+        expect(request.groupId).toBeUndefined();
+        expect(request.scope).toBeUndefined();
+        return {
+          entries: [summary(request.view === "needs_review" ? pending : child)],
+          nextCursor: null,
+          searchMode: "hybrid",
+        };
+      },
+    },
+  );
+  expect(calls).toHaveLength(3);
+  expect(result.collections.complete).toBe(true);
+  expect(result.collections.entries.map((entry) => entry.title)).toEqual([
+    "Engineering",
+    "Product UI",
+    "Proposed collection",
+  ]);
+  expect(result.collections.entries[1]?.parentIds).toEqual([parent.id]);
+  expect(result.collections.entries[0]?.description).toBe("Description of Engineering");
+  expect(result.collections.entries[2]?.view).toBe("needs_review");
+  expect(result.matches.published.entries[0]?.id).toBe(child.id);
+  expect(result.matches.needs_review.entries[0]?.id).toBe(pending.id);
+});
+
+test("large collection maps explicitly continue and long descriptions report loss", async () => {
+  const record = group("Large collection");
+  record.revision.entry.content = "x".repeat(3000);
+  let count = 0;
+  const services: NonNullable<Parameters<typeof prepareKnowledgeSave>[4]> = {
+    list: async (_db, _context, request) => {
+      if (request?.view === "needs_review") return { entries: [], nextCursor: null };
+      return { entries: [summary(record)], nextCursor: `page${++count}` };
+    },
+    get: async () => record,
+    search: async () => ({ entries: [], nextCursor: null, searchMode: "keyword" }),
+  };
+  const result = await prepareKnowledgeSave(db, context, { query: "subject" }, embedder, services);
+  expect(result.collections.complete).toBe(false);
+  expect(result.collections.nextCursors.published).toBeTruthy();
+  expect(result.collections.nextCursors.needs_review).toBeNull();
+  expect(result.collections.entries[0]?.descriptionTruncated).toBe(true);
+  expect(result.collections.entries[0]?.description).toHaveLength(2000);
+  let requestedCursor: string | undefined;
+  await prepareKnowledgeSave(
+    db,
+    context,
+    { query: "subject", collectionCursors: result.collections.nextCursors },
+    embedder,
+    {
+      ...services,
+      list: async (_db, _context, request) => {
+        expect(request?.view).toBe("published");
+        requestedCursor = request?.cursor;
+        return { entries: [], nextCursor: null };
+      },
+    },
+  );
+  expect(requestedCursor).toBe(result.collections.nextCursors.published!);
+});
+
+test("a catalog authorization failure is not disguised as an empty complete map", async () => {
+  await expect(
+    prepareKnowledgeSave(db, context, { query: "subject" }, embedder, {
+      list: async () => {
+        throw new Error("access revoked");
+      },
+      get: async () => null,
+      search: async () => ({ entries: [], nextCursor: null, searchMode: "keyword" }),
+    }),
+  ).rejects.toThrow("access revoked");
+});
+
+test("read-only principals without proposal access fail before searching or embedding", async () => {
+  let touched = false;
+  await expect(
+    prepareKnowledgeSave(
+      db,
+      {
+        accountId: "account",
+        workspaceId: "workspace",
+        actor: { kind: "service", review: false },
+      } as never,
+      { query: "subject" },
+      () => {
+        touched = true;
+        throw new Error("must not embed");
+      },
+      {
+        list: async () => {
+          touched = true;
+          return { entries: [], nextCursor: null };
+        },
+        get: async () => {
+          touched = true;
+          return null;
+        },
+        search: async () => {
+          touched = true;
+          return { entries: [], nextCursor: null, searchMode: "keyword" };
+        },
+      },
+    ),
+  ).rejects.toMatchObject({ code: "42501" });
+  expect(touched).toBe(false);
+});
+
+test("published and pending searches reuse one query embedding", async () => {
+  let calls = 0;
+  await prepareKnowledgeSave(
+    db,
+    context,
+    { query: "plugin dialog" },
+    () => ({
+      model: "test",
+      dimensions: 2,
+      embedMany: async () => [],
+      embedQuery: async () => {
+        calls++;
+        return [1, 0];
+      },
+    }),
+    {
+      list: async () => ({ entries: [], nextCursor: null }),
+      get: async () => null,
+      search: async (_db, _context, request, queryEmbedder) => {
+        expect(await queryEmbedder().embedQuery(request.query!)).toEqual([1, 0]);
+        return { entries: [], nextCursor: null, searchMode: "hybrid" };
+      },
+    },
+  );
+  expect(calls).toBe(1);
+});
+
+test("a keyword fallback in the first view never retries an unfunded provider in the review view", async () => {
+  const searches: Array<{ mode: string | undefined; settingsProvided: boolean }> = [];
+  await prepareKnowledgeSave(
+    db,
+    context,
+    { query: "Acme renewal" },
+    () => {
+      throw new Error("An unfunded provider was called");
+    },
+    {
+      list: async () => ({ entries: [], nextCursor: null }),
+      get: async () => null,
+      search: async (_db, _context, request, _embedder, settings) => {
+        searches.push({ mode: request.mode, settingsProvided: !!settings });
+        return { entries: [], nextCursor: null, searchMode: "keyword" };
+      },
+    },
+    { documentEmbeddingProvider: "openai", documentEmbeddingBillingMode: "credits" } as never,
+  );
+  expect(searches).toEqual([
+    { mode: "keyword", settingsProvided: false },
+    { mode: "keyword", settingsProvided: false },
+  ]);
+});
+
+test("catalog rechecks current metadata after a collection changes", async () => {
+  const old = group("Old name");
+  const current = {
+    ...old,
+    version: 2,
+    revision: {
+      ...old.revision,
+      id: crypto.randomUUID(),
+      entry: { ...old.revision.entry, title: "New name" },
+    },
+  };
+  const result = await prepareKnowledgeSave(db, context, { query: "subject" }, embedder, {
+    list: async (_db, _context, request) => ({
+      entries: request?.view === "published" ? [summary(old)] : [],
+      nextCursor: null,
+    }),
+    get: async (_db, _context, _id, options) => {
+      expect(options?.revisionId).toBeUndefined();
+      return current;
+    },
+    search: async () => ({ entries: [], nextCursor: null, searchMode: "keyword" }),
+  });
+  expect(result.collections.entries[0]).toMatchObject({
+    title: "New name",
+    version: 2,
+    revisionId: current.revision.id,
+  });
+});