pbtsdb 0.10.2 → 2.0.0

package/dist/chunk-X7ZGPVG2.js

@@ -1,1543 +0,0 @@
-import { BTreeIndex, createCollection as createCollection$1, parseWhereExpression, parseOrderByExpression, IR } from '@tanstack/db';
-export { BTreeIndex, BasicIndex, ReverseIndex, createEffect, materialize, toArray } from '@tanstack/db';
-import { queryCollectionOptions, DeleteOperationItemNotFoundError } from '@tanstack/query-db-collection';
-
-// src/core.ts
-
-// src/expand-paths.ts
-function normalizePaths(paths) {
-  const set = /* @__PURE__ */ new Set();
-  for (const path of paths) {
-    const trimmed = path.trim();
-    if (trimmed) set.add(trimmed);
-  }
-  return [...set].sort();
-}
-function splitPaths(csv) {
-  return csv ? normalizePaths(csv.split(",")) : [];
-}
-function joinPaths(paths) {
-  const normalized = normalizePaths(paths);
-  return normalized.length > 0 ? normalized.join(",") : void 0;
-}
-var BACK_RELATION_EXPAND_CAP = 1e3;
-function parseViaKey(key) {
-  const index = key.indexOf("_via_");
-  if (index < 0) return void 0;
-  const field = key.slice(index + "_via_".length);
-  return field ? { field } : void 0;
-}
-function markFiledSubset(target, key, values, parentId) {
-  const via = parseViaKey(key);
-  if (!via || values.length >= BACK_RELATION_EXPAND_CAP) return;
-  target.markSubsetLoaded(via.field, parentId);
-}
-function validateExpandPath(collectionName, targets, path) {
-  if (!targets) {
-    throw new Error(
-      `Cannot expand "${path}" on collection "${collectionName}": no relations declared`
-    );
-  }
-  let current = targets;
-  for (const segment of path.split(".")) {
-    const next = current?.[segment];
-    if (!next) {
-      throw new Error(
-        `Cannot expand "${path}" on collection "${collectionName}": segment "${segment}" is not a declared relation`
-      );
-    }
-    current = next.relationTargets;
-  }
-}
-
-// src/logger.ts
-var defaultLogger = {
-  debug: (msg, context) => {
-    if (process.env.NODE_ENV === "development") {
-      console.debug(`[pbtsdb] ${msg}`, context || "");
-    }
-  },
-  info: (msg, context) => {
-    console.info(`[pbtsdb] ${msg}`, context || "");
-  },
-  warn: (msg, context) => {
-    console.warn(`[pbtsdb] ${msg}`, context || "");
-  },
-  error: (msg, context) => {
-    console.error(`[pbtsdb] ${msg}`, context || "");
-  }
-};
-var currentLogger = defaultLogger;
-var logger = {
-  debug: (msg, context) => currentLogger.debug(msg, context),
-  info: (msg, context) => currentLogger.info(msg, context),
-  warn: (msg, context) => currentLogger.warn(msg, context),
-  error: (msg, context) => currentLogger.error(msg, context)
-};
-function setLogger(customLogger) {
-  currentLogger = customLogger;
-}
-function resetLogger() {
-  currentLogger = defaultLogger;
-}
-
-// src/records.ts
-function idOf(value) {
-  if (!value || typeof value !== "object" || !("id" in value)) return void 0;
-  return typeof value.id === "string" ? value.id : void 0;
-}
-function updatedAtOf(value) {
-  if (!value || typeof value !== "object" || !("updated" in value)) return void 0;
-  return typeof value.updated === "string" && value.updated !== "" ? value.updated : void 0;
-}
-function expandOf(value) {
-  if (!value || typeof value !== "object" || !("expand" in value)) return void 0;
-  const { expand } = value;
-  return expand && typeof expand === "object" ? expand : void 0;
-}
-function isObject(value) {
-  return typeof value === "object" && value !== null;
-}
-
-// src/expand-filing.ts
-function backRelationHeads(expandString, targets) {
-  if (!targets) return [];
-  const heads = [];
-  for (const key of splitPaths(expandString).map((path) => path.split(".")[0])) {
-    const target = targets[key];
-    const via = target && parseViaKey(key);
-    if (target && via) heads.push({ target, key, field: via.field });
-  }
-  return heads;
-}
-function targetsAlong(paths, targets) {
-  const found = /* @__PURE__ */ new Set();
-  for (const path of paths) {
-    let current = targets;
-    for (const segment of path.split(".")) {
-      const target = current?.[segment];
-      if (!target) break;
-      found.add(target);
-      current = target.relationTargets;
-    }
-  }
-  return found;
-}
-function withoutExpand(values) {
-  return values.map((value) => {
-    const { expand: _expand, ...plain } = value;
-    return plain;
-  });
-}
-function stripFetchedRelations(items, expandString) {
-  const heads = new Set(splitPaths(expandString).map((path) => path.split(".")[0]));
-  if (heads.size === 0) return items;
-  return items.map((item) => {
-    const { expand, ...plain } = item;
-    if (!expand) return item;
-    const kept = Object.fromEntries(Object.entries(expand).filter(([key]) => !heads.has(key)));
-    return Object.keys(kept).length > 0 ? { ...plain, expand: kept } : plain;
-  });
-}
-function groupExpandedByKey(records) {
-  const byKey = /* @__PURE__ */ new Map();
-  for (const record of records) {
-    const expand = expandOf(record);
-    if (!expand) continue;
-    const parentId = idOf(record);
-    for (const [key, value] of Object.entries(expand)) {
-      const values = (Array.isArray(value) ? value : [value]).filter(isObject);
-      const group = byKey.get(key) ?? { values: [], byParent: [] };
-      group.values.push(...values);
-      if (parentId) group.byParent.push([parentId, values]);
-      byKey.set(key, group);
-    }
-  }
-  return byKey;
-}
-function lastById(values) {
-  const byId = /* @__PURE__ */ new Map();
-  for (const value of values) byId.set(idOf(value), value);
-  return [...byId.values()];
-}
-function createExpandFiler(collectionName, recordFiled) {
-  function recordFiledGroup(target, key, group, values) {
-    const via = parseViaKey(key);
-    if (via) {
-      recordFiled(
-        target,
-        via.field,
-        group.byParent.map(([parentId]) => parentId)
-      );
-    } else {
-      recordFiled(
-        target,
-        "id",
-        values.flatMap((value) => idOf(value) ?? [])
-      );
-    }
-  }
-  async function upsertExpanded(records, targets) {
-    if (!targets) return;
-    for (const [key, group] of groupExpandedByKey(records)) {
-      const target = targets[key];
-      if (!target) {
-        logger.debug("No relation target for expanded field", { collectionName, key });
-        continue;
-      }
-      const values = lastById(group.values);
-      const filed = await target.writeFiled(values);
-      await upsertExpanded(values, target.relationTargets);
-      if (!filed) continue;
-      recordFiledGroup(target, key, group, values);
-      for (const [parentId, parentValues] of group.byParent) {
-        markFiledSubset(target, key, parentValues, parentId);
-      }
-    }
-  }
-  return {
-    upsertExpanded,
-    markEmptyBackRelations(items, heads) {
-      if (heads.length === 0) return;
-      for (const item of items) {
-        const id = idOf(item);
-        if (!id) continue;
-        const expand = expandOf(item);
-        for (const { target, key, field } of heads) {
-          if (expand?.[key] !== void 0) continue;
-          target.markSubsetLoaded(field, id);
-          recordFiled(target, field, [id]);
-        }
-      }
-    }
-  };
-}
-
-// src/keyed-where.ts
-function fieldRef(node) {
-  return node?.type === "ref" && node.path?.length === 1 ? node.path[0] : void 0;
-}
-function stringValue(node) {
-  return node?.type === "val" && typeof node.value === "string" ? node.value : void 0;
-}
-function collectEq(a, b) {
-  const field = fieldRef(a) ?? fieldRef(b);
-  if (field === void 0) return void 0;
-  const value = stringValue(fieldRef(a) !== void 0 ? b : a);
-  return value === void 0 ? void 0 : { field, values: [value] };
-}
-function collectIn(a, b) {
-  const field = fieldRef(a);
-  if (field === void 0 || b?.type !== "val" || !Array.isArray(b.value)) return void 0;
-  return b.value.every((v) => typeof v === "string") ? { field, values: b.value } : void 0;
-}
-function collectOr(args) {
-  let field;
-  const values = [];
-  for (const arg of args) {
-    const sub = collect(arg);
-    if (!sub || field !== void 0 && sub.field !== field) return void 0;
-    field = sub.field;
-    values.push(...sub.values);
-  }
-  return field === void 0 ? void 0 : { field, values };
-}
-function collect(node) {
-  if (node.type !== "func" || !node.args) return void 0;
-  const [a, b] = node.args;
-  switch (node.name) {
-    case "eq":
-      return collectEq(a, b);
-    case "in":
-      return collectIn(a, b);
-    case "or":
-      return collectOr(node.args);
-    default:
-      return void 0;
-  }
-}
-function subsetFromWhere(where) {
-  if (!where) return void 0;
-  const subset = collect(where);
-  return subset ? { field: subset.field, values: [...new Set(subset.values)].sort() } : void 0;
-}
-function matchesSubset(row, field, wanted) {
-  const value = row[field];
-  if (typeof value === "string") return wanted.has(value);
-  if (Array.isArray(value))
-    return value.some((item) => typeof item === "string" && wanted.has(item));
-  return false;
-}
-function escapeValue(value) {
-  if (value === null) {
-    return "null";
-  }
-  if (typeof value === "boolean") {
-    return value ? "true" : "false";
-  }
-  if (typeof value === "number") {
-    return value.toString();
-  }
-  if (typeof value === "string") {
-    return `"${value.replace(/"/g, '\\"')}"`;
-  }
-  if (value instanceof Date) {
-    return `"${value.toISOString()}"`;
-  }
-  if (Array.isArray(value)) {
-    return `[${value.map(escapeValue).join(",")}]`;
-  }
-  return `"${String(value)}"`;
-}
-function fieldPathToString(path) {
-  return path.join(".");
-}
-var NEVER_MATCH = "1 = 2";
-var ALWAYS_MATCH = "1 = 1";
-function membership(field, values, operator, joiner, empty) {
-  const valueArray = Array.isArray(values) ? values : [values];
-  const fieldStr = fieldPathToString(field);
-  const conditions = [...new Set(valueArray)].map(
-    (v) => `${fieldStr} ${operator} ${escapeValue(v)}`
-  );
-  if (conditions.length === 0) return empty;
-  return conditions.length > 1 ? `(${conditions.join(` ${joiner} `)})` : conditions[0];
-}
-var NEGATED_OPERATORS = {
-  eq: "neq",
-  neq: "eq",
-  gt: "lte",
-  gte: "lt",
-  lt: "gte",
-  lte: "gt",
-  in: "notIn",
-  notIn: "in",
-  like: "notLike",
-  notLike: "like",
-  isNull: "isNotNull",
-  isUndefined: "isNotNull",
-  isNotNull: "isNull"
-};
-function negate(expr) {
-  if (expr.type !== "func") {
-    throw new Error(
-      `Unsupported operand '${expr.type}' inside not() for PocketBase filter conversion`
-    );
-  }
-  if (expr.name === "not") {
-    return pushDownNot(expr.args[0]);
-  }
-  if (expr.name === "and" || expr.name === "or") {
-    return new IR.Func(expr.name === "and" ? "or" : "and", expr.args.map(negate));
-  }
-  const negated = NEGATED_OPERATORS[expr.name];
-  if (!negated) {
-    throw new Error(`Unsupported operator 'not(${expr.name})' for PocketBase filter conversion`);
-  }
-  return new IR.Func(negated, expr.args);
-}
-function pushDownNot(expr) {
-  if (expr.type !== "func") {
-    return expr;
-  }
-  if (expr.name === "not") {
-    return negate(expr.args[0]);
-  }
-  if (expr.name === "and" || expr.name === "or") {
-    return new IR.Func(expr.name, expr.args.map(pushDownNot));
-  }
-  return expr;
-}
-function convertToPocketBaseFilter(where) {
-  if (!where) {
-    return void 0;
-  }
-  const result = parseWhereExpression(pushDownNot(where), {
-    handlers: {
-      eq: (field, value) => {
-        return `${fieldPathToString(field)} = ${escapeValue(value)}`;
-      },
-      gt: (field, value) => {
-        return `${fieldPathToString(field)} > ${escapeValue(value)}`;
-      },
-      gte: (field, value) => {
-        return `${fieldPathToString(field)} >= ${escapeValue(value)}`;
-      },
-      lt: (field, value) => {
-        return `${fieldPathToString(field)} < ${escapeValue(value)}`;
-      },
-      lte: (field, value) => {
-        return `${fieldPathToString(field)} <= ${escapeValue(value)}`;
-      },
-      and: (...conditions) => {
-        if (conditions.length === 0) return "";
-        if (conditions.length === 1) return conditions[0];
-        return `(${conditions.join(" && ")})`;
-      },
-      or: (...conditions) => {
-        if (conditions.length === 0) return "";
-        if (conditions.length === 1) return conditions[0];
-        return `(${conditions.join(" || ")})`;
-      },
-      neq: (field, value) => {
-        return `${fieldPathToString(field)} != ${escapeValue(value)}`;
-      },
-      in: (field, values) => membership(field, values, "=", "||", NEVER_MATCH),
-      notIn: (field, values) => membership(field, values, "!=", "&&", ALWAYS_MATCH),
-      notLike: (field, value) => {
-        return `${fieldPathToString(field)} !~ ${escapeValue(value)}`;
-      },
-      like: (field, value) => {
-        return `${fieldPathToString(field)} ~ ${escapeValue(value)}`;
-      },
-      isNull: (field) => {
-        return `${fieldPathToString(field)} = null`;
-      },
-      isUndefined: (field) => {
-        return `${fieldPathToString(field)} = null`;
-      },
-      isNotNull: (field) => {
-        return `${fieldPathToString(field)} != null`;
-      }
-    },
-    onUnknownOperator: (operator, _args) => {
-      throw new Error(
-        `Unsupported operator '${operator}' for PocketBase filter conversion. Supported operators: eq, gt, gte, lt, lte, in, like, and, or, not, isNull, isUndefined`
-      );
-    }
-  });
-  return result || void 0;
-}
-function convertToPocketBaseSort(orderBy) {
-  if (!orderBy) {
-    return void 0;
-  }
-  const sorts = parseOrderByExpression(orderBy);
-  if (sorts.length === 0) {
-    return void 0;
-  }
-  return sorts.map((sort) => {
-    const field = fieldPathToString(sort.field);
-    return sort.direction === "desc" ? `-${field}` : field;
-  }).join(",");
-}
-
-// src/pocketbase-limits.ts
-var MAX_FILTER_LENGTH = 2500;
-var REALTIME_MAX_FILTER_LENGTH = 1e3;
-var REALTIME_TOPIC_MAX_LENGTH = 2500;
-var SDK_RESERVED_OPTIONS = /* @__PURE__ */ new Set([
-  "requestKey",
-  "$cancelKey",
-  "$autoCancel",
-  "fetch",
-  "headers",
-  "body",
-  "query",
-  "params",
-  "cache",
-  "credentials",
-  "integrity",
-  "keepalive",
-  "method",
-  "mode",
-  "redirect",
-  "referrer",
-  "referrerPolicy",
-  "signal",
-  "window"
-]);
-function realtimeTopicLength(collectionName, options) {
-  const topic = `${collectionName}/*`;
-  if (!options) return topic.length;
-  const query = { ...options.query };
-  for (const [key, value] of Object.entries(options)) {
-    if (!SDK_RESERVED_OPTIONS.has(key)) query[key] = value;
-  }
-  const encoded = encodeURIComponent(JSON.stringify({ query, headers: options.headers }));
-  return `${topic}?options=${encoded}`.length;
-}
-function subsetFilters({ field, values }, maxLength = MAX_FILTER_LENGTH) {
-  const filters = [];
-  let current = "";
-  for (const value of values) {
-    const clause = `${field} = ${escapeValue(value)}`;
-    const joined = current ? `${current} || ${clause}` : clause;
-    if (current && joined.length > maxLength) {
-      filters.push(current);
-      current = clause;
-    } else {
-      current = joined;
-    }
-  }
-  if (current) filters.push(current);
-  return filters;
-}
-
-// src/fetch-records.ts
-function createFetcher(deps) {
-  const { pb, collectionName, queryClient, relationTargets, guard, filer, subsets } = deps;
-  const pendingFilings = /* @__PURE__ */ new Map();
-  function expectFiling(field, settles) {
-    let pending = pendingFilings.get(field);
-    if (!pending) {
-      pending = [];
-      pendingFilings.set(field, pending);
-    }
-    pending.push(settles);
-    return () => {
-      const index = pending.indexOf(settles);
-      if (index !== -1) pending.splice(index, 1);
-      if (pending.length === 0) pendingFilings.delete(field);
-    };
-  }
-  async function awaitPendingFiling(field) {
-    const pending = pendingFilings.get(field);
-    if (pending && pending.length > 0) await Promise.all(pending);
-  }
-  function rowsFromStore(ids) {
-    const rows = [];
-    for (const id of ids) {
-      const row = deps.syncedRow(id);
-      if (!row) return void 0;
-      rows.push(row);
-    }
-    return rows;
-  }
-  function fieldSubsetFromStore(subset) {
-    if (!subsets.isLoaded(subset)) return void 0;
-    const wanted = new Set(subset.values);
-    return [...deps.syncedRows()].filter((row) => matchesSubset(row, subset.field, wanted));
-  }
-  function servedFromStore(request) {
-    const { subset, sort, limit } = request;
-    if (!subset) return void 0;
-    if (subset.values.length === 0) return [];
-    if (request.expand || sort && limit) return void 0;
-    const rows = subset.field === "id" ? rowsFromStore(subset.values) : fieldSubsetFromStore(subset);
-    return rows && limit ? rows.slice(0, limit) : rows;
-  }
-  async function fetchPage(request, expand, filter, index) {
-    const { sort, limit } = request;
-    const requestKey = `${collectionName}:${index}`;
-    if (limit) {
-      const result = await pb.collection(collectionName).getList(1, limit, { filter, sort, skipTotal: true, expand, requestKey });
-      return result.items;
-    }
-    const items = await pb.collection(collectionName).getFullList({ filter, sort, expand, requestKey });
-    return items;
-  }
-  async function fetchItems(request, heads) {
-    const served = servedFromStore(request);
-    if (served) return served;
-    if (request.subset && request.subset.field !== "id" && heads.length === 0) {
-      await awaitPendingFiling(request.subset.field);
-      const servedAfterFiling = servedFromStore(request);
-      if (servedAfterFiling) return servedAfterFiling;
-    }
-    const filters = request.subset ? subsetFilters(request.subset) : [request.filter];
-    const expand = deps.activeExpand(request);
-    const pages = await Promise.all(
-      filters.map((filter, index) => fetchPage(request, expand, filter, index))
-    );
-    const items = pages.flat();
-    filer.markEmptyBackRelations(items, heads);
-    return items;
-  }
-  function isAutoCancelled(error) {
-    return deps.ignoreAutoCancellation && error instanceof Error && error.message.includes("autocancelled");
-  }
-  async function fetchRecords(request, queryKey) {
-    const tracked = guard.trackFetch();
-    let settleFiling = () => void 0;
-    const filed = new Promise((resolve) => {
-      settleFiling = resolve;
-    });
-    const heads = backRelationHeads(deps.activeExpand(request), relationTargets);
-    const unregister = heads.map(({ target, field }) => target.expectFiling(field, filed));
-    try {
-      let items;
-      try {
-        items = await fetchItems(request, heads);
-      } catch (error) {
-        if (!isAutoCancelled(error)) throw error;
-        return guard.withRowsConfirmedMidFlight(
-          queryClient.getQueryData(queryKey) ?? [],
-          tracked.confirmed
-        );
-      }
-      await filer.upsertExpanded(items, relationTargets);
-      return guard.withRowsConfirmedMidFlight(
-        stripFetchedRelations(items, deps.activeExpand(request)),
-        tracked.confirmed
-      );
-    } finally {
-      tracked.done();
-      settleFiling();
-      for (const fn of unregister) fn();
-    }
-  }
-  return { fetchRecords, expectFiling };
-}
-
-// src/held-targets.ts
-function createHeldTargets(collectionName) {
-  const held = /* @__PURE__ */ new Map();
-  const filedByTarget = /* @__PURE__ */ new Map();
-  function filtersFor(target) {
-    const byField = filedByTarget.get(target);
-    if (!byField) return [];
-    const filters = [];
-    for (const [field, values] of byField) {
-      filters.push(
-        ...subsetFilters({ field, values: [...values] }, REALTIME_MAX_FILTER_LENGTH)
-      );
-    }
-    return filters;
-  }
-  function release(target) {
-    const hold2 = held.get(target);
-    if (!hold2) return;
-    held.delete(target);
-    try {
-      hold2.release();
-    } catch (error) {
-      logger.error("Failed to release relation target subscription", {
-        collectionName,
-        error
-      });
-    }
-  }
-  function hold(target) {
-    if (held.has(target)) return;
-    try {
-      const hold2 = target.holdLive();
-      held.set(target, hold2);
-      hold2.setFilters(filtersFor(target));
-    } catch (error) {
-      logger.error("Failed to hold relation target subscription", { collectionName, error });
-    }
-  }
-  function sync(desired) {
-    for (const target of [...held.keys()]) if (!desired.has(target)) release(target);
-    for (const target of desired) hold(target);
-  }
-  return {
-    recordFiled(target, field, values) {
-      let byField = filedByTarget.get(target);
-      if (!byField) {
-        byField = /* @__PURE__ */ new Map();
-        filedByTarget.set(target, byField);
-      }
-      let recorded = byField.get(field);
-      if (!recorded) {
-        recorded = /* @__PURE__ */ new Set();
-        byField.set(field, recorded);
-      }
-      let grew = false;
-      for (const value of values) {
-        if (recorded.has(value)) continue;
-        recorded.add(value);
-        grew = true;
-      }
-      if (grew) held.get(target)?.setFilters(filtersFor(target));
-    },
-    sync,
-    releaseAll: () => sync(/* @__PURE__ */ new Set()),
-    clearFiled: () => filedByTarget.clear(),
-    count: () => held.size
-  };
-}
-
-// src/request.ts
-function toRequest(opts) {
-  const request = {};
-  const subset = subsetFromWhere(opts?.where);
-  const filter = subset ? void 0 : convertToPocketBaseFilter(opts?.where);
-  const sort = convertToPocketBaseSort(opts?.orderBy);
-  const expand = joinPaths(opts?.expand ?? []);
-  if (subset) request.subset = subset;
-  if (filter) request.filter = filter;
-  if (sort) request.sort = sort;
-  if (opts?.limit) request.limit = opts.limit;
-  if (expand) request.expand = expand;
-  return request;
-}
-function queryKeyFor(collectionName, opts) {
-  const request = toRequest(opts);
-  return Object.keys(request).length === 0 ? [collectionName] : [collectionName, request];
-}
-function requestFromQueryKey(queryKey) {
-  return queryKey[1];
-}
-function realtimeFiltersFor(request) {
-  if (request.subset) return subsetFilters(request.subset, REALTIME_MAX_FILTER_LENGTH);
-  return request.filter ? [request.filter] : void 0;
-}
-
-// src/loaded-subsets.ts
-function createLoadedSubsets(collectionName, queryClient) {
-  const marks = /* @__PURE__ */ new Map();
-  function forgetValue(marked, value) {
-    if (typeof value === "string") return marked.delete(value) ? [value] : [];
-    if (!Array.isArray(value)) return [];
-    return value.filter((item) => typeof item === "string" && marked.delete(item));
-  }
-  function matchesMarked(query, isMarked) {
-    if (query.queryKey[0] !== collectionName) return false;
-    const subset = requestFromQueryKey(query.queryKey)?.subset;
-    if (!subset) return false;
-    return subset.values.some((value) => isMarked(subset.field, value));
-  }
-  function invalidate(isMarked) {
-    void queryClient.invalidateQueries({ predicate: (query) => matchesMarked(query, isMarked) }).catch(
-      (error) => logger.error("Failed to invalidate marked subset queries", {
-        collectionName,
-        error
-      })
-    );
-  }
-  return {
-    mark(field, value) {
-      let values = marks.get(field);
-      if (!values) {
-        values = /* @__PURE__ */ new Set();
-        marks.set(field, values);
-      }
-      values.add(value);
-    },
-    count() {
-      let count = 0;
-      for (const values of marks.values()) count += values.size;
-      return count;
-    },
-    isLoaded({ field, values }) {
-      const marked = marks.get(field);
-      return marked !== void 0 && values.every((value) => marked.has(value));
-    },
-    // Deferred: this runs inside TanStack's write batch, and
-    // invalidateQueries may start a queryFn synchronously.
-    forgetRow(row) {
-      if (!row || typeof row !== "object") return;
-      for (const [field, marked] of marks) {
-        const forgotten = forgetValue(marked, row[field]);
-        if (forgotten.length === 0) continue;
-        queueMicrotask(
-          () => invalidate(
-            (queryField, value) => queryField === field && forgotten.includes(value)
-          )
-        );
-      }
-    },
-    invalidateAll() {
-      invalidate((field, value) => marks.get(field)?.has(value) ?? false);
-    },
-    clear() {
-      marks.clear();
-    }
-  };
-}
-
-// src/filter-refs.ts
-var RefCounter = class {
-  constructor() {
-    this.counts = /* @__PURE__ */ new Map();
-  }
-  add(key) {
-    this.counts.set(key, (this.counts.get(key) ?? 0) + 1);
-  }
-  /** Drops one reference. Returns true when none remain. */
-  drop(key) {
-    const count = (this.counts.get(key) ?? 0) - 1;
-    if (count > 0) {
-      this.counts.set(key, count);
-      return false;
-    }
-    this.counts.delete(key);
-    return true;
-  }
-  has(key) {
-    return this.counts.has(key);
-  }
-  keys() {
-    return this.counts.keys();
-  }
-  clear() {
-    this.counts.clear();
-  }
-};
-
-// src/realtime-subscription.ts
-function createRealtimeSubscription(deps) {
-  const { pb, collectionName } = deps;
-  let starUnsubscribe = null;
-  let starExpand;
-  const filterEntries = /* @__PURE__ */ new Map();
-  const waiters = /* @__PURE__ */ new Set();
-  let collectionSubscribers = 0;
-  let unfilteredQueryRefs = 0;
-  const queryRefs = new RefCounter();
-  const holdRefs = new RefCounter();
-  const oversizedFilters = /* @__PURE__ */ new Set();
-  const isStarOpen = () => starUnsubscribe !== null;
-  const isOpen = () => isStarOpen() || filterEntries.size > 0;
-  const wantedFilters = () => /* @__PURE__ */ new Set([...queryRefs.keys(), ...holdRefs.keys()]);
-  const wantsStar = () => collectionSubscribers > 0 || unfilteredQueryRefs > 0 || oversizedFilters.size > 0;
-  function dropRef(refs, filter) {
-    if (refs.drop(filter) && !queryRefs.has(filter) && !holdRefs.has(filter)) {
-      oversizedFilters.delete(filter);
-    }
-  }
-  function notifyOpened() {
-    deps.onEntryOpened();
-    for (const resolve of waiters) resolve();
-    waiters.clear();
-  }
-  let work = Promise.resolve();
-  function enqueue(fn) {
-    work = work.then(fn, fn).catch((error) => {
-      logger.error("Subscription work failed", { collectionName, error });
-    });
-  }
-  async function openStar() {
-    if (isStarOpen()) return;
-    const expand = deps.pendingExpand();
-    try {
-      starUnsubscribe = await pb.collection(collectionName).subscribe("*", deps.handleEvent, deps.subscribeOptions());
-      starExpand = expand;
-      logger.debug("Subscription started", { collectionName });
-      notifyOpened();
-    } catch (error) {
-      logger.error("Failed to start subscription", { collectionName, error });
-    }
-  }
-  async function closeStar() {
-    const unsubscribe = starUnsubscribe;
-    if (!unsubscribe) return;
-    starUnsubscribe = null;
-    starExpand = void 0;
-    try {
-      await unsubscribe();
-      logger.debug("Subscription stopped", { collectionName });
-    } catch (error) {
-      logger.debug("Unsubscribe failed (expected if connection closed)", {
-        collectionName,
-        error
-      });
-    }
-  }
-  function filteredOptions(filter) {
-    const base = deps.subscribeOptions();
-    const combined = base?.filter ? `(${base.filter}) && (${filter})` : filter;
-    return { ...base, filter: combined };
-  }
-  async function openFilter(filter) {
-    if (filterEntries.has(filter)) return true;
-    const options = filteredOptions(filter);
-    const topicLength = realtimeTopicLength(collectionName, options);
-    if (topicLength > REALTIME_TOPIC_MAX_LENGTH) {
-      oversizedFilters.add(filter);
-      logger.warn("Realtime filter too long; subscribing to the whole collection", {
-        collectionName,
-        filterLength: filter.length,
-        topicLength
-      });
-      return false;
-    }
-    const expand = deps.pendingExpand();
-    try {
-      const unsubscribe = await pb.collection(collectionName).subscribe("*", deps.handleEvent, options);
-      filterEntries.set(filter, { unsubscribe, expand });
-      logger.debug("Filtered subscription started", { collectionName, filter });
-      notifyOpened();
-    } catch (error) {
-      logger.error("Failed to start filtered subscription", {
-        collectionName,
-        filter,
-        error
-      });
-    }
-    return true;
-  }
-  async function closeFilter(filter) {
-    const entry = filterEntries.get(filter);
-    if (!entry) return;
-    filterEntries.delete(filter);
-    try {
-      await entry.unsubscribe();
-      logger.debug("Filtered subscription stopped", { collectionName, filter });
-    } catch (error) {
-      logger.debug("Unsubscribe failed (expected if connection closed)", {
-        collectionName,
-        filter,
-        error
-      });
-    }
-  }
-  async function closeFilters(keep = () => false) {
-    for (const filter of [...filterEntries.keys()]) {
-      if (!keep(filter)) await closeFilter(filter);
-    }
-  }
-  async function openWantedFilters() {
-    if (wantsStar()) return;
-    for (const filter of wantedFilters()) {
-      if (!await openFilter(filter)) return;
-    }
-  }
-  function expandDrifted() {
-    const pending = deps.pendingExpand();
-    if (isStarOpen() && starExpand !== pending) return true;
-    for (const entry of filterEntries.values()) if (entry.expand !== pending) return true;
-    return false;
-  }
-  async function doReconcile() {
-    await openWantedFilters();
-    if (wantsStar()) {
-      await openStar();
-      if (isStarOpen()) await closeFilters();
-    } else {
-      await closeStar();
-      const wanted = wantedFilters();
-      await closeFilters((filter) => wanted.has(filter));
-    }
-    if (!isOpen() && !wantsStar() && wantedFilters().size === 0) deps.onIdle();
-    if (expandDrifted()) restart();
-  }
-  async function doRestart() {
-    if (!isOpen()) return;
-    await closeStar();
-    await closeFilters();
-    await doReconcile();
-  }
-  const reconcile = () => enqueue(doReconcile);
-  const restart = () => enqueue(doRestart);
-  return {
-    addCollectionSubscriber() {
-      collectionSubscribers += 1;
-    },
-    dropCollectionSubscriber() {
-      collectionSubscribers -= 1;
-    },
-    retainQueryFilters(filters) {
-      if (!filters) unfilteredQueryRefs += 1;
-      else for (const filter of filters) queryRefs.add(filter);
-      reconcile();
-    },
-    releaseQueryFilters(filters) {
-      if (!filters) unfilteredQueryRefs -= 1;
-      else for (const filter of filters) dropRef(queryRefs, filter);
-      reconcile();
-    },
-    resetQueryFilters() {
-      queryRefs.clear();
-      unfilteredQueryRefs = 0;
-      for (const filter of oversizedFilters) {
-        if (!holdRefs.has(filter)) oversizedFilters.delete(filter);
-      }
-      reconcile();
-    },
-    swapHoldFilters(previous, next) {
-      for (const filter of next) if (!previous.includes(filter)) holdRefs.add(filter);
-      for (const filter of previous) if (!next.includes(filter)) dropRef(holdRefs, filter);
-      reconcile();
-    },
-    reconcile,
-    restart,
-    isOpen,
-    wait(timeout = 5e3) {
-      if (isOpen()) return Promise.resolve();
-      return new Promise((resolve, reject) => {
-        const onOpen = () => {
-          clearTimeout(timer);
-          resolve();
-        };
-        const timer = setTimeout(() => {
-          waiters.delete(onOpen);
-          reject(new Error("Subscription timeout"));
-        }, timeout);
-        waiters.add(onOpen);
-      });
-    }
-  };
-}
-
-// src/synced-write-guard.ts
-function createSyncedWriteGuard(collectionName, store) {
-  let applyingOwnWrite = false;
-  const inFlight = /* @__PURE__ */ new Set();
-  function isStaleServerRecord(record) {
-    const id = idOf(record);
-    if (!id) return false;
-    const incoming = updatedAtOf(record);
-    if (!incoming) return false;
-    const current = updatedAtOf(store.syncedRow(id));
-    return current !== void 0 && incoming < current;
-  }
-  function writeKey(op) {
-    if (op.type !== "insert" && op.type !== "update") return null;
-    if (typeof op.key === "string") return op.key;
-    return idOf(op.value) ?? null;
-  }
-  function markConfirmedPresent(records) {
-    if (inFlight.size === 0) return;
-    for (const record of records) {
-      const id = idOf(record);
-      if (!id) continue;
-      for (const confirmed of inFlight) confirmed.add(id);
-    }
-  }
-  function withRowsConfirmedMidFlight(items, confirmed) {
-    if (confirmed.size === 0) return items;
-    const resultIds = new Set(items.map(idOf));
-    const merged = [];
-    for (const id of confirmed) {
-      if (resultIds.has(id)) continue;
-      const row = store.syncedRow(id);
-      if (row) merged.push(row);
-    }
-    if (merged.length === 0) return items;
-    logger.debug("Merging rows confirmed while fetch was in flight", {
-      collectionName,
-      ids: merged.map(idOf)
-    });
-    return [...items, ...merged];
-  }
-  return {
-    writeOwn(fn) {
-      applyingOwnWrite = true;
-      try {
-        fn();
-      } finally {
-        applyingOwnWrite = false;
-      }
-    },
-    isOwnWrite: () => applyingOwnWrite,
-    // A write to a key the synced store lacks is populating it and must
-    // pass, or the row is absent once the overlay clears.
-    shouldDrop(op) {
-      const key = writeKey(op);
-      if (key === null) return false;
-      if (!applyingOwnWrite && store.hasPendingMutation(key) && store.syncedRow(key)) {
-        logger.debug("Dropping synced write for optimistically-pending row", {
-          collectionName,
-          id: key
-        });
-        return true;
-      }
-      if (isStaleServerRecord(op.value)) {
-        logger.debug("Dropping stale synced write", { collectionName, id: key });
-        return true;
-      }
-      return false;
-    },
-    isStaleServerRecord,
-    markConfirmedPresent,
-    trackFetch() {
-      const confirmed = /* @__PURE__ */ new Set();
-      inFlight.add(confirmed);
-      return { confirmed, done: () => inFlight.delete(confirmed) };
-    },
-    withRowsConfirmedMidFlight,
-    // Rows are marked confirmed at once. The write waits for persistence
-    // (see docs/internals.md, "Write-back timing"), skips a collection
-    // that is not ready, and drops rows the store already supersedes.
-    writeBackAfterPersisted(transaction, records) {
-      markConfirmedPresent(records);
-      void transaction.isPersisted.promise.then(
-        () => {
-          if (!store.isReady()) return;
-          const fresh = records.filter((record) => !isStaleServerRecord(record));
-          if (fresh.length > 0) this.writeOwn(() => store.writeUpsert(fresh));
-        },
-        () => void 0
-      );
-    }
-  };
-}
-
-// src/views.ts
-function createViewRegistry(subscribe) {
-  const tags = /* @__PURE__ */ new WeakMap();
-  let subscribing;
-  function tagFor(opts) {
-    return (opts.subscription && tags.get(opts.subscription)) ?? subscribing;
-  }
-  return {
-    tagFor,
-    withViewExpand(opts) {
-      const paths = tagFor(opts)?.paths;
-      return paths ? { ...opts, expand: paths } : opts;
-    },
-    subscribeTagged(tag, args) {
-      subscribing = tag;
-      try {
-        const subscription = subscribe(...args);
-        if (tag) tags.set(subscription, tag);
-        return subscription;
-      } finally {
-        subscribing = void 0;
-      }
-    }
-  };
-}
-function createViews(deps) {
-  const { collectionName, collection, alwaysFetch, relationTargets, realtimeMode } = deps;
-  const views = /* @__PURE__ */ new Map();
-  function createView(tag) {
-    const query = [];
-    if (tag.paths.length > 0) query.push(`expand=${tag.paths.join(",")}`);
-    if (tag.realtime) query.push(`realtime=${tag.realtime}`);
-    const view = Object.create(collection);
-    Object.defineProperties(view, {
-      id: { value: `${collectionName}?${query.join("&")}` },
-      subscribeChanges: { value: deps.subscribeChangesFor(tag) },
-      fetchRelations: {
-        value: (...more) => viewFor([...tag.paths, ...more], tag.realtime)
-      },
-      withRealtime: {
-        value: (mode) => {
-          deps.assertRealtimeMode(mode);
-          const override = mode === realtimeMode ? void 0 : mode;
-          if (tag.realtime !== void 0 && tag.realtime !== override) {
-            throw new Error(
-              `A view of "${collectionName}" already uses realtime '${tag.realtime}'`
-            );
-          }
-          return viewFor(tag.paths, mode);
-        }
-      }
-    });
-    return view;
-  }
-  function viewFor(paths, realtime) {
-    for (const path of paths) validateExpandPath(collectionName, relationTargets, path);
-    const all = normalizePaths([...alwaysFetch, ...paths]);
-    const override = realtime === realtimeMode ? void 0 : realtime;
-    if (override === void 0 && all.every((path) => alwaysFetch.includes(path))) {
-      return collection;
-    }
-    const key = `${all.join(",")}|${override ?? ""}`;
-    let view = views.get(key);
-    if (!view) {
-      view = createView({ paths: all, realtime: override });
-      views.set(key, view);
-    }
-    return view;
-  }
-  return {
-    fetchRelations: (...paths) => viewFor(paths, void 0),
-    withRealtime: (mode) => {
-      deps.assertRealtimeMode(mode);
-      return viewFor([], mode);
-    }
-  };
-}
-
-// src/build-collection.ts
-var REALTIME_MODES = ["collection", "query"];
-function registerMarkInvalidationEvents(collection, clearMarks) {
-  collection.onStatusChange((event) => {
-    if (event.status === "cleaned-up") clearMarks();
-  });
-  collection.onTruncate(() => clearMarks());
-}
-function buildCollection(input) {
-  const { pb, queryClient, factoryOptions, collectionName, options } = input;
-  const relationTargets = options?.relations;
-  for (const [key, target] of Object.entries(relationTargets ?? {})) {
-    if (typeof target?.writeFiled !== "function" || typeof target.holdLive !== "function" || typeof target.expectFiling !== "function") {
-      throw new Error(
-        `Collection '${collectionName}': relation '${key}' is not a pbtsdb collection`
-      );
-    }
-  }
-  const alwaysFetch = normalizePaths(options?.alwaysFetchRelations ?? []);
-  for (const path of alwaysFetch) validateExpandPath(collectionName, relationTargets, path);
-  const syncMode = options?.syncMode ?? "eager";
-  const realtimeMode = options?.realtime ?? "collection";
-  const ignoreAutoCancellation = options?.ignoreAutoCancellation ?? true;
-  const refetchOnMutation = options?.refetchOnMutation ?? false;
-  function assertRealtimeMode(mode) {
-    if (!REALTIME_MODES.includes(mode)) {
-      throw new Error(
-        `Collection '${collectionName}': unknown realtime mode '${String(mode)}'`
-      );
-    }
-    if (mode === "query" && syncMode !== "on-demand") {
-      throw new Error(
-        `Collection '${collectionName}': realtime 'query' requires syncMode 'on-demand'`
-      );
-    }
-  }
-  assertRealtimeMode(realtimeMode);
-  const requestedExpand = /* @__PURE__ */ new Set();
-  const pendingSubscribeExpand = () => joinPaths([...alwaysFetch, ...requestedExpand]);
-  function activeExpand(request) {
-    return joinPaths([
-      ...alwaysFetch,
-      ...splitPaths(request.expand),
-      ...syncMode === "eager" ? requestedExpand : []
-    ]);
-  }
-  function realtimeSubscribeOptions() {
-    const base = factoryOptions?.subscribeOptions?.();
-    const expand = joinPaths([
-      ...splitPaths(pendingSubscribeExpand()),
-      ...splitPaths(base?.expand)
-    ]);
-    return expand ? { ...base, expand } : base;
-  }
-  function releaseAll() {
-    held.releaseAll();
-    subsets.invalidateAll();
-    subsets.clear();
-  }
-  const syncedRow = (id) => collection._state.syncedData.get(id);
-  const syncedRows = () => collection._state.syncedData.values();
-  const subsets = createLoadedSubsets(collectionName, queryClient);
-  const held = createHeldTargets(collectionName);
-  const filer = createExpandFiler(collectionName, held.recordFiled);
-  const guard = createSyncedWriteGuard(collectionName, {
-    isReady: () => collection.isReady(),
-    syncedRow,
-    // A visible row reports its own overlay; an invisible row with a
-    // synced copy is under an optimistic delete.
-    hasPendingMutation: (id) => {
-      const visible = collection.get(id);
-      return visible ? !visible.$synced : syncedRow(id) !== void 0;
-    },
-    writeUpsert: (records) => collection.utils.writeUpsert(records)
-  });
-  const fetcher = createFetcher({
-    pb,
-    collectionName,
-    queryClient,
-    relationTargets,
-    ignoreAutoCancellation,
-    activeExpand,
-    syncedRow,
-    syncedRows,
-    subsets,
-    guard,
-    filer
-  });
-  const realtime = createRealtimeSubscription({
-    pb,
-    collectionName,
-    handleEvent: (event) => handleRealtimeEvent(event),
-    pendingExpand: pendingSubscribeExpand,
-    subscribeOptions: realtimeSubscribeOptions,
-    onEntryOpened: () => held.sync(targetsAlong(splitPaths(pendingSubscribeExpand()), relationTargets)),
-    onIdle: releaseAll
-  });
-  function resolveHandler(option, fallback) {
-    return option === false ? void 0 : option ?? fallback;
-  }
-  const defaultInsert = async ({ transaction }) => {
-    const created = await Promise.all(
-      transaction.mutations.map(async (mutation) => {
-        const {
-          created: _created,
-          updated: _updated,
-          collectionId: _collectionId,
-          collectionName: _collectionName,
-          ...data
-        } = mutation.modified;
-        return pb.collection(collectionName).create(data);
-      })
-    );
-    guard.writeBackAfterPersisted(transaction, created);
-    return { refetch: refetchOnMutation };
-  };
-  const defaultUpdate = async ({ transaction }) => {
-    const updated = await Promise.all(
-      transaction.mutations.map(async (mutation) => {
-        return pb.collection(collectionName).update(mutation.original.id, mutation.changes);
-      })
-    );
-    guard.writeBackAfterPersisted(transaction, updated);
-    return { refetch: refetchOnMutation };
-  };
-  const defaultDelete = async ({ transaction }) => {
-    await Promise.all(
-      transaction.mutations.map(async (mutation) => {
-        await pb.collection(collectionName).delete(mutation.original.id);
-      })
-    );
-    return { refetch: refetchOnMutation };
-  };
-  const queryCollectionConfig = queryCollectionOptions({
-    autoIndex: "eager",
-    defaultIndexType: BTreeIndex,
-    ...options?.collectionOptions,
-    queryClient,
-    queryKey: (opts) => queryKeyFor(collectionName, opts),
-    syncMode,
-    queryFn: (ctx) => fetcher.fetchRecords(requestFromQueryKey(ctx.queryKey) ?? {}, ctx.queryKey),
-    getKey: (item) => {
-      const id = idOf(item);
-      if (id === void 0) {
-        throw new Error(
-          `Record in collection '${collectionName}' is missing required 'id' field. Received: ${JSON.stringify(item)}`
-        );
-      }
-      return id;
-    },
-    onInsert: resolveHandler(options?.onInsert, defaultInsert),
-    onUpdate: resolveHandler(options?.onUpdate, defaultUpdate),
-    onDelete: resolveHandler(options?.onDelete, defaultDelete)
-  });
-  const collectionOptions = options?.collectionOptions?.gcTime === void 0 ? queryCollectionConfig : { ...queryCollectionConfig, gcTime: options.collectionOptions.gcTime };
-  let retainedFilters = /* @__PURE__ */ new WeakMap();
-  function retainQueryFilters(opts) {
-    if ((registry.tagFor(opts)?.realtime ?? realtimeMode) !== "query") return;
-    const filters = realtimeFiltersFor(toRequest(opts));
-    const records = retainedFilters.get(opts) ?? [];
-    records.push({ filters });
-    retainedFilters.set(opts, records);
-    realtime.retainQueryFilters(filters);
-  }
-  function releaseQueryFilters(opts) {
-    const records = retainedFilters.get(opts);
-    const retained = records?.shift();
-    if (!retained) return;
-    if (records?.length === 0) retainedFilters.delete(opts);
-    realtime.releaseQueryFilters(retained.filters);
-  }
-  const innerSync = collectionOptions.sync.sync;
-  collectionOptions.sync = {
-    ...collectionOptions.sync,
-    sync: (params) => {
-      const guardedWrite = (message) => {
-        const op = message;
-        if (op.type === "delete" && !guard.isOwnWrite()) subsets.forgetRow(op.value);
-        if (guard.shouldDrop(op)) return;
-        return params.write(message);
-      };
-      const res = innerSync({ ...params, write: guardedWrite });
-      if (!res) return res;
-      const parts = typeof res === "function" ? { cleanup: res } : res;
-      const { cleanup, loadSubset, unloadSubset } = parts;
-      return {
-        ...parts,
-        // TanStack drops a discarded sync session's demands without
-        // unloadSubset and reloads them on the next session.
-        cleanup: () => {
-          retainedFilters = /* @__PURE__ */ new WeakMap();
-          realtime.resetQueryFilters();
-          return cleanup?.();
-        },
-        loadSubset: loadSubset ? (opts) => {
-          retainQueryFilters(opts);
-          try {
-            return loadSubset(registry.withViewExpand(opts));
-          } catch (error) {
-            releaseQueryFilters(opts);
-            throw error;
-          }
-        } : void 0,
-        unloadSubset: unloadSubset ? (opts) => {
-          releaseQueryFilters(opts);
-          return unloadSubset(registry.withViewExpand(opts));
-        } : void 0
-      };
-    }
-  };
-  const collection = createCollection$1(collectionOptions);
-  const originalSubscribeChanges = collection.subscribeChanges.bind(collection);
-  const registry = createViewRegistry(originalSubscribeChanges);
-  function subscribeCounted(subscribe) {
-    realtime.addCollectionSubscriber();
-    let subscription;
-    try {
-      subscription = subscribe();
-    } catch (error) {
-      realtime.dropCollectionSubscriber();
-      throw error;
-    }
-    const unsubscribe = subscription.unsubscribe.bind(subscription);
-    let released = false;
-    subscription.unsubscribe = () => {
-      if (!released) {
-        released = true;
-        realtime.dropCollectionSubscriber();
-        realtime.reconcile();
-      }
-      unsubscribe();
-    };
-    return subscription;
-  }
-  function subscribeChangesFor(tag) {
-    return (...args) => {
-      if (tag) noteViewSubscribed(tag.paths);
-      const subscription = (tag?.realtime ?? realtimeMode) === "collection" ? subscribeCounted(() => registry.subscribeTagged(tag, args)) : registry.subscribeTagged(tag, args);
-      realtime.reconcile();
-      return subscription;
-    };
-  }
-  Object.defineProperty(collection, "subscribeChanges", {
-    value: subscribeChangesFor(void 0)
-  });
-  const views = createViews({
-    collectionName,
-    collection,
-    alwaysFetch,
-    relationTargets,
-    realtimeMode,
-    assertRealtimeMode,
-    subscribeChangesFor
-  });
-  function isStaleEcho(event) {
-    if (event.action !== "create" && event.action !== "update") return false;
-    if (!guard.isStaleServerRecord(event.record)) return false;
-    logger.debug("Ignoring stale realtime echo", { collectionName, id: idOf(event.record) });
-    return true;
-  }
-  function handleRealtimeEvent(event) {
-    if (!collection.utils) return;
-    if (event.action !== "delete") guard.markConfirmedPresent([event.record]);
-    if (isStaleEcho(event)) return;
-    const [stored] = stripFetchedRelations([event.record], pendingSubscribeExpand());
-    try {
-      guard.writeOwn(
-        () => collection.utils.writeBatch(() => {
-          switch (event.action) {
-            case "create":
-              collection.utils.writeInsert(stored);
-              break;
-            case "update":
-              collection.utils.writeUpsert(stored);
-              break;
-            case "delete": {
-              const id = idOf(event.record);
-              if (id) collection.utils.writeDelete(id);
-              break;
-            }
-          }
-        })
-      );
-    } catch (error) {
-      if (!(error instanceof DeleteOperationItemNotFoundError)) throw error;
-      logger.debug("Ignoring delete echo for already-removed record", {
-        collectionName,
-        id: idOf(event.record)
-      });
-    }
-    if (event.action !== "delete") {
-      filer.upsertExpanded([event.record], relationTargets).catch(
-        (error) => logger.error("Failed to upsert expanded records from realtime echo", {
-          collectionName,
-          error
-        })
-      );
-    }
-  }
-  async function writeFiled(records) {
-    if (!collection.isReady()) {
-      const idle = collection.status === "idle" || collection.status === "cleaned-up";
-      if (syncMode === "eager" && idle) {
-        logger.warn(
-          `not syncing filed rows into ${collectionName} because store is not yet ready`
-        );
-        return false;
-      }
-      await collection.preload();
-    }
-    collection.utils.writeUpsert(withoutExpand(records));
-    return true;
-  }
-  function holdLive() {
-    const subscribe = () => originalSubscribeChanges(() => {
-    }, { includeInitialState: false });
-    const subscription = realtimeMode === "collection" ? subscribeCounted(subscribe) : subscribe();
-    let current = [];
-    let released = false;
-    realtime.reconcile();
-    return {
-      setFilters: (filters) => {
-        if (released) return;
-        const next = [...new Set(filters)];
-        realtime.swapHoldFilters(current, next);
-        current = next;
-      },
-      release: () => {
-        if (released) return;
-        released = true;
-        realtime.swapHoldFilters(current, []);
-        current = [];
-        subscription.unsubscribe();
-      }
-    };
-  }
-  function noteViewSubscribed(paths) {
-    let grew = false;
-    for (const path of paths) {
-      if (requestedExpand.has(path)) continue;
-      requestedExpand.add(path);
-      grew = true;
-    }
-    if (!grew) return;
-    if (syncMode === "eager" && collection.status !== "idle" && collection.status !== "cleaned-up") {
-      void collection.utils.refetch().catch(
-        (error) => logger.error("Failed to refetch after widening expand", {
-          collectionName,
-          error
-        })
-      );
-    }
-    realtime.restart();
-  }
-  registerMarkInvalidationEvents(
-    {
-      onStatusChange: (callback) => collection.on("status:change", callback),
-      onTruncate: (callback) => collection.on("truncate", callback)
-    },
-    () => {
-      subsets.clear();
-      held.clearFiled();
-    }
-  );
-  Object.assign(collection, {
-    collectionName,
-    relationTargets,
-    waitForSubscription: realtime.wait,
-    isSubscribed: realtime.isOpen,
-    heldRelationTargetCount: held.count,
-    markSubsetLoaded: subsets.mark,
-    loadedSubsetCount: subsets.count,
-    holdLive,
-    writeFiled,
-    expectFiling: fetcher.expectFiling,
-    fetchRelations: views.fetchRelations,
-    withRealtime: views.withRealtime
-  });
-  return collection;
-}
-
-// src/collection.ts
-function createCollection(pb, queryClient, factoryOptions) {
-  return (collectionName, options) => {
-    return buildCollection({
-      pb,
-      queryClient,
-      factoryOptions,
-      collectionName,
-      options
-    });
-  };
-}
-
-// src/util.ts
-function newRecordId() {
-  const chars = "abcdefghijklmnopqrstuvwxyz0123456789";
-  let result = "";
-  for (let i = 0; i < 15; i++) {
-    result += chars.charAt(Math.floor(Math.random() * chars.length));
-  }
-  return result;
-}
-
-export { createCollection, newRecordId, resetLogger, setLogger };
-//# sourceMappingURL=chunk-X7ZGPVG2.js.map
-//# sourceMappingURL=chunk-X7ZGPVG2.js.map