@ponceca/firestore-sdk 0.1.0

package/dist/chunk-DXPQJR5D.mjs

@@ -0,0 +1,2469 @@
+import {
+  getPersistenceManager
+} from "./chunk-SZKHE2TQ.mjs";
+import {
+  getHttpClient
+} from "./chunk-C6SKWUQV.mjs";
+import {
+  DocumentSnapshotImpl,
+  QuerySnapshotImpl,
+  createDocumentSnapshot,
+  createQuerySnapshot,
+  toFirestoreFields,
+  toFirestoreValue
+} from "./chunk-C3PCJJX4.mjs";
+
+// src/firestore/reference.ts
+var DocumentReferenceImpl = class {
+  constructor(firestore, path, parent) {
+    this.type = "document";
+    this.firestore = firestore;
+    this.path = path;
+    this.id = path.split("/").pop() || "";
+    this.parent = parent;
+  }
+};
+var CollectionReferenceImpl = class {
+  constructor(firestore, path, parent = null) {
+    this.type = "collection";
+    this.firestore = firestore;
+    this.path = path;
+    this.id = path.split("/").pop() || "";
+    this.parent = parent;
+  }
+};
+function normalizePath(path) {
+  return path.replace(/\/+/g, "/").replace(/^\//, "").replace(/\/$/, "");
+}
+function validatePath(path, expectedType) {
+  const segments = path.split("/").filter((s) => s.length > 0);
+  if (segments.length === 0) {
+    throw new Error(`Invalid ${expectedType} path: path cannot be empty`);
+  }
+  for (const segment of segments) {
+    if (segment.startsWith(".")) {
+      throw new Error(`Invalid path segment: "${segment}" - segments cannot start with a dot`);
+    }
+    if (segment.includes("..")) {
+      throw new Error(`Invalid path segment: "${segment}" - segments cannot contain double dots`);
+    }
+  }
+  const isEven = segments.length % 2 === 0;
+  if (expectedType === "document" && !isEven) {
+    throw new Error(`Invalid document path: "${path}" - document paths must have an even number of segments`);
+  }
+  if (expectedType === "collection" && isEven) {
+    throw new Error(`Invalid collection path: "${path}" - collection paths must have an odd number of segments`);
+  }
+}
+function doc(firestoreOrRef, ...pathSegments) {
+  let firestore;
+  let fullPath;
+  if ("type" in firestoreOrRef && firestoreOrRef.type === "collection") {
+    const collRef = firestoreOrRef;
+    firestore = collRef.firestore;
+    if (pathSegments.length === 0) {
+      fullPath = `${collRef.path}/${generateId()}`;
+    } else {
+      fullPath = `${collRef.path}/${pathSegments.join("/")}`;
+    }
+  } else {
+    firestore = firestoreOrRef;
+    fullPath = pathSegments.join("/");
+  }
+  fullPath = normalizePath(fullPath);
+  validatePath(fullPath, "document");
+  const segments = fullPath.split("/");
+  const parentPath = segments.slice(0, -1).join("/");
+  const parentRef = new CollectionReferenceImpl(firestore, parentPath);
+  return new DocumentReferenceImpl(firestore, fullPath, parentRef);
+}
+function collection(firestoreOrRef, ...pathSegments) {
+  let firestore;
+  let fullPath;
+  let parentDoc = null;
+  if ("type" in firestoreOrRef && firestoreOrRef.type === "document") {
+    const docRef = firestoreOrRef;
+    firestore = docRef.firestore;
+    fullPath = `${docRef.path}/${pathSegments.join("/")}`;
+    parentDoc = docRef;
+  } else {
+    firestore = firestoreOrRef;
+    fullPath = pathSegments.join("/");
+  }
+  fullPath = normalizePath(fullPath);
+  validatePath(fullPath, "collection");
+  if (!parentDoc) {
+    const segments = fullPath.split("/").filter(Boolean);
+    if (segments.length >= 3) {
+      const parentPath = segments.slice(0, -1).join("/");
+      const parentCollectionPath = segments.slice(0, -2).join("/");
+      const parentCollection = new CollectionReferenceImpl(
+        firestore,
+        parentCollectionPath
+      );
+      parentDoc = new DocumentReferenceImpl(
+        firestore,
+        parentPath,
+        parentCollection
+      );
+    }
+  }
+  return new CollectionReferenceImpl(firestore, fullPath, parentDoc);
+}
+function generateId() {
+  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  let result = "";
+  for (let i = 0; i < 20; i++) {
+    result += chars.charAt(Math.floor(Math.random() * chars.length));
+  }
+  return result;
+}
+
+// src/firestore/local-write-tracker.ts
+var documentListeners = /* @__PURE__ */ new Map();
+function registerLocalWriteListener(path, listener) {
+  let listeners = documentListeners.get(path);
+  if (!listeners) {
+    listeners = /* @__PURE__ */ new Set();
+    documentListeners.set(path, listeners);
+  }
+  listeners.add(listener);
+  return () => {
+    const current = documentListeners.get(path);
+    if (!current) return;
+    current.delete(listener);
+    if (current.size === 0) {
+      documentListeners.delete(path);
+    }
+  };
+}
+function notifyLocalWrite(path) {
+  const listeners = documentListeners.get(path);
+  if (!listeners) return;
+  listeners.forEach((listener) => listener());
+}
+
+// src/firestore/utilities.ts
+function withConverter(reference, converter) {
+  const refWithConverter = Object.create(Object.getPrototypeOf(reference));
+  Object.assign(refWithConverter, reference);
+  refWithConverter.converter = converter;
+  return refWithConverter;
+}
+function refEqual(left, right) {
+  if (left === right) return true;
+  return left.firestore === right.firestore && left.path === right.path && left.type === right.type;
+}
+function queryEqual(left, right) {
+  if (left === right) return true;
+  if (left.firestore !== right.firestore) return false;
+  if (left.path !== right.path) return false;
+  if (left.type !== right.type) return false;
+  const leftConstraints = left.constraints || [];
+  const rightConstraints = right.constraints || [];
+  if (leftConstraints.length !== rightConstraints.length) return false;
+  return JSON.stringify(leftConstraints) === JSON.stringify(rightConstraints);
+}
+function snapshotEqual(left, right) {
+  if (left === right) return true;
+  const leftIsDoc = "ref" in left;
+  const rightIsDoc = "ref" in right;
+  if (leftIsDoc !== rightIsDoc) return false;
+  if (leftIsDoc && rightIsDoc) {
+    const l = left;
+    const r = right;
+    if (!refEqual(l.ref, r.ref)) return false;
+    if (l.exists() !== r.exists()) return false;
+    return JSON.stringify(l.data()) === JSON.stringify(r.data());
+  } else {
+    const l = left;
+    const r = right;
+    if (l.size !== r.size) return false;
+    for (let i = 0; i < l.docs.length; i++) {
+      if (!snapshotEqual(l.docs[i], r.docs[i])) {
+        return false;
+      }
+    }
+    return true;
+  }
+}
+function onSnapshotsInSync(firestore, onSync) {
+  let timeoutId = null;
+  let isActive = true;
+  const scheduleSync = () => {
+    if (!isActive) return;
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+    timeoutId = setTimeout(() => {
+      if (isActive) {
+        onSync();
+      }
+    }, 50);
+  };
+  const firestoreInternal = firestore;
+  if (!firestoreInternal._syncCallbacks) {
+    firestoreInternal._syncCallbacks = /* @__PURE__ */ new Set();
+  }
+  firestoreInternal._syncCallbacks.add(scheduleSync);
+  scheduleSync();
+  return () => {
+    isActive = false;
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+    firestoreInternal._syncCallbacks?.delete(scheduleSync);
+  };
+}
+function asQueryDocumentSnapshot(snapshot) {
+  if (!snapshot.exists()) {
+    return null;
+  }
+  return {
+    ...snapshot,
+    exists: () => true,
+    data: () => snapshot.data()
+  };
+}
+function applyConverterToDocumentSnapshot(snapshot, converter) {
+  if (!converter || !snapshot.exists()) {
+    return snapshot;
+  }
+  const querySnap = asQueryDocumentSnapshot(snapshot);
+  if (!querySnap) {
+    return snapshot;
+  }
+  const converted = converter.fromFirestore(querySnap);
+  return Object.assign(Object.create(Object.getPrototypeOf(snapshot)), snapshot, {
+    data: () => converted
+  });
+}
+function applyConverterToQuerySnapshot(snapshot, converter) {
+  if (!converter) {
+    return snapshot;
+  }
+  const convertedDocs = snapshot.docs.map(
+    (doc2) => applyConverterToDocumentSnapshot(doc2, converter)
+  );
+  const convertedChanges = snapshot.docChanges().map((change) => ({
+    ...change,
+    doc: applyConverterToDocumentSnapshot(
+      change.doc,
+      converter
+    )
+  }));
+  return Object.assign(Object.create(Object.getPrototypeOf(snapshot)), snapshot, {
+    docs: convertedDocs,
+    docChanges: () => convertedChanges
+  });
+}
+
+// src/firestore/crud.ts
+async function getDoc(reference) {
+  if (!reference || !reference.path) {
+    throw new Error("getDoc requires a valid DocumentReference");
+  }
+  const pm = getPersistenceManager(reference.firestore);
+  if (!pm) {
+    return getDocDirect(reference);
+  }
+  if (pm.isOnline) {
+    try {
+      const snapshot = await getDocDirect(reference);
+      await pm.cacheDocument(reference.path, snapshot.data() ?? null, snapshot.exists(), snapshot._updateTime);
+      const hasPending = await pm.hasPendingWrites(reference.path);
+      if (hasPending) {
+        return createSnapshotWithMetadata(reference, snapshot, { hasPendingWrites: true });
+      }
+      return snapshot;
+    } catch (error) {
+      const code = error?.code;
+      if (code === "unavailable" || code === "deadline-exceeded") {
+        return getDocFromLocalCache(reference, pm);
+      }
+      throw error;
+    }
+  }
+  return getDocFromLocalCache(reference, pm);
+}
+async function getDocDirect(reference) {
+  const client = getHttpClient(reference.firestore);
+  try {
+    const doc2 = await client.get(
+      `/documents/${reference.path}`
+    );
+    const snapshot = createDocumentSnapshot(reference, doc2);
+    return applyConverterToDocumentSnapshot(snapshot, getConverter(reference));
+  } catch (error) {
+    if (error.code === "not-found") {
+      const snapshot = createDocumentSnapshot(reference, null);
+      return applyConverterToDocumentSnapshot(snapshot, getConverter(reference));
+    }
+    throw error;
+  }
+}
+async function getDocFromLocalCache(reference, pm) {
+  const cached = await pm.getCachedDocument(reference.path);
+  if (cached) {
+    return new DocumentSnapshotImpl(
+      reference,
+      cached.exists ? cached.data : void 0,
+      cached.exists,
+      { fromCache: true, hasPendingWrites: await pm.hasPendingWrites(reference.path) },
+      cached.updateTime
+    );
+  }
+  return new DocumentSnapshotImpl(
+    reference,
+    void 0,
+    false,
+    { fromCache: true, hasPendingWrites: false }
+  );
+}
+async function getDocFromCache(reference) {
+  if (!reference || !reference.path) {
+    throw new Error("getDocFromCache requires a valid DocumentReference");
+  }
+  const pm = getPersistenceManager(reference.firestore);
+  if (!pm) {
+    throw createFirestoreError(
+      "failed-precondition",
+      "Failed to get document from cache. Persistence is not enabled."
+    );
+  }
+  const cached = await pm.getCachedDocument(reference.path);
+  if (!cached) {
+    throw createFirestoreError(
+      "unavailable",
+      "Failed to get document from cache. Document is not cached."
+    );
+  }
+  return await getDocFromLocalCache(reference, pm);
+}
+function createSnapshotWithMetadata(reference, source, metadata) {
+  return new DocumentSnapshotImpl(
+    reference,
+    source.data(),
+    source.exists(),
+    {
+      fromCache: metadata.fromCache ?? source.metadata.fromCache,
+      hasPendingWrites: metadata.hasPendingWrites ?? source.metadata.hasPendingWrites
+    },
+    source._updateTime
+  );
+}
+async function setDoc(reference, data, options) {
+  if (!reference || !reference.path) {
+    throw new Error("setDoc requires a valid DocumentReference");
+  }
+  if (!data || typeof data !== "object") {
+    throw new Error("setDoc requires a valid data object");
+  }
+  const dataToWrite = applyConverterToData(reference, data);
+  assertValidTypes(dataToWrite);
+  const client = getHttpClient(reference.firestore);
+  assertDocumentDepth(dataToWrite);
+  const fields = toFirestoreFields(dataToWrite);
+  assertDocumentSize(fields);
+  notifyLocalWrite(reference.path);
+  const pm = getPersistenceManager(reference.firestore);
+  if (pm) {
+    await pm.addLocalWrite("set", reference.path, dataToWrite, options);
+  }
+  const body = {
+    fields
+  };
+  const sendToServer = async () => {
+    if (options?.merge || options?.mergeFields) {
+      const fieldPaths = options.mergeFields || Object.keys(dataToWrite);
+      body.updateMask = { fieldPaths };
+      await client.patch(`/documents/${reference.path}`, body);
+    } else {
+      const parentPath = reference.path.split("/").slice(0, -1).join("/");
+      const documentId2 = reference.id;
+      await client.post(`/documents/${parentPath}?documentId=${documentId2}`, { fields });
+    }
+  };
+  if (pm && !pm.isOnline) {
+    return;
+  }
+  try {
+    await sendToServer();
+    if (pm) {
+      const mutations = await pm.mutations.getForPath(reference.path);
+      if (mutations.length > 0) {
+        await pm.completeMutation(mutations[mutations.length - 1].id);
+      }
+    }
+  } catch (error) {
+    if (pm) {
+      const code = error?.code;
+      if (code === "unavailable" || code === "deadline-exceeded") {
+        return;
+      }
+    }
+    throw error;
+  }
+}
+async function getDocFromServer(reference) {
+  const snapshot = await getDocDirect(reference);
+  const pm = getPersistenceManager(reference.firestore);
+  if (pm) {
+    await pm.cacheDocument(reference.path, snapshot.data() ?? null, snapshot.exists(), snapshot._updateTime);
+  }
+  return snapshot;
+}
+async function updateDoc(reference, dataOrField, ...moreFieldsAndValues) {
+  if (!reference || !reference.path) {
+    throw new Error("updateDoc requires a valid DocumentReference");
+  }
+  let data;
+  if (typeof dataOrField === "string") {
+    if (moreFieldsAndValues.length === 0 || moreFieldsAndValues.length % 2 === 0) {
+      throw createFirestoreError(
+        "invalid-argument",
+        "updateDoc with field/value pairs requires an even number of field/value arguments"
+      );
+    }
+    const obj = { [dataOrField]: moreFieldsAndValues[0] };
+    for (let i = 1; i < moreFieldsAndValues.length; i += 2) {
+      const field = moreFieldsAndValues[i];
+      if (typeof field !== "string") {
+        throw createFirestoreError(
+          "invalid-argument",
+          "Field paths must be strings in updateDoc"
+        );
+      }
+      obj[field] = moreFieldsAndValues[i + 1];
+    }
+    data = obj;
+  } else {
+    data = dataOrField;
+  }
+  if (!data || typeof data !== "object") {
+    throw new Error("updateDoc requires a valid data object");
+  }
+  const dataToWrite = applyConverterToData(reference, data);
+  assertValidTypes(dataToWrite);
+  const client = getHttpClient(reference.firestore);
+  assertDocumentDepth(dataToWrite);
+  const fields = toFirestoreFields(dataToWrite);
+  assertDocumentSize(fields);
+  notifyLocalWrite(reference.path);
+  const pm = getPersistenceManager(reference.firestore);
+  if (pm) {
+    await pm.addLocalWrite("update", reference.path, dataToWrite);
+  }
+  const fieldPaths = extractFieldPaths(dataToWrite);
+  const sendToServer = async () => {
+    await client.patch(`/documents/${reference.path}`, {
+      fields,
+      updateMask: { fieldPaths }
+    });
+  };
+  if (pm && !pm.isOnline) {
+    return;
+  }
+  try {
+    await sendToServer();
+    if (pm) {
+      const mutations = await pm.mutations.getForPath(reference.path);
+      if (mutations.length > 0) {
+        await pm.completeMutation(mutations[mutations.length - 1].id);
+      }
+    }
+  } catch (error) {
+    if (pm) {
+      const code = error?.code;
+      if (code === "unavailable" || code === "deadline-exceeded") {
+        return;
+      }
+    }
+    throw error;
+  }
+}
+function extractFieldPaths(data, prefix = "") {
+  const paths = [];
+  for (const [key, value] of Object.entries(data)) {
+    if (value === void 0) {
+      continue;
+    }
+    const fullPath = prefix ? `${prefix}.${key}` : key;
+    if (key.includes(".")) {
+      paths.push(key);
+    } else if (isFieldValueForExtract(value)) {
+      paths.push(fullPath);
+    } else if (value !== null && typeof value === "object" && !Array.isArray(value) && !(value instanceof Date)) {
+      paths.push(...extractFieldPaths(value, fullPath));
+    } else {
+      paths.push(fullPath);
+    }
+  }
+  return paths;
+}
+var MAX_DOCUMENT_SIZE_BYTES = 1024 * 1024;
+var MAX_DOCUMENT_DEPTH = 20;
+function createFirestoreError(code, message) {
+  const error = new Error(message);
+  error.code = code;
+  return error;
+}
+function assertDocumentSize(fields) {
+  const json = JSON.stringify({ fields });
+  const size = typeof TextEncoder !== "undefined" ? new TextEncoder().encode(json).length : json.length;
+  if (size > MAX_DOCUMENT_SIZE_BYTES) {
+    throw createFirestoreError("invalid-argument", "Document size exceeds 1 MiB");
+  }
+}
+function assertDocumentDepth(fields) {
+  if (getDepth(fields, 0) > MAX_DOCUMENT_DEPTH) {
+    throw createFirestoreError("invalid-argument", "Document exceeds maximum depth");
+  }
+}
+function assertValidTypes(data, path = "") {
+  if (data === void 0) {
+    return;
+  }
+  if (typeof data === "function") {
+    throw createFirestoreError(
+      "invalid-argument",
+      `Function setDoc() called with invalid data. Unsupported field value: a function${path ? ` (found in field ${path})` : ""}`
+    );
+  }
+  if (typeof data === "symbol") {
+    throw createFirestoreError(
+      "invalid-argument",
+      `Function setDoc() called with invalid data. Unsupported field value: a symbol${path ? ` (found in field ${path})` : ""}`
+    );
+  }
+  if (data === null) {
+    return;
+  }
+  if (Array.isArray(data)) {
+    for (let i = 0; i < data.length; i++) {
+      assertValidTypes(data[i], `${path}[${i}]`);
+    }
+    return;
+  }
+  if (typeof data === "object") {
+    if ("_type" in data && typeof data._type === "string") {
+      return;
+    }
+    for (const [key, value] of Object.entries(data)) {
+      const fieldPath = path ? `${path}.${key}` : key;
+      assertValidTypes(value, fieldPath);
+    }
+  }
+}
+function getDepth(value, current) {
+  if (value === null || value === void 0) {
+    return current;
+  }
+  if (Array.isArray(value)) {
+    let maxDepth = current;
+    for (const item of value) {
+      const depth = getDepth(item, current);
+      if (depth > maxDepth) {
+        maxDepth = depth;
+      }
+    }
+    return maxDepth;
+  }
+  if (typeof value === "object") {
+    let maxDepth = current + 1;
+    for (const item of Object.values(value)) {
+      const depth = getDepth(item, current + 1);
+      if (depth > maxDepth) {
+        maxDepth = depth;
+      }
+    }
+    return maxDepth;
+  }
+  return current;
+}
+function isFieldValueForExtract(value) {
+  return value !== null && typeof value === "object" && "_type" in value && typeof value._type === "string";
+}
+async function deleteDoc(reference) {
+  if (!reference || !reference.path) {
+    throw new Error("deleteDoc requires a valid DocumentReference");
+  }
+  const client = getHttpClient(reference.firestore);
+  notifyLocalWrite(reference.path);
+  const pm = getPersistenceManager(reference.firestore);
+  if (pm) {
+    await pm.addLocalWrite("delete", reference.path, null);
+  }
+  if (pm && !pm.isOnline) {
+    return;
+  }
+  try {
+    await client.delete(`/documents/${reference.path}`);
+    if (pm) {
+      const mutations = await pm.mutations.getForPath(reference.path);
+      if (mutations.length > 0) {
+        await pm.completeMutation(mutations[mutations.length - 1].id);
+      }
+    }
+  } catch (error) {
+    if (pm) {
+      const code = error?.code;
+      if (code === "unavailable" || code === "deadline-exceeded") {
+        return;
+      }
+    }
+    throw error;
+  }
+}
+async function addDoc(reference, data) {
+  if (!reference || !reference.path) {
+    throw new Error("addDoc requires a valid CollectionReference");
+  }
+  if (!data || typeof data !== "object") {
+    throw new Error("addDoc requires a valid data object");
+  }
+  const newId = generateId();
+  const docRef = doc(reference, newId);
+  const converter = getConverter(reference);
+  if (converter) {
+    docRef.converter = converter;
+  }
+  await setDoc(docRef, data);
+  return docRef;
+}
+function getConverter(reference) {
+  return reference.converter;
+}
+function applyConverterToData(reference, data) {
+  const converter = getConverter(reference);
+  return converter ? converter.toFirestore(data) : data;
+}
+
+// src/firestore/query.ts
+var QueryImpl = class {
+  constructor(firestore, path, constraints = []) {
+    this.firestore = firestore;
+    this.path = path;
+    this.constraints = constraints;
+    this.type = "query";
+  }
+};
+function query(reference, ...constraints) {
+  const existingConstraints = "constraints" in reference ? reference.constraints : [];
+  const allConstraints = [...existingConstraints, ...constraints];
+  validateQueryConflicts(allConstraints);
+  const newQuery = new QueryImpl(
+    reference.firestore,
+    reference.path,
+    allConstraints
+  );
+  const converter = reference.converter;
+  if (converter) {
+    newQuery.converter = converter;
+  }
+  return newQuery;
+}
+function validateQueryConflicts(constraints) {
+  const whereConstraints = constraints.filter((c) => c.type === "where");
+  let hasIn = false;
+  let hasNotIn = false;
+  let hasNotEqual = false;
+  let arrayContainsCount = 0;
+  for (const w of whereConstraints) {
+    if (w.op === "in") hasIn = true;
+    if (w.op === "not-in") hasNotIn = true;
+    if (w.op === "!=") hasNotEqual = true;
+    if (w.op === "array-contains") arrayContainsCount++;
+  }
+  if (hasIn && hasNotIn) {
+    throw new Error(`Invalid Query. You cannot use 'in' and 'not-in' filters in the same query.`);
+  }
+  if (hasNotEqual && hasNotIn) {
+    throw new Error(`Invalid Query. You cannot use '!=' and 'not-in' filters in the same query.`);
+  }
+  if (arrayContainsCount > 1) {
+    throw new Error(`Invalid Query. You cannot use more than one 'array-contains' filter in a single query.`);
+  }
+}
+var VALID_OPS = /* @__PURE__ */ new Set([
+  "<",
+  "<=",
+  "==",
+  "!=",
+  ">=",
+  ">",
+  "array-contains",
+  "array-contains-any",
+  "in",
+  "not-in"
+]);
+var ARRAY_LIMIT_OPS = /* @__PURE__ */ new Set(["in", "not-in", "array-contains-any"]);
+function where(field, op, value) {
+  if (!VALID_OPS.has(op)) {
+    throw new Error(`Invalid operator '${op}' passed to where(). Valid operators are: <, <=, ==, !=, >=, >, array-contains, array-contains-any, in, not-in.`);
+  }
+  if (value === void 0) {
+    throw new Error(`Function Query.where() requires a valid third argument, but it was undefined.`);
+  }
+  if (typeof value === "function") {
+    throw new Error(`Function Query.where() requires a valid third argument, but it was a function.`);
+  }
+  if (typeof value === "symbol") {
+    throw new Error(`Function Query.where() requires a valid third argument, but it was a symbol.`);
+  }
+  if (ARRAY_LIMIT_OPS.has(op)) {
+    if (!Array.isArray(value)) {
+      throw new Error(`Invalid argument: in/not-in/array-contains-any requires an array value.`);
+    }
+    if (value.length > 30) {
+      throw new Error(`Invalid Query. '${op}' filters support a maximum of 30 elements in the value array.`);
+    }
+  }
+  return {
+    type: "where",
+    field,
+    op,
+    value
+  };
+}
+function orderBy(field, direction = "asc") {
+  return {
+    type: "orderBy",
+    field,
+    direction
+  };
+}
+function limit(n) {
+  if (n <= 0) {
+    throw new Error(`Function limit() requires a positive number, but it was: ${n}`);
+  }
+  return {
+    type: "limit",
+    limit: n
+  };
+}
+function limitToLast(n) {
+  if (n <= 0) {
+    throw new Error(`Function limitToLast() requires a positive number, but it was: ${n}`);
+  }
+  return {
+    type: "limitToLast",
+    limit: n
+  };
+}
+function startAt(...values) {
+  return {
+    type: "startAt",
+    values,
+    inclusive: true
+  };
+}
+function startAfter(...values) {
+  return {
+    type: "startAfter",
+    values,
+    inclusive: false
+  };
+}
+function endAt(...values) {
+  return {
+    type: "endAt",
+    values,
+    inclusive: true
+  };
+}
+function endBefore(...values) {
+  return {
+    type: "endBefore",
+    values,
+    inclusive: false
+  };
+}
+async function getDocs(queryRef) {
+  const pm = getPersistenceManager(queryRef.firestore);
+  if (!pm) {
+    return getDocsDirect(queryRef);
+  }
+  if (pm.isOnline) {
+    try {
+      const snapshot = await getDocsDirect(queryRef);
+      for (const doc2 of snapshot.docs) {
+        await pm.cacheDocument(doc2.ref.path, doc2.data() ?? null, doc2.exists(), doc2._updateTime);
+      }
+      const queryKey = buildQueryCacheKey(queryRef);
+      await pm.cacheQuery(queryKey, snapshot.docs.map((d) => d.ref.path));
+      return snapshot;
+    } catch (error) {
+      const code = error?.code;
+      if (code === "unavailable" || code === "deadline-exceeded") {
+        return getDocsFromLocalCache(queryRef, pm);
+      }
+      throw error;
+    }
+  }
+  return getDocsFromLocalCache(queryRef, pm);
+}
+async function getDocsDirect(queryRef) {
+  const client = getHttpClient(queryRef.firestore);
+  const constraints = "constraints" in queryRef ? queryRef.constraints : [];
+  const flexibleQueries = Boolean(queryRef.firestore._config?.allowFlexibleQueries);
+  validateQueryConstraints(constraints, { allowFlexibleQueries: flexibleQueries });
+  const isCollectionGroupQuery = queryRef.type === "collectionGroup";
+  const structuredQuery = buildStructuredQuery(queryRef.path, constraints, isCollectionGroupQuery);
+  const response = await client.post(
+    "/documents:runQuery",
+    { structuredQuery }
+  );
+  const documents = response.filter((r) => r.document).map((r) => r.document);
+  const queryForSnapshot = "constraints" in queryRef ? queryRef : new QueryImpl(queryRef.firestore, queryRef.path, []);
+  const snapshot = createQuerySnapshot(queryForSnapshot, documents);
+  const converter = queryRef.converter;
+  return applyConverterToQuerySnapshot(snapshot, converter);
+}
+async function getDocsFromLocalCache(queryRef, pm) {
+  const queryForSnapshot = "constraints" in queryRef ? queryRef : new QueryImpl(queryRef.firestore, queryRef.path, []);
+  const queryKey = buildQueryCacheKey(queryRef);
+  const cachedPaths = await pm.getCachedQuery(queryKey);
+  if (cachedPaths) {
+    const docs2 = [];
+    for (const path of cachedPaths) {
+      const cached = await pm.getCachedDocument(path);
+      if (!cached || !cached.exists) continue;
+      const segments = path.split("/");
+      const ref = {
+        type: "document",
+        path,
+        id: segments[segments.length - 1],
+        firestore: queryRef.firestore,
+        parent: {
+          type: "collection",
+          path: segments.slice(0, -1).join("/"),
+          id: segments[segments.length - 2] || "",
+          firestore: queryRef.firestore,
+          parent: null
+        }
+      };
+      docs2.push(new DocumentSnapshotImpl(
+        ref,
+        cached.data,
+        true,
+        { fromCache: true, hasPendingWrites: await pm.hasPendingWrites(path) }
+      ));
+    }
+    return new QuerySnapshotImpl(queryForSnapshot, docs2, [], { fromCache: true });
+  }
+  const collectionDocs = await pm.getCachedCollection(queryRef.path);
+  const docs = [];
+  for (const cached of collectionDocs) {
+    const segments = cached.path.split("/");
+    const ref = {
+      type: "document",
+      path: cached.path,
+      id: segments[segments.length - 1],
+      firestore: queryRef.firestore,
+      parent: {
+        type: "collection",
+        path: segments.slice(0, -1).join("/"),
+        id: segments[segments.length - 2] || "",
+        firestore: queryRef.firestore,
+        parent: null
+      }
+    };
+    docs.push(new DocumentSnapshotImpl(
+      ref,
+      cached.data,
+      true,
+      { fromCache: true, hasPendingWrites: await pm.hasPendingWrites(cached.path) }
+    ));
+  }
+  return new QuerySnapshotImpl(queryForSnapshot, docs, [], { fromCache: true });
+}
+async function getDocsFromCache(queryRef) {
+  const pm = getPersistenceManager(queryRef.firestore);
+  if (!pm) {
+    throw createFirestoreError2(
+      "failed-precondition",
+      "Failed to get documents from cache. Persistence is not enabled."
+    );
+  }
+  return getDocsFromLocalCache(queryRef, pm);
+}
+function buildQueryCacheKey(queryRef) {
+  const constraints = "constraints" in queryRef ? queryRef.constraints : [];
+  return `${queryRef.path}:${JSON.stringify(constraints)}`;
+}
+async function getDocsFromServer(queryRef) {
+  const snapshot = await getDocsDirect(queryRef);
+  const pm = getPersistenceManager(queryRef.firestore);
+  if (pm) {
+    for (const doc2 of snapshot.docs) {
+      await pm.cacheDocument(doc2.ref.path, doc2.data() ?? null, doc2.exists(), doc2._updateTime);
+    }
+  }
+  return snapshot;
+}
+var INEQUALITY_OPS = /* @__PURE__ */ new Set(["<", "<=", ">", ">=", "!=", "not-in"]);
+var ARRAY_VALUE_OPS = /* @__PURE__ */ new Set(["in", "not-in", "array-contains-any"]);
+function createFirestoreError2(code, message) {
+  const error = new Error(message);
+  error.code = code;
+  return error;
+}
+function validateQueryConstraints(constraints, options) {
+  const whereConstraints = collectWhereConstraints(constraints);
+  const orderByConstraints = constraints.filter((c) => c.type === "orderBy");
+  const allowFlexibleQueries = options?.allowFlexibleQueries ?? false;
+  const inequalityFields = /* @__PURE__ */ new Set();
+  for (const w of whereConstraints) {
+    if (ARRAY_VALUE_OPS.has(w.op)) {
+      validateArrayOperator(w);
+    }
+    if (INEQUALITY_OPS.has(w.op)) {
+      inequalityFields.add(w.field);
+    }
+  }
+  if (inequalityFields.size > 1) {
+    throw createFirestoreError2(
+      "invalid-argument",
+      "Firestore requires inequality filters on a single field"
+    );
+  }
+  if (!allowFlexibleQueries && inequalityFields.size === 1 && orderByConstraints.length > 0) {
+    const inequalityField = [...inequalityFields][0];
+    const firstOrderBy = orderByConstraints[0];
+    if (firstOrderBy.field !== inequalityField) {
+      throw createFirestoreError2(
+        "invalid-argument",
+        `Firestore requires an orderBy on '${inequalityField}' to appear first`
+      );
+    }
+  }
+}
+function validateArrayOperator(where2) {
+  if (!Array.isArray(where2.value)) {
+    throw createFirestoreError2(
+      "invalid-argument",
+      `Operator '${where2.op}' requires an array value`
+    );
+  }
+  if (where2.value.length === 0 || where2.value.length > 10) {
+    throw createFirestoreError2(
+      "invalid-argument",
+      `Operator '${where2.op}' requires a non-empty array with at most 10 elements`
+    );
+  }
+}
+function collectWhereConstraints(constraints) {
+  const result = [];
+  for (const constraint of constraints) {
+    if (constraint.type === "where") {
+      result.push(constraint);
+    } else if (constraint.type === "and" || constraint.type === "or") {
+      const composite = constraint;
+      result.push(...collectWhereConstraints(composite.constraints));
+    }
+  }
+  return result;
+}
+function buildStructuredQuery(collectionPath, constraints, isCollectionGroup2 = false) {
+  const query2 = {
+    from: [{
+      collectionId: getCollectionSelectorPath(collectionPath, isCollectionGroup2),
+      allDescendants: isCollectionGroup2
+    }]
+  };
+  const wheres = [];
+  const compositeFilters = [];
+  const orderBys = [];
+  let limitValue;
+  let limitToLastValue;
+  let offsetValue;
+  let startCursor;
+  let endCursor;
+  for (const constraint of constraints) {
+    switch (constraint.type) {
+      case "where":
+        wheres.push(constraint);
+        break;
+      case "and":
+      case "or":
+        compositeFilters.push(constraint);
+        break;
+      case "orderBy":
+        orderBys.push(constraint);
+        break;
+      case "limit":
+        limitValue = constraint.limit;
+        break;
+      case "limitToLast":
+        limitToLastValue = constraint.limit;
+        break;
+      case "offset":
+        offsetValue = constraint.count;
+        break;
+      case "startAt":
+      case "startAfter": {
+        const c = constraint;
+        const cursorValues = extractCursorValues(c.values, orderBys);
+        startCursor = {
+          values: cursorValues.map((v) => toFirestoreValue(v)),
+          before: c.inclusive
+        };
+        break;
+      }
+      case "endAt":
+      case "endBefore": {
+        const c = constraint;
+        const cursorValues = extractCursorValues(c.values, orderBys);
+        endCursor = {
+          values: cursorValues.map((v) => toFirestoreValue(v)),
+          before: !c.inclusive
+        };
+        break;
+      }
+    }
+  }
+  const allFilters = [];
+  for (const w of wheres) {
+    const filter = buildWhereFilter(w);
+    if (filter) {
+      allFilters.push(filter);
+    }
+  }
+  for (const cf of compositeFilters) {
+    allFilters.push(buildCompositeFilterQuery(cf));
+  }
+  if (allFilters.length === 1) {
+    query2.where = allFilters[0];
+  } else if (allFilters.length > 1) {
+    query2.where = {
+      compositeFilter: {
+        op: "AND",
+        filters: allFilters
+      }
+    };
+  }
+  if (orderBys.length > 0) {
+    query2.orderBy = orderBys.map((ob) => ({
+      field: { fieldPath: ob.field },
+      direction: ob.direction === "desc" ? "DESCENDING" : "ASCENDING"
+    }));
+  }
+  if (limitValue !== void 0) {
+    query2.limit = limitValue;
+  }
+  if (limitToLastValue !== void 0) {
+    query2.limitToLast = limitToLastValue;
+  }
+  if (offsetValue !== void 0) {
+    query2.offset = offsetValue;
+  }
+  if (startCursor) {
+    query2.startAt = startCursor;
+  }
+  if (endCursor) {
+    query2.endAt = endCursor;
+  }
+  return query2;
+}
+function buildWhereFilter(where2) {
+  const fieldPath = where2.field;
+  const value = toFirestoreValue(where2.value);
+  const opMap = {
+    "<": "LESS_THAN",
+    "<=": "LESS_THAN_OR_EQUAL",
+    "==": "EQUAL",
+    "!=": "NOT_EQUAL",
+    ">": "GREATER_THAN",
+    ">=": "GREATER_THAN_OR_EQUAL",
+    "array-contains": "ARRAY_CONTAINS",
+    "array-contains-any": "ARRAY_CONTAINS_ANY",
+    "in": "IN",
+    "not-in": "NOT_IN"
+  };
+  if (where2.op === "array-contains-any" || where2.op === "in" || where2.op === "not-in") {
+    return {
+      fieldFilter: {
+        field: { fieldPath },
+        op: opMap[where2.op],
+        value
+      }
+    };
+  }
+  return {
+    fieldFilter: {
+      field: { fieldPath },
+      op: opMap[where2.op],
+      value
+    }
+  };
+}
+function buildCompositeFilterQuery(constraint) {
+  const op = constraint.type === "and" ? "AND" : "OR";
+  const filters = constraint.constraints.map((c) => {
+    if (c.type === "and" || c.type === "or") {
+      return buildCompositeFilterQuery(c);
+    }
+    return buildWhereFilter(c);
+  });
+  return {
+    compositeFilter: {
+      op,
+      filters
+    }
+  };
+}
+function getCollectionId(path) {
+  const parts = path.split("/");
+  return parts[parts.length - 1];
+}
+function getCollectionSelectorPath(path, isCollectionGroup2) {
+  if (isCollectionGroup2) {
+    return getCollectionId(path);
+  }
+  return path;
+}
+function extractCursorValues(values, orderBys) {
+  if (values.length === 0) return values;
+  const first = values[0];
+  if (isDocumentSnapshot(first)) {
+    const snapshot = first;
+    const data = snapshot.data();
+    if (!data) {
+      return values;
+    }
+    if (orderBys.length > 0) {
+      return orderBys.map((ob) => {
+        if (ob.field === "__name__") {
+          return snapshot.id;
+        }
+        return getNestedValue(data, ob.field);
+      });
+    }
+    return [snapshot.id];
+  }
+  return values;
+}
+function isDocumentSnapshot(value) {
+  if (!value || typeof value !== "object") return false;
+  const obj = value;
+  return typeof obj.exists === "function" && typeof obj.data === "function" && typeof obj.id === "string";
+}
+function getNestedValue(obj, path) {
+  const parts = path.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (current === null || current === void 0) return void 0;
+    if (typeof current !== "object") return void 0;
+    current = current[part];
+  }
+  return current;
+}
+
+// src/transport/websocket.ts
+function getWebSocketConstructor() {
+  if (typeof globalThis.WebSocket !== "undefined") {
+    return globalThis.WebSocket;
+  }
+  return null;
+}
+function normalizeWebSocketHost(rawHost, ssl) {
+  const trimmed = rawHost.trim().replace(/\/+$/, "");
+  if (trimmed.startsWith("ws://") || trimmed.startsWith("wss://")) {
+    return trimmed;
+  }
+  if (trimmed.startsWith("http://")) {
+    return `ws://${trimmed.slice("http://".length)}`;
+  }
+  if (trimmed.startsWith("https://")) {
+    return `wss://${trimmed.slice("https://".length)}`;
+  }
+  const protocol = ssl ? "wss" : "ws";
+  return `${protocol}://${trimmed}`;
+}
+var WebSocketClient = class {
+  constructor(firestore) {
+    this.socket = null;
+    this.state = "disconnected";
+    this.reconnectAttempts = 0;
+    this.maxReconnectAttempts = 5;
+    this.reconnectDelay = 1e3;
+    this.authToken = null;
+    this.syncTimer = null;
+    // Suscripciones activas
+    this.subscriptions = /* @__PURE__ */ new Map();
+    // ID para suscripciones
+    this.subscriptionIdCounter = 0;
+    this.firestore = firestore;
+    const host = normalizeWebSocketHost(firestore._config.host, firestore._config.ssl);
+    this.url = `${host}/v1/projects/${firestore._projectId}/databases/${firestore._databaseId}/documents:listen`;
+  }
+  /**
+   * Establece el token de autenticación
+   */
+  setAuthToken(token) {
+    this.authToken = token;
+    if (this.socket && this.state === "connected") {
+      this.reconnect();
+    }
+  }
+  /**
+   * Conecta al WebSocket
+   */
+  async connect() {
+    if (this.state === "connecting" || this.state === "connected") {
+      return;
+    }
+    this.state = "connecting";
+    return new Promise((resolve, reject) => {
+      try {
+        const WS = getWebSocketConstructor();
+        if (!WS) {
+          this.state = "error";
+          reject(new Error("WebSocket not available in this environment"));
+          return;
+        }
+        this.socket = new WS(this.url);
+        this.socket.onopen = () => {
+          this.state = "connected";
+          this.reconnectAttempts = 0;
+          this.sendAuth();
+          this.resubscribeAll();
+          resolve();
+        };
+        this.socket.onclose = () => {
+          this.state = "disconnected";
+          this.handleDisconnect();
+        };
+        this.socket.onerror = () => {
+          this.state = "error";
+          reject(new Error("WebSocket connection failed"));
+        };
+        this.socket.onmessage = (event) => {
+          this.handleMessage(event.data);
+        };
+      } catch (error) {
+        this.state = "error";
+        reject(error);
+      }
+    });
+  }
+  /**
+   * Maneja desconexión e intenta reconectar
+   */
+  handleDisconnect() {
+    if (this.reconnectAttempts < this.maxReconnectAttempts && this.subscriptions.size > 0) {
+      this.reconnectAttempts++;
+      const delay = this.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1);
+      setTimeout(() => this.connect(), delay);
+    }
+  }
+  /**
+   * Reconecta forzadamente
+   */
+  reconnect() {
+    this.socket?.close();
+    this.state = "disconnected";
+    this.connect();
+  }
+  /**
+   * Envía el token de autenticación como mensaje (no en URL)
+   */
+  sendAuth() {
+    if (this.socket && this.state === "connected" && this.authToken) {
+      this.socket.send(JSON.stringify({ type: "auth", token: this.authToken }));
+    }
+  }
+  /**
+   * Re-suscribe a todas las suscripciones activas
+   */
+  resubscribeAll() {
+    for (const [id, sub] of this.subscriptions) {
+      this.sendSubscribe(id, sub.path, sub.query, sub.includeMetadataChanges, sub.allDescendants);
+      if (sub.resumeToken && sub.path) {
+        this.sendResume(id, sub.resumeToken, sub.path);
+      }
+    }
+  }
+  /**
+   * Envía mensaje de suscripción
+   */
+  sendSubscribe(id, path, query2, includeMetadataChanges, allDescendants) {
+    if (this.socket && this.state === "connected") {
+      const message = {
+        type: "subscribe",
+        id,
+        path,
+        query: query2,
+        includeMetadataChanges,
+        allDescendants
+      };
+      this.socket.send(JSON.stringify(message));
+    }
+  }
+  /**
+   * Envía mensaje de reanudación con resumeToken
+   */
+  sendResume(id, resumeToken, path) {
+    if (this.socket && this.state === "connected") {
+      const message = {
+        type: "resume",
+        id,
+        resumeToken,
+        path
+      };
+      this.socket.send(JSON.stringify(message));
+    }
+  }
+  /**
+   * Notifica onSnapshotsInSync con debounce
+   */
+  scheduleSnapshotsSync() {
+    const firestoreInternal = this.firestore;
+    if (!firestoreInternal._syncCallbacks || firestoreInternal._syncCallbacks.size === 0) {
+      return;
+    }
+    if (this.syncTimer) {
+      clearTimeout(this.syncTimer);
+    }
+    this.syncTimer = setTimeout(() => {
+      firestoreInternal._syncCallbacks?.forEach((cb) => cb());
+    }, 50);
+  }
+  /**
+   * Envía mensaje de cancelación de suscripción
+   */
+  sendUnsubscribe(id) {
+    if (this.socket && this.state === "connected") {
+      const message = {
+        type: "unsubscribe",
+        id
+      };
+      this.socket.send(JSON.stringify(message));
+    }
+  }
+  /**
+   * Maneja mensajes entrantes
+   */
+  handleMessage(data) {
+    try {
+      const message = JSON.parse(data);
+      switch (message.type) {
+        case "document_change":
+        case "query_change":
+        case "metadata_change":
+        case "missed_event": {
+          const sub = this.subscriptions.get(message.id || "");
+          if (sub) {
+            if (message.resumeToken) {
+              sub.resumeToken = message.resumeToken;
+            }
+            sub.callback(message);
+            this.scheduleSnapshotsSync();
+          }
+          break;
+        }
+        case "snapshots_in_sync": {
+          this.scheduleSnapshotsSync();
+          break;
+        }
+        case "error": {
+          const sub = this.subscriptions.get(message.id || "");
+          if (sub?.errorCallback) {
+            sub.errorCallback(new Error(message.error || "Unknown error"));
+          }
+          break;
+        }
+      }
+    } catch {
+    }
+  }
+  /**
+   * Suscribe a cambios de un documento
+   */
+  async subscribeToDocument(path, callback, errorCallback, includeMetadataChanges) {
+    if (this.state !== "connected") {
+      await this.connect();
+    }
+    const id = `doc_${++this.subscriptionIdCounter}`;
+    this.subscriptions.set(id, {
+      path,
+      callback,
+      errorCallback,
+      includeMetadataChanges
+    });
+    this.sendSubscribe(id, path, void 0, includeMetadataChanges);
+    return () => {
+      this.subscriptions.delete(id);
+      this.sendUnsubscribe(id);
+      if (this.subscriptions.size === 0) {
+        this.socket?.close();
+        this.state = "disconnected";
+      }
+    };
+  }
+  /**
+   * Suscribe a cambios de una query
+   */
+  async subscribeToQuery(query2, callback, errorCallback, path, includeMetadataChanges, allDescendants) {
+    if (this.state !== "connected") {
+      await this.connect();
+    }
+    const id = `query_${++this.subscriptionIdCounter}`;
+    this.subscriptions.set(id, {
+      query: query2,
+      callback,
+      errorCallback,
+      path,
+      includeMetadataChanges,
+      allDescendants
+    });
+    this.sendSubscribe(id, path, query2, includeMetadataChanges, allDescendants);
+    return () => {
+      this.subscriptions.delete(id);
+      this.sendUnsubscribe(id);
+      if (this.subscriptions.size === 0) {
+        this.socket?.close();
+        this.state = "disconnected";
+      }
+    };
+  }
+  /**
+   * Cierra la conexión
+   */
+  close() {
+    this.subscriptions.clear();
+    this.socket?.close();
+    this.state = "disconnected";
+  }
+  /**
+   * Fuerza desconexión sin limpiar suscripciones (para pruebas de reconexión)
+   */
+  simulateDisconnect() {
+    if (this.socket) {
+      this.socket.close();
+    }
+  }
+};
+var clients = /* @__PURE__ */ new WeakMap();
+function getWebSocketClient(firestore) {
+  let client = clients.get(firestore);
+  if (!client) {
+    client = new WebSocketClient(firestore);
+    clients.set(firestore, client);
+  }
+  return client;
+}
+
+// src/firestore/realtime.ts
+function onSnapshot(reference, onNextOrObserverOrOptions, onErrorOrObserver, onError) {
+  let nextCallback;
+  let errorCallback = onError;
+  let options;
+  let onNextOrObserver = onNextOrObserverOrOptions;
+  const maybeOptions = onNextOrObserverOrOptions;
+  if (maybeOptions && typeof maybeOptions === "object" && ("includeMetadataChanges" in maybeOptions || "source" in maybeOptions)) {
+    options = maybeOptions;
+    onNextOrObserver = onErrorOrObserver;
+    errorCallback = onError;
+  } else {
+    errorCallback = onErrorOrObserver;
+  }
+  if (typeof onNextOrObserver === "function") {
+    nextCallback = onNextOrObserver;
+  } else {
+    nextCallback = onNextOrObserver?.next;
+    errorCallback = onNextOrObserver?.error ?? errorCallback;
+  }
+  const isDocument = reference.type === "document";
+  if (isDocument) {
+    return subscribeToDocument(
+      reference,
+      nextCallback,
+      errorCallback,
+      options
+    );
+  } else {
+    return subscribeToQuery(
+      reference,
+      nextCallback,
+      errorCallback,
+      options
+    );
+  }
+}
+function subscribeToDocument(reference, onNext, onError, options) {
+  let unsubscribed = false;
+  let wsUnsubscribe = null;
+  let localUnsubscribe = null;
+  let lastSnapshot = null;
+  const pm = getPersistenceManager(reference.firestore);
+  if (pm) {
+    pm.getCachedDocument(reference.path).then(async (cached) => {
+      if (cached && !unsubscribed) {
+        const cachedSnapshot = new DocumentSnapshotImpl(
+          reference,
+          cached.exists ? cached.data : void 0,
+          cached.exists,
+          { fromCache: true, hasPendingWrites: await pm.hasPendingWrites(reference.path) }
+        );
+        lastSnapshot = cachedSnapshot;
+        if (!unsubscribed && onNext) {
+          onNext(cachedSnapshot);
+        }
+      }
+    });
+  }
+  if (options?.source === "cache") {
+    if (!lastSnapshot) {
+      const hasPendingPromise = pm ? Promise.resolve(pm.hasPendingWrites(reference.path)) : Promise.resolve(false);
+      hasPendingPromise.then((hasPending) => {
+        if (unsubscribed || lastSnapshot) return;
+        const emptyCachedSnapshot = new DocumentSnapshotImpl(
+          reference,
+          void 0,
+          false,
+          {
+            fromCache: true,
+            hasPendingWrites: hasPending
+          }
+        );
+        lastSnapshot = emptyCachedSnapshot;
+        if (!unsubscribed && onNext) {
+          onNext(emptyCachedSnapshot);
+        }
+      });
+    }
+    if (options?.includeMetadataChanges) {
+      localUnsubscribe = registerLocalWriteListener(reference.path, () => {
+        if (unsubscribed || !onNext) return;
+        const data = lastSnapshot?.data();
+        const pendingSnapshot = new DocumentSnapshotImpl(
+          reference,
+          data,
+          lastSnapshot?.exists() ?? false,
+          { fromCache: true, hasPendingWrites: true }
+        );
+        onNext(pendingSnapshot);
+      });
+    }
+    return () => {
+      unsubscribed = true;
+      if (localUnsubscribe) {
+        localUnsubscribe();
+      }
+    };
+  }
+  getDoc(reference).then(async (snapshot) => {
+    if (!unsubscribed && onNext) {
+      lastSnapshot = snapshot;
+      if (pm) {
+        await pm.cacheDocument(reference.path, snapshot.data() ?? null, snapshot.exists(), snapshot._updateTime);
+      }
+      onNext(snapshot);
+    }
+  }).catch((error) => {
+    if (!unsubscribed && onError) {
+      onError(error);
+    }
+  });
+  if (options?.includeMetadataChanges) {
+    localUnsubscribe = registerLocalWriteListener(reference.path, () => {
+      if (unsubscribed || !onNext) return;
+      const data = lastSnapshot?.data();
+      const pendingSnapshot = new DocumentSnapshotImpl(
+        reference,
+        data,
+        lastSnapshot?.exists() ?? false,
+        { fromCache: true, hasPendingWrites: true }
+      );
+      onNext(pendingSnapshot);
+    });
+  }
+  try {
+    const wsClient = getWebSocketClient(reference.firestore);
+    wsClient.subscribeToDocument(
+      reference.path,
+      () => {
+        if (!unsubscribed && onNext) {
+          getDoc(reference).then(async (snapshot) => {
+            if (!unsubscribed) {
+              lastSnapshot = snapshot;
+              if (pm) {
+                await pm.cacheDocument(reference.path, snapshot.data() ?? null, snapshot.exists(), snapshot._updateTime);
+              }
+              onNext(snapshot);
+            }
+          }).catch((error) => {
+            if (!unsubscribed && onError) {
+              onError(error);
+            }
+          });
+        }
+      },
+      (error) => {
+        if (!unsubscribed && onError) {
+          onError(error);
+        }
+      },
+      options?.includeMetadataChanges
+    ).then((unsub) => {
+      wsUnsubscribe = unsub;
+      if (unsubscribed) {
+        unsub();
+      }
+    }).catch((error) => {
+      if (!unsubscribed && onError) {
+        onError(error);
+      }
+    });
+  } catch (error) {
+    if (!unsubscribed && onError) {
+      onError(error);
+    }
+  }
+  return () => {
+    unsubscribed = true;
+    if (wsUnsubscribe) {
+      wsUnsubscribe();
+    }
+    if (localUnsubscribe) {
+      localUnsubscribe();
+    }
+  };
+}
+function subscribeToQuery(queryRef, onNext, onError, options) {
+  let unsubscribed = false;
+  let previousSnapshot = null;
+  let wsUnsubscribe = null;
+  if (options?.source === "cache") {
+    getDocsFromCache(queryRef).then((snapshot) => {
+      if (!unsubscribed && onNext) {
+        onNext(snapshot);
+      }
+    }).catch((error) => {
+      if (!unsubscribed && onError) {
+        onError(error);
+      }
+    });
+    return () => {
+      unsubscribed = true;
+    };
+  }
+  const refresh = () => {
+    getDocsWithPreviousState(queryRef, previousSnapshot).then((snapshot) => {
+      if (!unsubscribed && onNext) {
+        previousSnapshot = snapshot;
+        onNext(snapshot);
+      }
+    }).catch((error) => {
+      if (!unsubscribed && onError) {
+        onError(error);
+      }
+    });
+  };
+  refresh();
+  try {
+    const wsClient = getWebSocketClient(queryRef.firestore);
+    const constraints = "constraints" in queryRef ? queryRef.constraints : [];
+    const isCollectionGroup2 = queryRef.type === "collectionGroup";
+    wsClient.subscribeToQuery(
+      constraints,
+      () => {
+        if (!unsubscribed) {
+          refresh();
+        }
+      },
+      (error) => {
+        if (!unsubscribed && onError) {
+          onError(error);
+        }
+      },
+      queryRef.path,
+      options?.includeMetadataChanges,
+      isCollectionGroup2
+      // allDescendants para collectionGroup
+    ).then((unsub) => {
+      wsUnsubscribe = unsub;
+      if (unsubscribed) {
+        unsub();
+      }
+    }).catch((error) => {
+      if (!unsubscribed && onError) {
+        onError(error);
+      }
+    });
+  } catch (error) {
+    if (!unsubscribed && onError) {
+      onError(error);
+    }
+  }
+  return () => {
+    unsubscribed = true;
+    if (wsUnsubscribe) {
+      wsUnsubscribe();
+    }
+  };
+}
+async function getDocsWithPreviousState(queryRef, previousSnapshot) {
+  const { getHttpClient: getHttpClient2 } = await import("./http-SZFONH6Z.mjs");
+  const { createQuerySnapshot: createQuerySnapshot2, toFirestoreValue: toFirestoreValue3 } = await import("./snapshot-ZWZFIFZD.mjs");
+  const client = getHttpClient2(queryRef.firestore);
+  const constraints = "constraints" in queryRef ? queryRef.constraints : [];
+  const isCollectionGroupQuery = queryRef.type === "collectionGroup";
+  const structuredQuery = buildStructuredQueryForRealtime(queryRef.path, constraints, isCollectionGroupQuery, toFirestoreValue3);
+  const response = await client.post(
+    "/documents:runQuery",
+    { structuredQuery }
+  );
+  const documents = response.filter((r) => r.document).map((r) => r.document);
+  const previousDocs = previousSnapshot ? previousSnapshot.docs : [];
+  return createQuerySnapshot2(queryRef, documents, previousDocs);
+}
+function buildStructuredQueryForRealtime(collectionPath, constraints, isCollectionGroup2, toFirestoreValue3) {
+  const query2 = {
+    from: [{
+      collectionId: isCollectionGroup2 ? collectionPath.split("/").pop() || collectionPath : collectionPath,
+      allDescendants: isCollectionGroup2
+    }]
+  };
+  const allFilters = [];
+  const orderBys = [];
+  let startCursor;
+  let endCursor;
+  for (const raw of constraints) {
+    if (raw.type === "where") {
+      const w = raw;
+      const filter = buildWhereFilterRealtime(w, toFirestoreValue3);
+      if (filter) {
+        allFilters.push(filter);
+      }
+    } else if (raw.type === "and" || raw.type === "or") {
+      allFilters.push(buildCompositeFilterRealtime(raw, toFirestoreValue3));
+    } else if (raw.type === "orderBy") {
+      const o = raw;
+      if (!query2.orderBy) query2.orderBy = [];
+      query2.orderBy.push({
+        field: { fieldPath: o.field },
+        direction: o.direction === "desc" ? "DESCENDING" : "ASCENDING"
+      });
+      orderBys.push(o);
+    } else if (raw.type === "limit") {
+      query2.limit = raw.limit;
+    } else if (raw.type === "limitToLast") {
+      query2.limitToLast = raw.limit;
+    } else if (raw.type === "startAt" || raw.type === "startAfter") {
+      const c = raw;
+      const cursorValues = extractCursorValuesRealtime(c.values, orderBys);
+      startCursor = {
+        values: cursorValues.map((v) => toFirestoreValue3(v)),
+        before: c.inclusive
+      };
+    } else if (raw.type === "endAt" || raw.type === "endBefore") {
+      const c = raw;
+      const cursorValues = extractCursorValuesRealtime(c.values, orderBys);
+      endCursor = {
+        values: cursorValues.map((v) => toFirestoreValue3(v)),
+        before: !c.inclusive
+      };
+    }
+  }
+  if (allFilters.length === 1) {
+    query2.where = allFilters[0];
+  } else if (allFilters.length > 1) {
+    query2.where = {
+      compositeFilter: {
+        op: "AND",
+        filters: allFilters
+      }
+    };
+  }
+  if (startCursor) {
+    query2.startAt = startCursor;
+  }
+  if (endCursor) {
+    query2.endAt = endCursor;
+  }
+  return query2;
+}
+function extractCursorValuesRealtime(values, orderBys) {
+  if (!values || values.length === 0) return values;
+  const first = values[0];
+  if (first && typeof first.data === "function") {
+    const data = first.data();
+    if (!data) return values;
+    if (orderBys.length > 0) {
+      return orderBys.map((ob) => {
+        if (ob.field === "__name__") {
+          return first.id ?? "";
+        }
+        return getNestedValue2(data, ob.field);
+      });
+    }
+  }
+  return values;
+}
+function getNestedValue2(obj, path) {
+  const parts = path.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (current === null || current === void 0) return void 0;
+    if (typeof current !== "object") return void 0;
+    current = current[part];
+  }
+  return current;
+}
+function buildWhereFilterRealtime(where2, toFirestoreValue3) {
+  const opMap = {
+    "<": "LESS_THAN",
+    "<=": "LESS_THAN_OR_EQUAL",
+    "==": "EQUAL",
+    "!=": "NOT_EQUAL",
+    ">": "GREATER_THAN",
+    ">=": "GREATER_THAN_OR_EQUAL",
+    "array-contains": "ARRAY_CONTAINS",
+    "array-contains-any": "ARRAY_CONTAINS_ANY",
+    "in": "IN",
+    "not-in": "NOT_IN"
+  };
+  return {
+    fieldFilter: {
+      field: { fieldPath: where2.field },
+      op: opMap[where2.op],
+      value: toFirestoreValue3(where2.value)
+    }
+  };
+}
+function buildCompositeFilterRealtime(constraint, toFirestoreValue3) {
+  const op = constraint.type === "and" ? "AND" : "OR";
+  const constraints = constraint.constraints || [];
+  const filters = constraints.map((c) => {
+    const item = c;
+    if (item.type === "and" || item.type === "or") {
+      return buildCompositeFilterRealtime(item, toFirestoreValue3);
+    }
+    return buildWhereFilterRealtime(item, toFirestoreValue3);
+  });
+  return {
+    compositeFilter: {
+      op,
+      filters
+    }
+  };
+}
+
+// src/firestore/batch.ts
+var WriteBatchImpl = class {
+  constructor(firestore) {
+    this.firestore = firestore;
+    this.operations = [];
+    this.committed = false;
+  }
+  set(reference, data, options) {
+    this.verifyNotCommitted();
+    this.operations.push({
+      type: "set",
+      reference,
+      data,
+      options
+    });
+    return this;
+  }
+  update(reference, data) {
+    this.verifyNotCommitted();
+    this.operations.push({
+      type: "update",
+      reference,
+      data
+    });
+    return this;
+  }
+  delete(reference) {
+    this.verifyNotCommitted();
+    this.operations.push({ type: "delete", reference });
+    return this;
+  }
+  async commit() {
+    this.verifyNotCommitted();
+    this.committed = true;
+    if (this.operations.length === 0) {
+      return;
+    }
+    if (this.operations.length > 500) {
+      throw createFirestoreError3("invalid-argument", "Batch write exceeds 500 operations");
+    }
+    const client = getHttpClient(this.firestore);
+    const writes = this.operations.map((op) => {
+      switch (op.type) {
+        case "set": {
+          const fields = toFirestoreFields(op.data);
+          if (op.options?.merge || op.options?.mergeFields) {
+            const fieldPaths = op.options.mergeFields || Object.keys(op.data);
+            return {
+              update: {
+                name: `projects/${this.firestore.app.options.projectId}/databases/(default)/documents/${op.reference.path}`,
+                fields
+              },
+              updateMask: { fieldPaths }
+            };
+          }
+          return {
+            update: {
+              name: `projects/${this.firestore.app.options.projectId}/databases/(default)/documents/${op.reference.path}`,
+              fields
+            }
+          };
+        }
+        case "update": {
+          const fields = toFirestoreFields(op.data);
+          const fieldPaths = Object.keys(op.data);
+          return {
+            update: {
+              name: `projects/${this.firestore.app.options.projectId}/databases/(default)/documents/${op.reference.path}`,
+              fields
+            },
+            updateMask: { fieldPaths }
+          };
+        }
+        case "delete":
+          return {
+            delete: `projects/${this.firestore.app.options.projectId}/databases/(default)/documents/${op.reference.path}`
+          };
+      }
+    });
+    await client.post(":batchWrite", { writes });
+  }
+  verifyNotCommitted() {
+    if (this.committed) {
+      throw new Error("WriteBatch ya ha sido committed");
+    }
+  }
+};
+function writeBatch(firestore) {
+  return new WriteBatchImpl(firestore);
+}
+var TransactionImpl = class {
+  constructor(firestore, client) {
+    this.firestore = firestore;
+    this.client = client;
+    this.reads = /* @__PURE__ */ new Map();
+    this.operations = [];
+    this.id = createTransactionId();
+    this.readVersions = /* @__PURE__ */ new Map();
+    this.preconditions = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Inicia la transacción
+   */
+  async begin() {
+    const response = await this.client.post(
+      ":beginTransaction",
+      {}
+    );
+    this.transactionId = response.transaction;
+  }
+  async get(reference) {
+    const cached = this.reads.get(reference.path);
+    if (cached) {
+      return cached;
+    }
+    const snapshot = await getDoc(reference);
+    this.readVersions.set(reference.path, getDocumentVersion(reference.path));
+    const snapImpl = snapshot;
+    this.preconditions.set(reference.path, {
+      exists: snapshot.exists(),
+      updateTime: snapImpl._updateTime
+    });
+    this.reads.set(reference.path, snapshot);
+    return snapshot;
+  }
+  set(reference, data, options) {
+    this.operations.push({
+      type: "set",
+      reference,
+      data,
+      options
+    });
+    return this;
+  }
+  update(reference, data) {
+    this.operations.push({
+      type: "update",
+      reference,
+      data
+    });
+    return this;
+  }
+  delete(reference) {
+    this.operations.push({ type: "delete", reference });
+    return this;
+  }
+  /**
+   * Ejecuta la transacción
+   */
+  async commit() {
+    if (this.operations.length > 500) {
+      throw createFirestoreError3("invalid-argument", "Transaction exceeds 500 operations");
+    }
+    if (this.operations.length > 0) {
+      for (const [path, version] of this.readVersions.entries()) {
+        if (getDocumentVersion(path) !== version) {
+          throw createFirestoreError3("aborted", "Transaction read conflict");
+        }
+      }
+    }
+    const paths = this.operations.map((op) => op.reference.path);
+    if (hasWriteConflict(this.id, paths)) {
+      throw createFirestoreError3("aborted", "Transaction conflicted with another in-flight write");
+    }
+    acquireWriteLocks(this.id, paths);
+    if (this.operations.length === 0) {
+      if (this.transactionId) {
+        await this.client.post(":rollback", {
+          transaction: this.transactionId
+        });
+      }
+      releaseWriteLocks(this.id);
+      return;
+    }
+    const writes = this.operations.map((op) => {
+      const baseName = `projects/${this.firestore.app.options.projectId}/databases/(default)/documents/${op.reference.path}`;
+      switch (op.type) {
+        case "set": {
+          const fields = toFirestoreFields(op.data);
+          if (op.options?.merge || op.options?.mergeFields) {
+            const fieldPaths = op.options.mergeFields || Object.keys(op.data);
+            return {
+              update: { name: baseName, fields },
+              updateMask: { fieldPaths },
+              currentDocument: this.preconditions.get(op.reference.path)
+            };
+          }
+          return {
+            update: { name: baseName, fields },
+            currentDocument: this.preconditions.get(op.reference.path)
+          };
+        }
+        case "update": {
+          const fields = toFirestoreFields(op.data);
+          const fieldPaths = Object.keys(op.data);
+          return {
+            update: { name: baseName, fields },
+            updateMask: { fieldPaths },
+            currentDocument: this.preconditions.get(op.reference.path)
+          };
+        }
+        case "delete":
+          return {
+            delete: baseName,
+            currentDocument: this.preconditions.get(op.reference.path)
+          };
+      }
+    });
+    try {
+      await this.client.post(":commit", {
+        transaction: this.transactionId,
+        writes
+      });
+      bumpDocumentVersions(paths);
+    } finally {
+      releaseWriteLocks(this.id);
+    }
+  }
+  /**
+   * Rollback de la transacción
+   */
+  async rollback() {
+    if (this.transactionId) {
+      await this.client.post(":rollback", {
+        transaction: this.transactionId
+      });
+    }
+    releaseWriteLocks(this.id);
+  }
+};
+async function runTransaction(firestore, updateFunction, options) {
+  const maxAttempts = options?.maxAttempts ?? 5;
+  const client = getHttpClient(firestore);
+  let lastError;
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    const transaction = new TransactionImpl(firestore, client);
+    try {
+      await transaction.begin();
+      const result = await updateFunction(transaction);
+      await transaction.commit();
+      return result;
+    } catch (error) {
+      lastError = error;
+      try {
+        await transaction.rollback();
+      } catch {
+      }
+      if (error.code === "aborted") {
+        await new Promise(
+          (resolve) => setTimeout(resolve, Math.pow(2, attempt) * 100)
+        );
+        continue;
+      }
+      throw error;
+    }
+  }
+  throw lastError || new Error("Transaction failed after max attempts");
+}
+function createFirestoreError3(code, message) {
+  const error = new Error(message);
+  error.code = code;
+  return error;
+}
+var writeLocks = /* @__PURE__ */ new Map();
+var documentVersions = /* @__PURE__ */ new Map();
+function createTransactionId() {
+  return `tx_${Math.random().toString(36).slice(2)}_${Date.now()}`;
+}
+function hasWriteConflict(txId, paths) {
+  return paths.some((path) => {
+    const owner = writeLocks.get(path);
+    return owner !== void 0 && owner !== txId;
+  });
+}
+function getDocumentVersion(path) {
+  return documentVersions.get(path) ?? 0;
+}
+function bumpDocumentVersions(paths) {
+  paths.forEach((path) => {
+    const current = getDocumentVersion(path);
+    documentVersions.set(path, current + 1);
+  });
+}
+function acquireWriteLocks(txId, paths) {
+  paths.forEach((path) => {
+    writeLocks.set(path, txId);
+  });
+}
+function releaseWriteLocks(txId) {
+  for (const [path, owner] of writeLocks.entries()) {
+    if (owner === txId) {
+      writeLocks.delete(path);
+    }
+  }
+}
+
+// src/firestore/advanced-query.ts
+function and(...constraints) {
+  if (constraints.length === 0) {
+    throw new Error("and() requires at least one constraint");
+  }
+  return {
+    type: "and",
+    constraints
+  };
+}
+function or(...constraints) {
+  if (constraints.length === 0) {
+    throw new Error("or() requires at least one constraint");
+  }
+  return {
+    type: "or",
+    constraints
+  };
+}
+var CollectionGroupImpl = class {
+  constructor(firestore, collectionId, path, constraints = []) {
+    this.firestore = firestore;
+    this.collectionId = collectionId;
+    this.path = path;
+    this.constraints = constraints;
+    this.type = "collectionGroup";
+  }
+};
+function collectionGroup(firestore, collectionId) {
+  if (!collectionId || typeof collectionId !== "string") {
+    throw new Error("collectionGroup requires a valid collection ID");
+  }
+  if (collectionId.includes("/")) {
+    throw new Error("collectionGroup ID cannot contain slashes");
+  }
+  return new CollectionGroupImpl(
+    firestore,
+    collectionId,
+    collectionId,
+    // path es solo el ID para collection groups
+    []
+  );
+}
+function isAndConstraint(constraint) {
+  return constraint.type === "and";
+}
+function isOrConstraint(constraint) {
+  return constraint.type === "or";
+}
+function isCompositeFilter(constraint) {
+  return isAndConstraint(constraint) || isOrConstraint(constraint);
+}
+function isCollectionGroup(ref) {
+  return ref.type === "collectionGroup";
+}
+
+// src/firestore/aggregations.ts
+function count() {
+  return {
+    _aggregateType: "count"
+  };
+}
+function sum(field) {
+  return {
+    _aggregateType: "sum",
+    _field: field
+  };
+}
+function average(field) {
+  return {
+    _aggregateType: "average",
+    _field: field
+  };
+}
+async function getCountFromServer(query2) {
+  return getAggregateFromServer(query2, { count: count() });
+}
+async function getAggregateFromServer(query2, aggregateSpec) {
+  const firestore = query2.firestore;
+  const client = getHttpClient(firestore);
+  const structuredQuery = buildAggregateQuery(query2, aggregateSpec);
+  const response = await client.post("/documents:runAggregationQuery", {
+    structuredAggregationQuery: structuredQuery
+  });
+  let aggregateFields = {};
+  if (Array.isArray(response)) {
+    aggregateFields = response[0]?.result?.aggregateFields || {};
+  } else {
+    aggregateFields = response?.result?.aggregateFields || {};
+  }
+  const resultData = {};
+  for (const [alias, spec] of Object.entries(aggregateSpec)) {
+    const value = aggregateFields[alias];
+    if (value) {
+      if ("nullValue" in value) {
+        resultData[alias] = null;
+      } else if (value.integerValue !== void 0) {
+        resultData[alias] = parseInt(value.integerValue, 10);
+      } else if (value.doubleValue !== void 0) {
+        resultData[alias] = value.doubleValue;
+      } else {
+        resultData[alias] = null;
+      }
+    } else {
+      resultData[alias] = spec._aggregateType === "average" ? null : 0;
+    }
+  }
+  return {
+    data: () => resultData
+  };
+}
+function buildAggregateQuery(query2, aggregateSpec) {
+  const pathParts = query2.path.split("/");
+  const collectionId = pathParts[pathParts.length - 1];
+  const structuredQuery = {
+    from: [{ collectionId }]
+  };
+  if ("constraints" in query2) {
+    const constraints = query2.constraints || [];
+    const wheres = constraints.filter((c) => c.type === "where");
+    if (wheres.length > 0) {
+      structuredQuery.where = buildWhereFromConstraints(wheres);
+    }
+  }
+  const aggregations = Object.entries(aggregateSpec).map(([alias, spec]) => {
+    const aggregation = { alias };
+    switch (spec._aggregateType) {
+      case "count":
+        aggregation.count = {};
+        break;
+      case "sum":
+        aggregation.sum = { field: { fieldPath: spec._field } };
+        break;
+      case "average":
+        aggregation.average = { field: { fieldPath: spec._field } };
+        break;
+    }
+    return aggregation;
+  });
+  return {
+    structuredQuery,
+    aggregations
+  };
+}
+function buildWhereFromConstraints(constraints) {
+  const filters = constraints.map((c) => {
+    const constraint = c;
+    return {
+      fieldFilter: {
+        field: { fieldPath: constraint.field },
+        op: mapOperator(constraint.op),
+        value: toFirestoreValue2(constraint.value)
+      }
+    };
+  });
+  if (filters.length === 1) {
+    return filters[0];
+  }
+  return {
+    compositeFilter: {
+      op: "AND",
+      filters
+    }
+  };
+}
+function mapOperator(op) {
+  const opMap = {
+    "<": "LESS_THAN",
+    "<=": "LESS_THAN_OR_EQUAL",
+    "==": "EQUAL",
+    "!=": "NOT_EQUAL",
+    ">": "GREATER_THAN",
+    ">=": "GREATER_THAN_OR_EQUAL",
+    "array-contains": "ARRAY_CONTAINS",
+    "array-contains-any": "ARRAY_CONTAINS_ANY",
+    "in": "IN",
+    "not-in": "NOT_IN"
+  };
+  return opMap[op] || "EQUAL";
+}
+function toFirestoreValue2(value) {
+  if (value === null) return { nullValue: null };
+  if (typeof value === "boolean") return { booleanValue: value };
+  if (typeof value === "number") {
+    return Number.isInteger(value) ? { integerValue: String(value) } : { doubleValue: value };
+  }
+  if (typeof value === "string") return { stringValue: value };
+  if (Array.isArray(value)) {
+    return { arrayValue: { values: value.map(toFirestoreValue2) } };
+  }
+  if (typeof value === "object") {
+    const fields = {};
+    for (const [k, v] of Object.entries(value)) {
+      fields[k] = toFirestoreValue2(v);
+    }
+    return { mapValue: { fields } };
+  }
+  return { stringValue: String(value) };
+}
+
+// src/firestore/advanced-search.ts
+function whereSearch(field, value) {
+  return {
+    type: "where",
+    field: `${field}_search`,
+    op: "==",
+    value
+  };
+}
+function whereContains(field, value) {
+  return {
+    type: "where",
+    field: `${field}_contains`,
+    op: "==",
+    value
+  };
+}
+function whereFuzzy(field, value) {
+  return {
+    type: "where",
+    field: `${field}_fuzzy`,
+    op: "==",
+    value
+    // El threshold se maneja en el backend (default 0.3)
+  };
+}
+function whereSimilar(field, value) {
+  return {
+    type: "where",
+    field: `${field}_similar`,
+    op: "==",
+    value
+  };
+}
+function orderByRelevance(direction = "desc") {
+  return {
+    type: "orderBy",
+    field: "__relevance__",
+    direction
+  };
+}
+function offset(count2) {
+  return {
+    type: "offset",
+    count: count2
+  };
+}
+async function fastSearch(firestore, collectionPath, term, options = {}) {
+  if (!collectionPath) {
+    throw new Error("La colecci\xF3n es obligatoria.");
+  }
+  if (!term) {
+    throw new Error("El t\xE9rmino es obligatorio.");
+  }
+  const params = new URLSearchParams({
+    q: term,
+    limit: String(options.limit ?? 50),
+    fuzzy: options.fuzzy ? "true" : "false"
+  });
+  if (options.field) {
+    params.set("field", options.field);
+  }
+  const searchPath = `/search/${encodeURIComponent(collectionPath)}?${params.toString()}`;
+  const client = getHttpClient(firestore);
+  return await client.get(searchPath);
+}
+
+export {
+  doc,
+  collection,
+  withConverter,
+  refEqual,
+  queryEqual,
+  snapshotEqual,
+  onSnapshotsInSync,
+  getDoc,
+  getDocFromCache,
+  setDoc,
+  getDocFromServer,
+  updateDoc,
+  deleteDoc,
+  addDoc,
+  query,
+  where,
+  orderBy,
+  limit,
+  limitToLast,
+  startAt,
+  startAfter,
+  endAt,
+  endBefore,
+  getDocs,
+  getDocsFromCache,
+  getDocsFromServer,
+  onSnapshot,
+  writeBatch,
+  runTransaction,
+  and,
+  or,
+  collectionGroup,
+  isAndConstraint,
+  isOrConstraint,
+  isCompositeFilter,
+  isCollectionGroup,
+  count,
+  sum,
+  average,
+  getCountFromServer,
+  getAggregateFromServer,
+  whereSearch,
+  whereContains,
+  whereFuzzy,
+  whereSimilar,
+  orderByRelevance,
+  offset,
+  fastSearch
+};
+//# sourceMappingURL=chunk-DXPQJR5D.mjs.map