pyric 0.1.0-alpha.21 → 0.1.0-alpha.24

package/src/firestore/reads.ts

@@ -5,6 +5,7 @@
  * any converter, and hand back a snapshot rehydrated to the modular-SDK
  * shape (see `snapshots.ts`).
  */
+import { withFirestoreFirebaseError } from './errors.js';
 import type {
   AdminDocumentSnapshot as ChainDocSnap,
   AdminQuerySnapshot as ChainQuerySnap,
@@ -33,63 +34,95 @@ import type {
   FirestoreDataConverter,
 } from './types.js';
 import { clientStateFor } from './client-state.js';
+import { beginFirestoreActivity } from './sdk-activity.js';
+import { finishSdkRead, type SdkActivityHandle } from '../sandbox/internal/sdk-activity.js';
 
-export async function getDoc<T = DocumentData>(ref: DocumentReference<T>): Promise<DocumentSnapshot<T>> {
+export function getDoc<T = DocumentData>(ref: DocumentReference<T>): Promise<DocumentSnapshot<T>> {
+  return readDocumentAs(ref, 'getDoc');
+}
+
+/** Keep served aliases on the same backend path while preserving their public name. */
+export async function readDocumentAs<T = DocumentData>(ref: DocumentReference<T>, method: string): Promise<DocumentSnapshot<T>> {
+  return readDocument(ref, beginFirestoreActivity(targetOf(ref), ref, method, 'operation'));
+}
+
+/** Shared executor; the public caller supplies its own activity identity. */
+export async function readDocument<T = DocumentData>(ref: DocumentReference<T>, activity: SdkActivityHandle): Promise<DocumentSnapshot<T>> {
   const target = targetOf(ref);
   const client = clientStateFor(target);
   client.markStarted();
-  const conv = converterOf(ref);
-  const snap = await chainDocFor(target, ref).get();
-  client.cachePath(ref.path);
-  if (conv) {
-    return applyConverterToDocSnap(
-      snap as unknown as ChainDocSnap,
-      conv as FirestoreDataConverter<T>,
-      target,
-      'document',
-    );
+  try {
+    const conv = converterOf(ref);
+    const snap = await chainDocFor(target, ref).get();
+    client.cachePath(ref.path);
+    if (conv) {
+      return finishSdkRead(activity, applyConverterToDocSnap(
+        snap as unknown as ChainDocSnap,
+        conv as FirestoreDataConverter<T>,
+        target,
+        'document',
+      ));
+    }
+    tagSnapshotRefs(snap, target);
+    return finishSdkRead(activity, wrapSandboxDocSnap<T>(snap as object, target));
+  } catch (error) {
+    activity.fail();
+    throw error;
   }
-  tagSnapshotRefs(snap, target);
-  return wrapSandboxDocSnap<T>(snap as object, target);
 }
 
-export async function getDocs<T = DocumentData>(query: Query<T>): Promise<QuerySnapshot<T>> {
+export function getDocs<T = DocumentData>(query: Query<T>): Promise<QuerySnapshot<T>> {
+  return readQueryAs(query, 'getDocs');
+}
+
+/** Keep served aliases on the same backend path while preserving their public name. */
+export async function readQueryAs<T = DocumentData>(query: Query<T>, method: string): Promise<QuerySnapshot<T>> {
+  return readQuery(query, beginFirestoreActivity(targetOf(query), query, method, 'operation'));
+}
+
+/** Shared executor; the public caller supplies its own activity identity. */
+export async function readQuery<T = DocumentData>(query: Query<T>, activity: SdkActivityHandle): Promise<QuerySnapshot<T>> {
   const target = targetOf(query);
   const client = clientStateFor(target);
   client.markStarted();
-  const conv = converterOf(query);
-  const snap = await chainQueryFor(target, query).get();
-  client.cacheQuery(query as object);
-  if (conv) {
-    const c = conv as FirestoreDataConverter<T>;
-    const wrappedDocs = (snap as unknown as ChainQuerySnap).docs.map((d) =>
-      applyConverterToDocSnap(
-        d as unknown as ChainDocSnap,
-        c,
-        target,
-        'query-child',
-      ) as QueryDocumentSnapshot<T>,
-    );
-    const wrapped = tag({
-      size: wrappedDocs.length,
-      empty: wrappedDocs.length === 0,
-      docs: wrappedDocs,
-      metadata: client.querySnapshotMetadata(),
-    }, target);
-    for (const document of wrappedDocs) client.cachePath(document.ref.path);
-    recordQuerySnapshot(wrapped, snap as object, target, query as object, 'read');
-    return wrapped;
-  }
-  tagSnapshotRefs(snap, target);
-  const docs = (snap as unknown as ChainQuerySnap).docs;
-  for (const d of docs) {
-    client.cachePath(d.ref.path);
-    wrapSandboxDocSnap(d as object, target);
+  try {
+    const conv = converterOf(query);
+    const snap = await withFirestoreFirebaseError(() => chainQueryFor(target, query).get());
+    client.cacheQuery(query as object);
+    if (conv) {
+      const c = conv as FirestoreDataConverter<T>;
+      const wrappedDocs = (snap as unknown as ChainQuerySnap).docs.map((d) =>
+        applyConverterToDocSnap(
+          d as unknown as ChainDocSnap,
+          c,
+          target,
+          'query-child',
+        ) as QueryDocumentSnapshot<T>,
+      );
+      const wrapped = tag({
+        size: wrappedDocs.length,
+        empty: wrappedDocs.length === 0,
+        docs: wrappedDocs,
+        metadata: client.querySnapshotMetadata(),
+      }, target);
+      for (const document of wrappedDocs) client.cachePath(document.ref.path);
+      recordQuerySnapshot(wrapped, snap as object, target, query as object, 'read');
+      return finishSdkRead(activity, wrapped);
+    }
+    tagSnapshotRefs(snap, target);
+    const docs = (snap as unknown as ChainQuerySnap).docs;
+    for (const d of docs) {
+      client.cachePath(d.ref.path);
+      wrapSandboxDocSnap(d as object, target);
+    }
+    Object.defineProperty(snap, 'metadata', {
+      value: client.querySnapshotMetadata(),
+      configurable: true,
+    });
+    recordQuerySnapshot(snap as object, snap as object, target, query as object, 'read');
+    return finishSdkRead(activity, snap as unknown as QuerySnapshot<T>);
+  } catch (error) {
+    activity.fail();
+    throw error;
   }
-  Object.defineProperty(snap, 'metadata', {
-    value: client.querySnapshotMetadata(),
-    configurable: true,
-  });
-  recordQuerySnapshot(snap as object, snap as object, target, query as object, 'read');
-  return snap as unknown as QuerySnapshot<T>;
 }

package/src/firestore/refs.ts

@@ -17,10 +17,11 @@ import {
   buildSandboxShell,
   asChainColl,
   asChainDoc,
+  type Target,
 } from './state.js';
+import { DocumentReference } from './types.js';
 import type {
   Firestore,
-  DocumentReference,
   CollectionReference,
   Query,
   FirestoreDataConverter,
@@ -29,13 +30,33 @@ import {
   boundedActivityIdentity,
   registerActivityValue,
 } from './sandbox/activity-value-registry.js';
-import { registerReferenceQueryValue } from './sandbox/query-value-registry.js';
-import { copyQueryValueRegistration } from './sandbox/query-value-registry.js';
+import {
+  registerReferenceQueryValue,
+  copyQueryValueRegistration,
+} from './sandbox/query-value-registry.js';
+import { attachConverterMethod, convertedView } from './converter-method.js';
 
-function registerDocumentValue<T extends object>(ref: T, path: string, owner: object): T {
-  registerActivityValue(ref, boundedActivityIdentity('reference', path));
-  registerReferenceQueryValue(ref, path, owner);
-  return ref;
+function registerDocumentValue<T extends { id: string; path: string }>(
+  ref: T,
+  path: string,
+  owner: Target,
+  converter: FirestoreDataConverter<unknown> | null = null,
+) {
+  function convert<A, D extends DocumentData = DocumentData>(converter: FirestoreDataConverter<A, D>): DocumentReference<A>;
+  function convert(converter: null): DocumentReference<DocumentData>;
+  function convert(converter: FirestoreDataConverter<unknown> | null): DocumentReference<unknown> {
+    const removesConverter = converter === null;
+    if (removesConverter) return withConverter(reference, null);
+    return withConverter(reference, converter);
+  }
+  // Modular methods must live outside the Admin error-translation proxy.
+  const underlying = underlyingOf(ref) as { id?: string; path?: string };
+  const shell = buildSandboxShell(underlying, owner, converter);
+  const reference = Object.assign(shell, { withConverter: convert });
+  registerActivityValue(reference, boundedActivityIdentity('reference', path));
+  registerReferenceQueryValue(underlying, path, owner);
+  copyQueryValueRegistration(underlying, reference);
+  return reference;
 }
 
 // ─── Path constructors ────────────────────────────────────────────────
@@ -51,35 +72,33 @@ export function doc<T = DocumentData>(
   const conv = isHandle ? undefined : converterOf(parent);
   const db = sandboxDb(target);
   if (isHandle) {
-    if (pathSegments.length === 0) {
+    const hasNoPath = pathSegments.length === 0;
+    if (hasNoPath) {
       throw new TypeError('doc(db, path) requires at least one path segment.');
     }
     const path = pathSegments.join('/');
     const built = db.doc(path);
     const tagged = tagSandboxRef(
-      built as object,
+      built,
       target,
-      (fresh) => fresh.doc(path) as unknown as object,
+      (fresh) => fresh.doc(path),
     );
     return registerDocumentValue(tagged, path, target) as DocumentReference<T>;
   }
   const coll = asChainColl(underlyingOf(parent));
-  const ref = pathSegments.length === 0
-    ? coll.doc()
-    : coll.doc(pathSegments.join('/'));
-  const absPath = (ref as { path: string }).path;
+  const createsId = pathSegments.length === 0;
+  let ref;
+  if (createsId) ref = coll.doc();
+  else ref = coll.doc(pathSegments.join('/'));
+  const absPath = ref.path;
   const tagged = tagSandboxRef(
-    ref as object,
+    ref,
     target,
-    (fresh) => fresh.doc(absPath) as unknown as object,
+    (fresh) => fresh.doc(absPath),
   );
-  if (conv) {
-    const shell = buildSandboxShell(
-      tagged as { id: string; path: string },
-      target,
-      conv,
-    );
-    return registerDocumentValue(shell, absPath, target) as DocumentReference<T>;
+  const hasConverter = conv !== undefined && conv !== null;
+  if (hasConverter) {
+    return registerDocumentValue(tagged, absPath, target, conv) as DocumentReference<T>;
   }
   return registerDocumentValue(tagged, absPath, target) as DocumentReference<T>;
 }
@@ -94,7 +113,7 @@ export function doc<T = DocumentData>(
  */
 export function collectionGroup(db: Firestore, collectionId: string): Query {
   const target = targetOf(db);
-  const q = sandboxDb(target).collectionGroup(collectionId);
+  const q = attachConverterMethod(sandboxDb(target).collectionGroup(collectionId));
   return tagSandboxRef(
     q as unknown as Query,
     target,
@@ -114,19 +133,19 @@ export function collection(parent: Firestore | DocumentReference, ...pathSegment
   // A parent doc's T describes its own data, not its subcollections'.
   if (isHandle) {
     const path = pathSegments.join('/');
-    const built = sandboxDb(target).collection(path);
+    const built = attachConverterMethod(sandboxDb(target).collection(path));
     return tagSandboxRef(
-      built as CollectionReference,
+      built as unknown as CollectionReference,
       target,
       (fresh) => fresh.collection(path) as unknown as object,
     );
   }
   const docRef = asChainDoc(underlyingOf(parent));
   const subPath = pathSegments.join('/');
-  const built = docRef.collection(subPath);
+  const built = attachConverterMethod(docRef.collection(subPath));
   const absPath = (built as { path: string }).path;
   return tagSandboxRef(
-    built as CollectionReference,
+    built as unknown as CollectionReference,
     target,
     (fresh) => fresh.collection(absPath) as unknown as object,
   );
@@ -134,9 +153,8 @@ export function collection(parent: Firestore | DocumentReference, ...pathSegment
 
 // ─── withConverter (typed refs / queries) ────────────────────────────
 //
-// Modular Web-SDK shape (the JS SDK exposes it as a method on the ref;
-// pyric exposes it as a free function for consistency with the rest of
-// the surface, where every operation routes through a free call):
+// Document references expose the Firebase-shaped method. This free function
+// remains available for existing document, collection, and query callers:
 //
 //   interface UserDb { name: string; createdAt: Timestamp; }
 //   interface User    { name: string; createdAt: Date; }
@@ -161,8 +179,8 @@ export function collection(parent: Firestore | DocumentReference, ...pathSegment
 //   - `getDoc` / `getDocs` invoke `fromFirestore` on each result.
 //   - `updateDoc` does NOT run the converter (matches JS SDK; partial
 //     writes don't have a typed home).
-//   - Passing `null` strips an existing converter, returning the
-//     underlying untyped ref.
+//   - Passing `null` strips an existing converter while retaining a
+//     usable untyped reference.
 
 export function withConverter<AppModel, DbModel extends DocumentData = DocumentData>(
   ref: DocumentReference<DocumentData>,
@@ -193,13 +211,10 @@ export function withConverter(
   converter: FirestoreDataConverter<unknown, DocumentData> | null,
 ): object {
   const target = targetOf(source);
-  if (converter === null) {
-    // Strip — return the underlying plain ref. Falls back to `source`
-    // itself if it was never wrapped (no-op).
-    return underlyingOf(source);
-  }
   const underlying = underlyingOf(source) as { id?: string; path?: string };
-  const shell = buildSandboxShell(underlying, target, converter);
-  copyQueryValueRegistration(underlying, shell);
-  return shell;
+  const isDocument = underlying instanceof DocumentReference;
+  if (isDocument) {
+    return registerDocumentValue(underlying, underlying.path, target, converter);
+  }
+  return convertedView(source, converter);
 }

package/src/firestore/sandbox/activity-query-display.ts

@@ -0,0 +1,138 @@
+/**
+ * Display projection of a captured Firestore query operand.
+ *
+ * PURE. `activity-query-value.ts` reduces an operand to a fixed-size digest so
+ * two reads of the same query compare equal without the diagnostic ever
+ * observing user code. A digest cannot be read back, so a surface that shows
+ * the developer the query they wrote needs the operand itself.
+ *
+ * This module projects the CANONICAL snapshot `captureQueryOperand` already
+ * took at construction time, never the caller's object. That snapshot is plain
+ * frozen data — the same lifecycle point at which Firebase parses query values
+ * — so walking it runs no getter and can trip no Proxy trap. The projection is
+ * bounded in string length, entry count, and depth, so an attach event never
+ * retains an unbounded operand tree.
+ *
+ * The output is diagnostic only: nothing reads it back into a query, and no
+ * verdict, delivery, or query identity depends on it.
+ */
+
+/** How much of one string operand a display value carries. */
+const MAX_STRING = 200;
+/** How many entries of one array or map operand a display value carries. */
+const MAX_ENTRIES = 10;
+/** How deep into a nested operand a display value reaches. */
+const MAX_DEPTH = 4;
+
+/** One operand as a surface can print it. Tagged so a renderer never has to
+ *  guess whether `12` was a number or a string. */
+export type QueryDisplayValue =
+  | { readonly type: 'string'; readonly value: string; readonly truncated?: true }
+  | { readonly type: 'number'; readonly value: number }
+  | { readonly type: 'boolean'; readonly value: boolean }
+  | { readonly type: 'null' }
+  | { readonly type: 'reference'; readonly path: string }
+  | { readonly type: 'timestamp'; readonly iso: string }
+  | { readonly type: 'geoPoint'; readonly latitude: number; readonly longitude: number }
+  | { readonly type: 'bytes'; readonly length: number }
+  | { readonly type: 'vector'; readonly length: number }
+  | {
+    readonly type: 'array';
+    readonly values: readonly QueryDisplayValue[];
+    readonly truncated?: true;
+  }
+  | {
+    readonly type: 'map';
+    readonly entries: readonly (readonly [string, QueryDisplayValue])[];
+    readonly truncated?: true;
+  }
+  | { readonly type: 'opaque' };
+
+function displayString(value: string): QueryDisplayValue {
+  return value.length <= MAX_STRING
+    ? { type: 'string', value }
+    : { type: 'string', value: value.slice(0, MAX_STRING), truncated: true };
+}
+
+/** Seconds and nanoseconds as the ISO instant a surface prints. */
+function displayTimestamp(seconds: number, nanoseconds: number): QueryDisplayValue {
+  const millis = seconds * 1_000 + Math.floor(nanoseconds / 1_000_000);
+  if (!Number.isFinite(millis)) return { type: 'opaque' };
+  try {
+    return { type: 'timestamp', iso: new Date(millis).toISOString() };
+  } catch {
+    return { type: 'opaque' };
+  }
+}
+
+/** A value the registry recorded for a Pyric-owned operand: a reference, a
+ *  timestamp, a geo point, bytes, or a vector. */
+function displayRegistered(value: unknown): QueryDisplayValue {
+  if (typeof value !== 'object' || value === null) return { type: 'opaque' };
+  const record = value as Record<string, unknown>;
+  if (typeof record.path === 'string') return { type: 'reference', path: record.path };
+  if (record.type === 'timestamp'
+    && typeof record.seconds === 'number'
+    && typeof record.nanoseconds === 'number') {
+    return displayTimestamp(record.seconds, record.nanoseconds);
+  }
+  if (record.type === 'geo-point'
+    && typeof record.latitude === 'number'
+    && typeof record.longitude === 'number') {
+    return { type: 'geoPoint', latitude: record.latitude, longitude: record.longitude };
+  }
+  if (record.type === 'bytes' && Array.isArray(record.values)) {
+    return { type: 'bytes', length: record.values.length };
+  }
+  if (record.type === 'vector' && Array.isArray(record.values)) {
+    return { type: 'vector', length: record.values.length };
+  }
+  return { type: 'opaque' };
+}
+
+function project(value: unknown, depth: number): QueryDisplayValue {
+  if (value === null) return { type: 'null' };
+  if (typeof value === 'string') return displayString(value);
+  if (typeof value === 'number') return { type: 'number', value };
+  if (typeof value === 'boolean') return { type: 'boolean', value };
+  if (typeof value !== 'object') return { type: 'opaque' };
+  if (depth >= MAX_DEPTH) return { type: 'opaque' };
+
+  const record = value as Record<string, unknown>;
+  if (record.type === 'registered-firestore-value') return displayRegistered(record.value);
+  if (record.type === 'timestamp'
+    && typeof record.seconds === 'number'
+    && typeof record.nanoseconds === 'number') {
+    return displayTimestamp(record.seconds, record.nanoseconds);
+  }
+  if (record.type === 'bytes' && Array.isArray(record.values)) {
+    return { type: 'bytes', length: record.values.length };
+  }
+  if (record.type === 'array' && Array.isArray(record.values)) {
+    const values = record.values.slice(0, MAX_ENTRIES).map((entry) => project(entry, depth + 1));
+    return record.values.length > MAX_ENTRIES
+      ? { type: 'array', values, truncated: true }
+      : { type: 'array', values };
+  }
+  if (record.type === 'map' && Array.isArray(record.entries)) {
+    const entries = record.entries
+      .slice(0, MAX_ENTRIES)
+      .filter((entry): entry is [string, unknown] => Array.isArray(entry)
+        && typeof entry[0] === 'string')
+      .map(([key, entry]) => [key, project(entry, depth + 1)] as const);
+    return record.entries.length > MAX_ENTRIES
+      ? { type: 'map', entries, truncated: true }
+      : { type: 'map', entries };
+  }
+  return { type: 'opaque' };
+}
+
+/**
+ * Project one canonical query operand into its display value.
+ *
+ * The argument is the `value` of a `CapturedQueryOperand` — the comparison
+ * snapshot, not the caller's object.
+ */
+export function activityDisplayValue(canonical: unknown): QueryDisplayValue {
+  return project(canonical, 0);
+}

package/src/firestore/sandbox/admin-compat/batch.ts

@@ -4,12 +4,8 @@
  *
  * Ported from bench's `pilot/src/firestore-wrapper.ts:360-391`.
  *
- * Set semantics: `WriteBatch.set(ref, data)` translates to either
- * `'create'` (doc absent) or `'update'` (doc present) at queue time —
- * the simulator's `BatchOperationInput` accepts only
- * `'create' | 'update' | 'delete'`. The peek runs in the wrapper
- * thread (single-threaded; the simulator is synchronous), so no other
- * write can interleave between peek and queue.
+ * Set writes retain replacement intent until commit. The engine selects
+ * the create/update rule from the document's state at commit time.
  *
  * Error translation: `LocalEnvironment.batch(...)` returns a
  * `BatchResult` whose `.error` carries a typed `FirestoreSimError`
@@ -22,12 +18,14 @@
 import type { LocalEnvironment } from 'pyric/sandbox/internal';
 import type { BatchOperationInput } from 'pyric/sandbox/internal';
 import { makeError } from 'pyric/sandbox/internal';
+import { cloneDoc } from '../document-copy.js';
 import {
   FirestoreCompatError,
   type AuthContext,
   type DocumentData,
   type DocumentReference,
   type OperationOptions,
+  type SetOptions,
   type WriteBatch,
 } from './types.js';
 
@@ -42,18 +40,22 @@ export class WriteBatchImpl implements WriteBatch {
     private readonly bypassRules: boolean = false,
   ) {}
 
-  set(ref: DocumentReference, data: DocumentData): WriteBatch {
-    // Dispatch to create-or-update at queue time — same logic as
-    // DocumentRefImpl.set, kept here rather than shared because the
-    // batch path has no async wrapping.
-    const existing = this.env.getDocument(ref.path);
-    const method: 'create' | 'update' = existing === null ? 'create' : 'update';
-    this.ops.push({ method, path: ref.path, data });
+  set(ref: DocumentReference, data: DocumentData, options?: SetOptions): WriteBatch {
+    const operation: BatchOperationInput = { method: 'set', path: ref.path, data: cloneDoc(data) };
+    const mergeFields = options?.mergeFields;
+    const hasFieldMask = mergeFields !== undefined;
+    if (hasFieldMask) {
+      operation.merge = { mergeFields: [...mergeFields] };
+    } else {
+      const mergesAllFields = options?.merge === true;
+      if (mergesAllFields) operation.merge = true;
+    }
+    this.ops.push(operation);
     return this;
   }
 
   update(ref: DocumentReference, data: DocumentData): WriteBatch {
-    this.ops.push({ method: 'update', path: ref.path, data });
+    this.ops.push({ method: 'update', path: ref.path, data: cloneDoc(data) });
     return this;
   }
 
@@ -65,17 +67,22 @@ export class WriteBatchImpl implements WriteBatch {
   async commit(opts?: OperationOptions): Promise<void> {
     // Empty batch is a no-op — match Admin SDK behavior (commit() of an
     // empty WriteBatch resolves cleanly without a network round-trip).
-    if (this.ops.length === 0) return;
+    const isEmpty = this.ops.length === 0;
+    if (isEmpty) return;
+    const authOverride = opts?.auth;
+    const hasAuthOverride = authOverride !== undefined;
     const result = this.env.batch(
       this.ops,
-      opts?.auth !== undefined ? opts.auth : this.auth,
+      hasAuthOverride ? authOverride : this.auth,
       this.bypassRules,
     );
-    if (result.allowed) return;
+    const { allowed, error } = result;
+    if (allowed) return;
     // Surface the structured error if present (always present per
     // Item 6 — see errors.ts; first per-op error mirrored to top-level).
-    if (result.error) {
-      throw new FirestoreCompatError(result.error);
+    const hasError = error !== undefined;
+    if (hasError) {
+      throw new FirestoreCompatError(error);
     }
     // Defensive fallback — should be unreachable given Item 6's
     // invariant that every denial carries an error.

package/src/firestore/sandbox/admin-compat/query-comparison.ts

@@ -12,6 +12,7 @@ import type {
   QueryScope,
 } from '../query-execution.js';
 import type { Filter } from './types.js';
+import { assertQueryWhereFilter } from '../query-operators.js';
 
 export type ComparableQueryFilter =
   | (Extract<QueryFilter, { kind: 'where' }> & {
@@ -33,14 +34,14 @@ export function snapshotFilter(
   filter: Filter | QueryFilter | ComparableQueryFilter,
   owner?: object,
 ): ComparableQueryFilter {
-  if (filter.kind === 'where') {
-    const comparisonValue = 'comparisonValue' in filter
+  const isWhereFilter = filter.kind === 'where';
+  if (isWhereFilter) {
+    assertQueryWhereFilter(filter.op, filter.value);
+    const hasCapturedOperand = 'comparisonValue' in filter;
+    const usesListOperand = filter.op === 'in' || filter.op === 'not-in';
+    const comparisonValue = hasCapturedOperand
       ? filter.comparisonValue
-      : captureQueryOperand(
-        filter.value,
-        owner,
-        filter.op === 'in' || filter.op === 'not-in',
-      );
+      : captureQueryOperand(filter.value, owner, usesListOperand);
     return Object.freeze({
       kind: 'where',
       field: filter.field,
@@ -52,7 +53,7 @@ export function snapshotFilter(
   return Object.freeze({
     kind: filter.kind,
     filters: Object.freeze(filter.filters.map((nested) => snapshotFilter(nested, owner))),
-  }) as ComparableQueryFilter;
+  });
 }
 
 export function snapshotCursor(