@cursor/july 0.1.108 → 0.1.109

package/src/internal/session-engine.ts

@@ -12,12 +12,6 @@ import { mkdir, rm, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import type { SDKCustomTool, SDKCustomToolResult } from "@cursor/sdk";
 import type { Meter } from "@opentelemetry/api";
-import {
-  type ABDefinition,
-  mergeABInstructions,
-  resolveABMaxPlaygroundSessions,
-  resolveABSplit,
-} from "../ab.js";
 import { SLACK_CHANNEL_ID } from "../channels/slack/constants.js";
 import { materializeSlackNudgeCarrier } from "../channels/slack/nudge-carrier.js";
 import {
@@ -98,9 +92,6 @@ import {
   type ToolNeedsApproval,
   type TurnOutcome,
 } from "../types.js";
-import { ABCollector } from "./ab-collector.js";
-import { foldABStream } from "./ab-fold.js";
-import { type ABSnapshot, buildABSnapshot } from "./ab-snapshot.js";
 import {
   type AdvertiseHostMcp,
   resolveAdvertisedTools,
@@ -455,8 +446,8 @@ export class SessionEngine {
   /**
    * Runtime for `agent/storage.ts` (`defineStorage`), when
    * authored. All durable state changes funnel through it (session
-   * records, event chunks, A/B samples/snapshots); the eval run store
-   * attaches via {@link StorageCoordinator.evalRuns} at serve start.
+   * records, event chunks); the eval run store attaches via
+   * {@link StorageCoordinator.evalRuns} at serve start.
    */
   readonly storage: StorageCoordinator | undefined;
   /** In-flight lazy restores, deduped per channel + continuation key. */
@@ -464,8 +455,6 @@ export class SessionEngine {
     string,
     Promise<SessionRecord | undefined>
   >();
-  /** Once-per-process cache for the A/B snapshot backfill (see abSnapshot). */
-  private restoredAbSnapshot: Promise<ABSnapshot | undefined> | undefined;
   /** In-flight authored files → Agent Store syncs (see syncToCloudStore). */
   private readonly cloudSyncs = new Map<CloudSyncSurface, Promise<boolean>>();
 
@@ -528,7 +517,6 @@ export class SessionEngine {
   private probeCursorAccount:
     | ((connection: string) => Promise<string | undefined>)
     | undefined;
-  private readonly abCollector: ABCollector;
   private readonly otel: OtelCollector | undefined;
   private readonly otelHost: HostOtelSessionApi;
   private readonly stopMemoryTelemetry: (() => void) | undefined;
@@ -639,13 +627,6 @@ export class SessionEngine {
       config: options.project.artifacts,
       sink: managedV2Files?.(),
     });
-    this.abCollector = new ABCollector(
-      options.project.abs,
-      this.logger,
-      async (sessionId) => (await this.logs.get(sessionId)).snapshot(0),
-      // Samples flow to the defineStorage `abs` table (no-op without one).
-      { persistSample: (sample) => this.storage?.abSample(sample) }
-    );
     // Peer and Cursor-account transports are symbolic until the serve host
     // resolves them; the host-side MCP registry starts with the concrete
     // connections and gains the rest via setResolvedConnections.
@@ -1138,7 +1119,7 @@ export class SessionEngine {
     const purpose = sendOptions.purpose === "eval" ? "eval" : "live";
     const frozenAsOf = normalizeAsOf(sendOptions.asOf);
     assertTimeArgs(this.project.agent.tools, frozenAsOf);
-    let record: SessionRecord = {
+    const record: SessionRecord = {
       sessionId: sendOptions.hostedSessionId ?? newSessionId(),
       channelId,
       mode: sendOptions.mode ?? "chat",
@@ -1167,7 +1148,6 @@ export class SessionEngine {
         dryRun: record.dryRun === true ? true : undefined,
       },
     });
-    record = await this.enrollABs(record);
     const since = (await this.logs.get(record.sessionId)).count;
     await this.startTurn(record.sessionId, message, {
       admission: sendOptions.admission ?? "preempt",
@@ -1241,97 +1221,6 @@ export class SessionEngine {
     return existing !== undefined;
   }
 
-  /**
-   * Sticky A/B enrollment at session creation — before the first turn, so
-   * variants are in the durable stream (and on {@link SessionRecord.abs})
-   * ahead of model/instructions work. Failures persist as `variant: null`
-   * (sticky skip). Eval harness sessions (`purpose: "eval"`) are never
-   * enrolled.
-   */
-  private async enrollABs(record: SessionRecord): Promise<SessionRecord> {
-    if (!this.abCollector.enabled || record.purpose === "eval") {
-      return record;
-    }
-    const sessionInfo = this.sessionInfo(record);
-    const abs: Record<string, string | null> = {};
-    for (const experiment of this.project.abs) {
-      const def = experiment.definition as ABDefinition;
-      const variantKeys = Object.keys(def.variants);
-      let variant: string | null = null;
-      try {
-        variant = await resolveABSplit(def.split, {
-          agent: { name: this.project.name },
-          channel: { id: record.channelId },
-          session: sessionInfo,
-          experiment: experiment.name,
-          variants: variantKeys,
-        });
-        if (variant !== null && !(variant in def.variants)) {
-          throw new Error(
-            `split resolved to ${JSON.stringify(variant)}; expected one of ${variantKeys.join(", ")} or null to skip`
-          );
-        }
-      } catch (error) {
-        this.logger(
-          `[agent-sdk] ab "${experiment.name}" enrollment failed (sticky skip): ${describeError(error)}`
-        );
-        variant = null;
-      }
-      abs[experiment.name] = variant;
-      await this.appendEvent(record.sessionId, {
-        type: "ab.assigned",
-        data: { experiment: experiment.name, variant },
-      });
-    }
-    return this.updateRecord(record.sessionId, (current) => ({
-      ...current,
-      abs,
-    }));
-  }
-
-  /**
-   * Ensure {@link SessionRecord.abs} is populated (hydrate from the durable
-   * `ab.assigned` stream when missing — e.g. older sessions after upgrade).
-   */
-  private async ensureAbs(record: SessionRecord): Promise<SessionRecord> {
-    if (record.abs !== undefined || record.purpose === "eval") {
-      return record;
-    }
-    if (!this.abCollector.enabled) {
-      return record;
-    }
-    const events = await this.listEvents(record.sessionId, 0);
-    const folded = foldABStream(events);
-    if (folded.arms.size === 0) {
-      return record;
-    }
-    const abs = Object.fromEntries(folded.arms);
-    return this.updateRecord(record.sessionId, (current) => ({
-      ...current,
-      abs,
-    }));
-  }
-
-  /**
-   * Agent config for this session: base project agent plus any per-variant
-   * `instructions` overlays from enrolled A/B arms.
-   */
-  private agentForSession(record: SessionRecord): ResolvedAgent {
-    const base = this.project.agent;
-    const instructions = mergeABInstructions(
-      base.instructions,
-      record.abs,
-      this.project.abs.map((experiment) => ({
-        name: experiment.name,
-        definition: experiment.definition as ABDefinition,
-      }))
-    );
-    if (instructions === base.instructions) {
-      return base;
-    }
-    return { ...base, instructions };
-  }
-
   /** Look up a session as a channel-scoped handle. */
   async getChannelSession(
     channelId: string,
@@ -1656,12 +1545,10 @@ export class SessionEngine {
 
     let lifecycleInstalled = false;
     try {
-      let record = await this.updateRecord(sessionId, (current) => ({
+      const record = await this.updateRecord(sessionId, (current) => ({
         ...current,
         turnCount: current.turnCount + 1,
       }));
-      // Arms must be on the record before tools/instructions see SessionInfo.
-      record = await this.ensureAbs(record);
       const turnId = `turn_${record.turnCount}`;
       const isFirstTurn = record.turnCount === 1;
 
@@ -2269,12 +2156,10 @@ export class SessionEngine {
       emit({ type: "turn.started", data: {} });
       try {
         // Scaffold agent files into the session workspace even when the harness
-        // cwd is overridden (e.g. a PR worktree). A/B variant instruction
-        // overlays are applied via agentForSession.
-        const agent = this.agentForSession(record);
+        // cwd is overridden (e.g. a PR worktree).
         if (!this.hasRootOverride()) {
           await materializeWorkspace({
-            agent,
+            agent: this.project.agent,
             workspaceDir,
             seed: isFirstTurn,
             stateRoot: this.stateRoot,
@@ -2296,7 +2181,7 @@ export class SessionEngine {
         const pendingFiles = record.pendingWorkspaceFiles;
         const pendingImages = record.pendingImages;
         const runtime = resolveSessionRuntime({
-          agentRuntime: agent.runtime,
+          agentRuntime: this.project.agent.runtime,
           cloudOverride: record.cloudOverride,
         });
         const hasPendingFiles =
@@ -2339,7 +2224,6 @@ export class SessionEngine {
             (await isNestedInGitRepo(harnessCwd)));
         const request = await this.buildTurnRequest(
           record,
-          agent,
           turnId,
           message,
           isFirstTurn,
@@ -2713,7 +2597,6 @@ export class SessionEngine {
 
   private async buildTurnRequest(
     record: SessionRecord,
-    agent: ResolvedAgent,
     turnId: string,
     prompt: string,
     isFirstTurn: boolean,
@@ -2724,6 +2607,7 @@ export class SessionEngine {
     signal: AbortSignal,
     images?: Array<{ data: string; mimeType: string }>
   ): Promise<RunnerTurnRequest> {
+    const agent = this.project.agent;
     // Per-session cloud attach (channel/tool handoff) forces cloud runtime
     // even when the agent defaults to local for chat server tools.
     const runtime = resolveSessionRuntime({
@@ -2931,9 +2815,7 @@ export class SessionEngine {
         ? {}
         : { sdkAgentId: record.sdkAgentId }),
       workspaceDir: this.harnessCwd(record),
-      sandbox: authoredRoot
-        ? false
-        : this.project.agent.local?.sandbox === true,
+      sandbox: authoredRoot ? false : agent.local?.sandbox === true,
       ...(runtime === "local" && harnessTools !== undefined
         ? {
             ...(harnessTools.tools === undefined
@@ -2966,13 +2848,7 @@ export class SessionEngine {
         : {}),
       customTools:
         runtime === "local"
-          ? await this.buildCustomTools(
-              record,
-              agent,
-              turnId,
-              emit,
-              synthesized
-            )
+          ? await this.buildCustomTools(record, turnId, emit, synthesized)
           : {},
       mcpServers: this.buildMcpServers(
         runtime,
@@ -3269,11 +3145,11 @@ export class SessionEngine {
 
   private async buildCustomTools(
     record: SessionRecord,
-    agent: ResolvedAgent,
     turnId: string,
     emit: (payload: SessionEventPayload) => void,
     extraTools: DiscoveredTool[] = []
   ): Promise<Record<string, SDKCustomTool>> {
+    const agent = this.project.agent;
     const tools: Record<string, SDKCustomTool> = {};
     const register = (tool: ResolvedAgent["tools"][number]): void => {
       tools[tool.name] = {
@@ -4796,14 +4672,6 @@ export class SessionEngine {
       }
     }
 
-    if (this.abCollector.enabled) {
-      await this.abCollector.onEvent(
-        event,
-        sessionCtx.session,
-        this.project.name
-      );
-    }
-
     this.otel?.onEvent(event, sessionCtx.session);
   }
 
@@ -5123,61 +4991,6 @@ export class SessionEngine {
       });
   }
 
-  /**
-   * Fold durable session streams into per-session A/B assignments and
-   * aggregate arm metrics (`GET /v1/abs`). Collector-independent: always
-   * reads `events.ndjson`.
-   */
-  async abSnapshot(
-    caller: AuthContext | null,
-    options?: { includeAll?: boolean }
-  ): Promise<ABSnapshot> {
-    const sessions = await this.listSessions(caller, options);
-    const abConfig = this.project.abConfig;
-    const maxPlaygroundSessions = resolveABMaxPlaygroundSessions(
-      abConfig?.maxPlaygroundSessions
-    );
-    const foldedSessions = sessions.slice(0, maxPlaygroundSessions);
-    // Backfill for a replacement host with nothing local to fold (e.g.
-    // lazy-only restore before any session resumed): serve the persisted
-    // aggregate instead of an empty surface. Gated on the host having no
-    // sessions AT ALL — the persisted snapshot spans every principal, so a
-    // caller who merely owns no sessions must not see it. Loaded once per
-    // process (playground polls this route ~every 4s); skip the persist
-    // side effect below — re-saving a restored snapshot would echo stale
-    // data back into the store.
-    if (
-      foldedSessions.length === 0 &&
-      this.storage !== undefined &&
-      (await this.sessions.list()).length === 0
-    ) {
-      this.restoredAbSnapshot ??= this.storage.getLatestAbSnapshot();
-      const restoredSnapshot = await this.restoredAbSnapshot;
-      if (restoredSnapshot !== undefined) {
-        return restoredSnapshot;
-      }
-    }
-    const abTable = this.project.storage?.abs;
-    const snapshot = await buildABSnapshot({
-      experiments: this.project.abs,
-      agentName: this.project.name,
-      sessions: foldedSessions,
-      loadRecord: (sessionId) => this.sessions.get(sessionId),
-      loadEvents: (sessionId) => this.listEvents(sessionId, 0),
-      sessionInfo: (record) => this.sessionInfo(record),
-      logger: this.logger,
-      config: {
-        maxPlaygroundSessions,
-        durableSamples: abTable !== undefined,
-        durableSnapshots: abTable?.putSnapshot !== undefined,
-      },
-    });
-    // Side effect on the read path: playground polls GET /v1/abs ~every 4s;
-    // the coordinator throttles the actual table write.
-    this.storage?.abSnapshot(snapshot);
-    return snapshot;
-  }
-
   async eventStream(
     sessionId: string,
     startIndex = 0
@@ -5437,7 +5250,6 @@ export class SessionEngine {
       asOf: record.asOf,
       auth: record.auth,
       continuationKey: record.continuationKey,
-      ...(record.abs === undefined ? {} : { abs: record.abs }),
       ...(record.title === undefined ? {} : { title: record.title }),
       ...(record.sdkAgentId === undefined
         ? {}
@@ -5539,9 +5351,9 @@ export class SessionEngine {
    * serve start, before channels accept traffic: any persisted session
    * missing from the local `--state-root` is materialized there — events
    * as `events.ndjson`, record as `session.json` — after which every
-   * existing read path (continuation lookup, event replay/streams, A/B
-   * fold hydration) works unchanged. Local state always wins over the
-   * sink, so restarts on the same host are no-ops.
+   * existing read path (continuation lookup, event replay/streams) works
+   * unchanged. Local state always wins over the sink, so restarts on the
+   * same host are no-ops.
    *
    * Failures are logged and skipped; a broken store (including rows that
    * violate the SessionRecord shape) never blocks serve start.

package/src/internal/storage-coordinator.ts

@@ -11,19 +11,17 @@
  * must never stall or fail a turn.
  *
  * Scaling shape: sessions reduce to keyed puts on the KV sink; eval runs
- * and A/B metrics go to their dedicated tables (`evals` / `abs`).
- * Reminder documents live on the control plane. Everything shares one
- * bounded, serialized queue.
+ * go to their dedicated `evals` table. Reminder documents live on the
+ * control plane. Everything shares one bounded, serialized queue.
  *
  * It does three unrelated jobs, declared separately as
  * {@link FrameworkSessionStore}, {@link AuthorKvStore}, and
- * {@link EvalAbStore} — see `storage-roles.ts` for why they differ and where
+ * {@link EvalStore} — see `storage-roles.ts` for why they differ and where
  * each is headed. The queue stays shared: it is one bounded, serialized chain
  * per agent, and splitting it would change backpressure behavior, which this
  * seam deliberately does not touch.
  */
 
-import type { ABMetricSample } from "../ab.js";
 import type { EvalRunSnapshot } from "../evals.js";
 import {
   type ResolvedStoragePolicy,
@@ -36,12 +34,11 @@ import {
 } from "../storage.js";
 import { isCursorHostedStorage } from "../storage-backends/cursor-hosted.js";
 import type { JsonValue, SessionEvent, SessionRecord } from "../types.js";
-import type { ABSnapshot } from "./ab-snapshot.js";
 import { describeError } from "./describe-error.js";
 import type { EvalRunStorage } from "./eval-run-store.js";
 import type {
   AuthorKvStore,
-  EvalAbStore,
+  EvalStore,
   FrameworkSessionStore,
 } from "./storage-roles.js";
 
@@ -71,13 +68,6 @@ const CLOSE_DRAIN_TIMEOUT_MS = 10_000;
 /** Debounced event batching flushes early past this many buffered events. */
 const DEBOUNCE_MAX_BATCH = 200;
 
-/**
- * Aggregate A/B snapshots are refreshed at most this often — the
- * playground polls `GET /v1/abs` every few seconds, and the snapshot is a
- * convenience backfill, not a source of truth.
- */
-const AB_SNAPSHOT_MIN_INTERVAL_MS = 60_000;
-
 /** One queued sink call (KV put/delete or a dedicated-table write). */
 interface StorageOp {
   /** Human-readable op label for failure logs, e.g. `put({root}/...)`. */
@@ -114,7 +104,7 @@ function sessionRecordsOf(entries: readonly StorageEntry[]): SessionRecord[] {
 }
 
 export class StorageCoordinator
-  implements FrameworkSessionStore, AuthorKvStore, EvalAbStore
+  implements FrameworkSessionStore, AuthorKvStore, EvalStore
 {
   readonly policy: ResolvedStoragePolicy;
 
@@ -136,7 +126,6 @@ export class StorageCoordinator
   private pending = 0;
   /** Ops dropped because the queue was full. */
   private dropped = 0;
-  private lastAbSnapshotAt = 0;
   private closed = false;
 
   constructor(options: StorageCoordinatorOptions) {
@@ -559,66 +548,6 @@ export class StorageCoordinator
     };
   }
 
-  // ==========================================================================
-  // A/Bs (dedicated `abs` table)
-  // ==========================================================================
-
-  /** Append one metric sample to the `abs` table (no-op without it). */
-  abSample(sample: ABMetricSample): void {
-    const table = this.definition.abs;
-    if (this.closed || table === undefined) {
-      return;
-    }
-    this.enqueue(
-      [
-        {
-          label: `abs.putSample(${sample.sessionId})`,
-          run: (ctx) => table.putSample(sample, ctx),
-        },
-      ],
-      "policy"
-    );
-  }
-
-  /**
-   * Refresh the persisted aggregate A/B snapshot, throttled to once per
-   * {@link AB_SNAPSHOT_MIN_INTERVAL_MS} (the playground recomputes the
-   * fold on every `GET /v1/abs` poll). No-op without `abs.putSnapshot`.
-   */
-  abSnapshot(snapshot: ABSnapshot): void {
-    const putSnapshot = this.definition.abs?.putSnapshot;
-    const now = Date.now();
-    if (
-      this.closed ||
-      putSnapshot === undefined ||
-      now - this.lastAbSnapshotAt < AB_SNAPSHOT_MIN_INTERVAL_MS
-    ) {
-      return;
-    }
-    this.lastAbSnapshotAt = now;
-    this.enqueue(
-      [{ label: "abs.putSnapshot", run: (ctx) => putSnapshot(snapshot, ctx) }],
-      "policy"
-    );
-  }
-
-  /** Latest persisted aggregate A/B snapshot; errors read as absent. */
-  async getLatestAbSnapshot(): Promise<ABSnapshot | undefined> {
-    const getSnapshot = this.definition.abs?.getSnapshot;
-    if (getSnapshot === undefined) {
-      return undefined;
-    }
-    try {
-      const value = await getSnapshot(this.context("restore"));
-      return value ?? undefined;
-    } catch (error) {
-      this.logger(
-        `[agent-sdk] storage abs.getSnapshot() failed: ${describeError(error)}`
-      );
-      return undefined;
-    }
-  }
-
   // ==========================================================================
   // Delivery
   // ==========================================================================

package/src/internal/storage-roles.ts

@@ -14,18 +14,16 @@
  * - {@link AuthorKvStore} is author state: whatever `ctx.host.kv` was handed.
  *   It converges onto the author file plane, which is a different destination
  *   from the one above.
- * - {@link EvalAbStore} is playground/experiment bookkeeping with its own
- *   dedicated tables, and follows neither.
+ * - {@link EvalStore} is playground eval bookkeeping with its own dedicated
+ *   table, and follows neither.
  *
  * Consumers should depend on the narrowest role they use. That is what keeps a
  * later change to framework persistence from silently reaching author KV, and
  * it is why these are interfaces rather than a comment on one class.
  */
 
-import type { ABMetricSample } from "../ab.js";
 import type { StorageContext } from "../storage.js";
 import type { JsonValue, SessionEvent, SessionRecord } from "../types.js";
-import type { ABSnapshot } from "./ab-snapshot.js";
 import type { EvalRunStorage } from "./eval-run-store.js";
 
 /**
@@ -84,10 +82,7 @@ export interface AuthorKvStore {
   kvDelete(authorKey: string): Promise<void>;
 }
 
-/** Playground eval batches and live A/B metrics, on their own tables. */
-export interface EvalAbStore {
+/** Playground eval batches, on their own table. */
+export interface EvalStore {
   evalRuns(): EvalRunStorage | undefined;
-  abSample(sample: ABMetricSample): void;
-  abSnapshot(snapshot: ABSnapshot): void;
-  getLatestAbSnapshot(): Promise<ABSnapshot | undefined>;
 }

package/src/storage-backends/cursor-hosted-v2.ts

@@ -25,9 +25,9 @@
  *   pagination. `list` / `listKeys` below drain every page, so the v1
  *   truncated-scan failure mode does not exist here.
  *
- * Eval runs and A/B samples still ride the v1 storage proxy's dedicated
- * tables (`evals` / `abs` below); moving them to factorydb is a separate
- * follow-up from the KV cutover.
+ * Eval runs still ride the v1 storage proxy's dedicated table (`evals`
+ * below); moving them to factorydb is a separate follow-up from the KV
+ * cutover.
  *
  * This backend is platform-selected for architecture v2
  * (framework-storage-selection.ts) — authors never import it; `agent/storage.ts`
@@ -35,7 +35,6 @@
  */
 
 import type {
-  StorageABTable,
   StorageCasTable,
   StorageConfig,
   StorageEntry,
@@ -85,7 +84,6 @@ type CursorHostedStorageV2Methods = Required<
   readonly [CURSOR_HOSTED_STORAGE]: true;
   cas: StorageCasTable;
   evals: StorageEvalsTable;
-  abs: StorageABTable;
 };
 
 function toCasResult(response: KvV2PutResponse): KvCasResult {
@@ -149,7 +147,7 @@ async function listAllPages(
 export function cursorHostedStorageV2(
   options: CursorHostedStorageOptions = {}
 ): CursorHostedStorageV2Methods {
-  // Eval runs and A/B samples stay on the v1 proxy's dedicated tables.
+  // Eval runs stay on the v1 proxy's dedicated table.
   const v1 = cursorHostedStorage(options);
   return {
     [CURSOR_HOSTED_STORAGE]: true,
@@ -214,6 +212,5 @@ export function cursorHostedStorageV2(
       },
     },
     evals: v1.evals,
-    abs: v1.abs,
   };
 }

package/src/storage-backends/cursor-hosted.ts

@@ -22,11 +22,9 @@
  * ```
  */
 
-import type { ABSnapshot } from "../ab.js";
 import type { EvalRunSnapshot } from "../evals.js";
 import { injectActiveTraceContext } from "../otel.js";
 import type {
-  StorageABTable,
   StorageCasTable,
   StorageConfig,
   StorageEntry,
@@ -114,7 +112,6 @@ type CursorHostedStorageMethods = Required<
   readonly [CURSOR_HOSTED_STORAGE]: true;
   cas: StorageCasTable;
   evals: StorageEvalsTable;
-  abs: StorageABTable;
 };
 
 // ============================================================================
@@ -417,39 +414,5 @@ export function cursorHostedStorage(
         return result.runs;
       },
     },
-    abs: {
-      async putSample(sample, ctx): Promise<void> {
-        await storageRpc(
-          options,
-          "/internal/agent-serve/storage/abs/put-sample",
-          {
-            agentName: ctx.agentName,
-            sample,
-          }
-        );
-      },
-      async putSnapshot(snapshot, ctx): Promise<void> {
-        await storageRpc(
-          options,
-          "/internal/agent-serve/storage/abs/put-snapshot",
-          {
-            agentName: ctx.agentName,
-            snapshot,
-          }
-        );
-      },
-      async getSnapshot(ctx): Promise<ABSnapshot | undefined> {
-        const result = await storageRpc<{
-          found: boolean;
-          snapshot: ABSnapshot | null;
-        }>(options, "/internal/agent-serve/storage/abs/get-snapshot", {
-          agentName: ctx.agentName,
-        });
-        if (!result.found) {
-          return undefined;
-        }
-        return result.snapshot ?? undefined;
-      },
-    },
   };
 }