pbtsdb 0.11.0 → 2.0.0

package/dist/chunk-4CRCARB3.js

@@ -0,0 +1,2954 @@
+import { parseWhereExpression, parseOrderByExpression, IR, createCollection as createCollection$1, BTreeIndex, whenSyncAccepted, LoadSubsetOperationAbortedError, compileSingleRowExpression, toBooleanPredicate } from '@tanstack/db';
+export { BTreeIndex, BasicIndex, ReverseIndex, createEffect, materialize, toArray } from '@tanstack/db';
+
+// 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 idsOf(rows) {
+  return rows.map(idOf).filter((id) => 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 tailsOf(paths, key) {
+  return paths.filter((path) => path.startsWith(`${key}.`)).map((path) => path.slice(key.length + 1));
+}
+function createExpandFiler(deps) {
+  const { collectionName, setFiled, holder } = deps;
+  function entryFor2(perRoot, root) {
+    let found = perRoot.get(root);
+    if (!found) {
+      found = { rows: /* @__PURE__ */ new Set(), parents: /* @__PURE__ */ new Set() };
+      perRoot.set(root, found);
+    }
+    return found;
+  }
+  function addTo(index, key, value) {
+    let values = index.get(key);
+    if (!values) {
+      values = /* @__PURE__ */ new Set();
+      index.set(key, values);
+    }
+    values.add(value);
+  }
+  function rootsReaching(records, via, rootsOf, perRoot) {
+    for (const record of records) {
+      const parentId = idOf(record);
+      if (!parentId) continue;
+      for (const root of rootsOf(parentId)) {
+        const found = entryFor2(perRoot, root);
+        if (via) found.parents.add(parentId);
+      }
+    }
+  }
+  function collectRoots(records, group, requested, via, rootsOf) {
+    const perRoot = /* @__PURE__ */ new Map();
+    const childRoots = /* @__PURE__ */ new Map();
+    if (requested) rootsReaching(records, via, rootsOf, perRoot);
+    for (const [parentId, values] of group.byParent) {
+      const ids = idsOf(values);
+      for (const root of rootsOf(parentId)) {
+        const found = entryFor2(perRoot, root);
+        found.parents.add(parentId);
+        for (const id of ids) {
+          found.rows.add(id);
+          addTo(childRoots, id, root);
+        }
+      }
+    }
+    return { perRoot, childRoots };
+  }
+  function clearDeeper(root, targets, paths, prefix, releases) {
+    if (!targets) return;
+    for (const head of new Set(paths.map((path) => path.split(".")[0]))) {
+      const target = targets[head];
+      if (!target) continue;
+      releases.push(setFiled(root, target, `${prefix}${head}`, [], []));
+      clearDeeper(
+        root,
+        target.relationTargets,
+        tailsOf(paths, head),
+        `${prefix}${head}.`,
+        releases
+      );
+    }
+  }
+  async function fileKey(records, level, key, target, group, requested) {
+    const via = parseViaKey(key) !== void 0;
+    const { perRoot, childRoots } = collectRoots(records, group, requested, via, level.rootsOf);
+    const values = lastById(group.values);
+    const tails = tailsOf(level.requestedPaths, key);
+    const path = `${level.prefix}${key}`;
+    if (values.length > 0) {
+      await fileLevel(values, target.relationTargets, {
+        requestedPaths: tails,
+        releases: level.releases,
+        rootsOf: (id) => childRoots.get(id) ?? [],
+        prefix: `${path}.`
+      });
+      if (!await target.writeFiled(values, holder)) return;
+    }
+    for (const [root, { rows, parents }] of perRoot) {
+      level.releases.push(setFiled(root, target, path, rows, via ? parents : rows));
+      if (rows.size === 0) {
+        clearDeeper(root, target.relationTargets, tails, `${path}.`, level.releases);
+      }
+    }
+    for (const [parentId, parentValues] of group.byParent) {
+      markFiledSubset(target, key, parentValues, parentId);
+    }
+  }
+  async function fileLevel(records, targets, level) {
+    if (!targets) return;
+    const grouped = groupExpandedByKey(records);
+    const heads = new Set(level.requestedPaths.map((path) => path.split(".")[0]));
+    for (const key of /* @__PURE__ */ new Set([...grouped.keys(), ...heads])) {
+      const target = targets[key];
+      if (!target) {
+        if (grouped.has(key)) {
+          logger.debug("No relation target for expanded field", { collectionName, key });
+        }
+        continue;
+      }
+      const group = grouped.get(key) ?? { values: [], byParent: [] };
+      await fileKey(records, level, key, target, group, heads.has(key));
+    }
+  }
+  async function fileExpanded(records, targets, requestedPaths) {
+    const releases = [];
+    try {
+      await fileLevel(
+        records.filter((record) => !deps.isStale(record)),
+        targets,
+        { requestedPaths, releases, rootsOf: (id) => [id], prefix: "" }
+      );
+    } catch (error) {
+      for (const change of [...releases].reverse()) change.undo();
+      throw error;
+    }
+    return {
+      commit: () => {
+        for (const change of releases) change.commit();
+      },
+      undo: () => {
+        for (const change of [...releases].reverse()) change.undo();
+      }
+    };
+  }
+  async function upsertExpanded(records, targets, requestedPaths) {
+    (await fileExpanded(records, targets, requestedPaths)).commit();
+  }
+  function targetsReady(records, targets) {
+    for (const [key, group] of groupExpandedByKey(records)) {
+      const target = targets[key];
+      if (!target) continue;
+      if (!target.isReady()) return false;
+      const nested = target.relationTargets;
+      if (nested && !targetsReady(lastById(group.values), nested)) return false;
+    }
+    return true;
+  }
+  function canFileFirst(records, targets) {
+    if (!targets) return false;
+    const toFile = [...groupExpandedByKey(records).keys()].some((key) => targets[key]);
+    return toFile && targetsReady(records, targets);
+  }
+  return {
+    fileExpanded,
+    upsertExpanded,
+    canFileFirst,
+    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) target.markSubsetLoaded(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 realtimeTopic(collectionName, options) {
+  const topic = `${collectionName}/*`;
+  if (!options) return topic;
+  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}`;
+}
+function realtimeTopicLength(collectionName, options) {
+  return realtimeTopic(collectionName, options).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
+var NO_FILINGS = { commit: () => void 0, undo: () => void 0 };
+var FetchAbortedError = class extends Error {
+  constructor(collectionName) {
+    super(`${collectionName}: fetch aborted`);
+    this.name = "AbortError";
+  }
+};
+function createFetcher(deps) {
+  const { pb, collectionName, relationTargets, filer, subsets } = deps;
+  const pendingFilings = /* @__PURE__ */ new Map();
+  let requestSeq = 0;
+  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 || request.cursor || sort && limit) return void 0;
+    const rows = subset.field === "id" ? rowsFromStore(subset.values) : fieldSubsetFromStore(subset);
+    return rows && limit ? rows.slice(0, limit) : rows;
+  }
+  function withCursor(filter, cursor) {
+    if (!cursor) return filter;
+    return filter ? `(${filter}) && (${cursor})` : cursor;
+  }
+  async function fetchPage(request, expand, chunkFilter, requestKey, offset, signal) {
+    const { sort, limit } = request;
+    const filter = withCursor(chunkFilter, request.cursor);
+    if (limit) {
+      if (offset % limit === 0) {
+        const result2 = await pb.collection(collectionName).getList(offset / limit + 1, limit, {
+          filter,
+          sort,
+          skipTotal: true,
+          expand,
+          requestKey,
+          signal
+        });
+        return result2.items;
+      }
+      const result = await pb.collection(collectionName).getList(1, offset + limit, {
+        filter,
+        sort,
+        skipTotal: true,
+        expand,
+        requestKey,
+        signal
+      });
+      return result.items.slice(offset);
+    }
+    const items = await pb.collection(collectionName).getFullList({ filter, sort, expand, requestKey, signal });
+    return items.slice(offset);
+  }
+  function chunkRequest(request, chunks) {
+    const offset = request.offset ?? 0;
+    if (chunks === 1 || offset === 0) return { request, offset };
+    const limit = request.limit ? offset + request.limit : void 0;
+    return { request: { ...request, limit }, offset: 0 };
+  }
+  async function fetchItems(request, heads, refetch, cancel) {
+    const served = refetch ? void 0 : servedFromStore(request);
+    if (served) return { rows: served, fromStore: true };
+    if (!refetch && request.subset && request.subset.field !== "id" && heads.length === 0) {
+      await awaitPendingFiling(request.subset.field);
+      const servedAfterFiling = servedFromStore(request);
+      if (servedAfterFiling) return { rows: servedAfterFiling, fromStore: true };
+    }
+    const filters = request.subset ? subsetFilters(request.subset) : [request.filter];
+    const expand = deps.activeExpand(request);
+    const chunk = chunkRequest(request, filters.length);
+    const load = ++requestSeq;
+    const pages = await Promise.all(
+      filters.map((chunkFilter, index) => {
+        const requestKey = `${collectionName}:${load}:${index}`;
+        cancel.keys.push(requestKey);
+        return fetchPage(
+          chunk.request,
+          expand,
+          chunkFilter,
+          requestKey,
+          chunk.offset,
+          cancel.controller.signal
+        );
+      })
+    );
+    const items = pages.flat();
+    filer.markEmptyBackRelations(items, heads);
+    return { rows: items, fromStore: false };
+  }
+  async function fetchRecords(request, options = {}) {
+    const { signals = [] } = options;
+    const aborted = () => signals.some((signal) => signal.aborted);
+    const cancel = { controller: new AbortController(), keys: [] };
+    const onAbort = () => {
+      cancel.controller.abort();
+      for (const key of cancel.keys) pb.cancelRequest(key);
+    };
+    for (const signal of signals) signal.addEventListener("abort", onAbort, { once: true });
+    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 {
+      if (aborted()) throw new FetchAbortedError(collectionName);
+      const result = await fetchItems(request, heads, options.refetch === true, cancel).catch(
+        (error) => {
+          if (aborted()) throw new FetchAbortedError(collectionName);
+          throw error;
+        }
+      );
+      if (aborted()) throw new FetchAbortedError(collectionName);
+      const filings = result.fromStore ? NO_FILINGS : await filer.fileExpanded(
+        result.rows,
+        relationTargets,
+        splitPaths(deps.activeExpand(request))
+      );
+      if (aborted()) {
+        filings.undo();
+        throw new FetchAbortedError(collectionName);
+      }
+      return {
+        rows: stripFetchedRelations(result.rows, deps.activeExpand(request)),
+        fromStore: result.fromStore,
+        filings
+      };
+    } finally {
+      for (const signal of signals) signal.removeEventListener("abort", onAbort);
+      settleFiling();
+      for (const fn of unregister) fn();
+    }
+  }
+  return { fetchRecords, serveFromStore: servedFromStore, expectFiling };
+}
+
+// src/held-targets.ts
+function createHeldTargets(collectionName, holder) {
+  const held = /* @__PURE__ */ new Map();
+  const filings = /* @__PURE__ */ new Map();
+  const rowRefs = /* @__PURE__ */ new Map();
+  const filterRefs = /* @__PURE__ */ new Map();
+  function filtersFor(target) {
+    const byField = filterRefs.get(target);
+    if (!byField) return [];
+    const filters = [];
+    for (const [field, values] of byField) {
+      if (values.size === 0) continue;
+      filters.push(
+        ...subsetFilters({ field, values: [...values.keys()] }, REALTIME_MAX_FILTER_LENGTH)
+      );
+    }
+    return filters;
+  }
+  function bump(counts, key, delta) {
+    const next = (counts.get(key) ?? 0) + delta;
+    if (next <= 0) {
+      counts.delete(key);
+      return delta < 0;
+    }
+    counts.set(key, next);
+    return delta > 0 && next === 1;
+  }
+  function filterRef(target, field, value, delta) {
+    let byField = filterRefs.get(target);
+    if (!byField) {
+      byField = /* @__PURE__ */ new Map();
+      filterRefs.set(target, byField);
+    }
+    let values = byField.get(field);
+    if (!values) {
+      values = /* @__PURE__ */ new Map();
+      byField.set(field, values);
+    }
+    return bump(values, value, delta);
+  }
+  function rowRef(target, id, delta) {
+    let counts = rowRefs.get(target);
+    if (!counts) {
+      counts = /* @__PURE__ */ new Map();
+      rowRefs.set(target, counts);
+    }
+    return bump(counts, id, delta);
+  }
+  function filedUnder(rootId, target) {
+    let byTarget = filings.get(rootId);
+    if (!byTarget) {
+      byTarget = /* @__PURE__ */ new Map();
+      filings.set(rootId, byTarget);
+    }
+    let byKey = byTarget.get(target);
+    if (!byKey) {
+      byKey = /* @__PURE__ */ new Map();
+      byTarget.set(target, byKey);
+    }
+    return byKey;
+  }
+  function fieldFor(key) {
+    const last = key.split(".").at(-1) ?? key;
+    return parseViaKey(last)?.field ?? "id";
+  }
+  function diff(previous, next) {
+    return {
+      added: [...next].filter((value) => !previous.has(value)),
+      removed: [...previous].filter((value) => !next.has(value))
+    };
+  }
+  function swapFilterRefs(target, field, previous, next) {
+    const { added, removed } = diff(previous, next);
+    let changed = false;
+    for (const value of added) if (filterRef(target, field, value, 1)) changed = true;
+    for (const value of removed) if (filterRef(target, field, value, -1)) changed = true;
+    return changed;
+  }
+  function swapRowRefs(target, previous, next) {
+    const { added, removed } = diff(previous, next);
+    for (const id of added) rowRef(target, id, 1);
+    return removed.filter((id) => rowRef(target, id, -1));
+  }
+  function dropEntry(rootId, target, key) {
+    const byTarget = filings.get(rootId);
+    const byKey = byTarget?.get(target);
+    byKey?.delete(key);
+    if (byKey?.size === 0) byTarget?.delete(target);
+    if (byTarget?.size === 0) filings.delete(rootId);
+  }
+  function setFiled(rootId, target, key, rowIds, filterValues) {
+    const rows = new Set(rowIds);
+    const next = { rows, filters: new Set(filterValues ?? rows) };
+    const byKey = filedUnder(rootId, target);
+    const before = byKey.get(key);
+    const previous = before ?? { rows: /* @__PURE__ */ new Set(), filters: /* @__PURE__ */ new Set() };
+    byKey.set(key, next);
+    const released = swapRowRefs(target, previous.rows, next.rows);
+    if (swapFilterRefs(target, fieldFor(key), previous.filters, next.filters)) {
+      held.get(target)?.setFilters(filtersFor(target));
+    }
+    return {
+      // Another root may file one of these rows again before the
+      // commit, so it releases only the rows still at zero then.
+      commit: () => {
+        const counts = rowRefs.get(target);
+        const unreferenced = released.filter((id) => !counts?.has(id));
+        if (unreferenced.length > 0) target.releaseFiled(unreferenced, holder);
+      },
+      // Only while this change is still the current filing: a later
+      // change owns the state after it.
+      undo: () => {
+        if (byKey.get(key) !== next) return;
+        setFiled(rootId, target, key, previous.rows, previous.filters).commit();
+        if (!before) dropEntry(rootId, target, key);
+      }
+    };
+  }
+  function forgetParentRow(rootId) {
+    const byTarget = filings.get(rootId);
+    if (!byTarget) return;
+    for (const [target, byKey] of byTarget) {
+      for (const key of [...byKey.keys()]) setFiled(rootId, target, key, [], []).commit();
+    }
+    filings.delete(rootId);
+  }
+  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(holder);
+      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 {
+    setFiled,
+    forgetParentRow,
+    sync,
+    releaseAll: () => sync(/* @__PURE__ */ new Set()),
+    clearFiled: () => {
+      filings.clear();
+      rowRefs.clear();
+      filterRefs.clear();
+    },
+    count: () => held.size
+  };
+}
+
+// src/ledger.ts
+var ACCEPTED = { holder: "accepted" };
+var EAGER = { holder: "eager" };
+function createLedger() {
+  const entries2 = /* @__PURE__ */ new Map();
+  const byHolder = /* @__PURE__ */ new Map();
+  let journal;
+  function link(id, entry, holder) {
+    if (entry.holders.has(holder)) return;
+    entry.holders.add(holder);
+    let ids = byHolder.get(holder);
+    if (!ids) {
+      ids = /* @__PURE__ */ new Set();
+      byHolder.set(holder, ids);
+    }
+    ids.add(id);
+    journal?.push(() => unlink(id, entry, holder));
+  }
+  function unlink(id, entry, holder) {
+    if (!entry.holders.delete(holder)) return;
+    const ids = byHolder.get(holder);
+    ids?.delete(id);
+    if (ids?.size === 0) byHolder.delete(holder);
+    journal?.push(() => link(id, entry, holder));
+  }
+  function put(id, entry) {
+    entries2.set(id, entry);
+    journal?.push(() => {
+      entries2.delete(id);
+    });
+  }
+  function remove(id, entry) {
+    entries2.delete(id);
+    journal?.push(() => {
+      entries2.set(id, entry);
+    });
+  }
+  function setRow(entry, row) {
+    const previous = entry.row;
+    entry.row = row;
+    journal?.push(() => {
+      entry.row = previous;
+    });
+  }
+  function isOlder(incoming, current) {
+    const next = updatedAtOf(incoming);
+    const now = updatedAtOf(current);
+    return next !== void 0 && now !== void 0 && next < now;
+  }
+  function update(entry, incoming, writes) {
+    if (entry.row === incoming || isOlder(incoming, entry.row)) return;
+    setRow(entry, { ...entry.row, ...incoming });
+    writes.updated.push(entry.row);
+  }
+  function retain(holder, rows) {
+    const writes = { inserted: [], updated: [] };
+    for (const incoming of rows) {
+      const id = idOf(incoming);
+      if (id === void 0) continue;
+      const entry = entries2.get(id);
+      if (!entry) {
+        const created = { row: { ...incoming }, holders: /* @__PURE__ */ new Set() };
+        put(id, created);
+        link(id, created, holder);
+        writes.inserted.push(created.row);
+        continue;
+      }
+      link(id, entry, holder);
+      update(entry, incoming, writes);
+    }
+    return writes;
+  }
+  function refresh(rows) {
+    const writes = { inserted: [], updated: [] };
+    for (const incoming of rows) {
+      const id = idOf(incoming);
+      const entry = id === void 0 ? void 0 : entries2.get(id);
+      if (entry) update(entry, incoming, writes);
+    }
+    return writes;
+  }
+  function release(holder, ids) {
+    const held = byHolder.get(holder);
+    if (!held) return [];
+    const removed = [];
+    for (const id of ids ? [...ids] : [...held]) {
+      const entry = entries2.get(id);
+      if (!entry || !held.has(id)) continue;
+      unlink(id, entry, holder);
+      if (entry.holders.size === 0) {
+        remove(id, entry);
+        removed.push(id);
+      }
+    }
+    return removed;
+  }
+  return {
+    row: (id) => entries2.get(id)?.row,
+    has: (id) => entries2.has(id),
+    rows: function* rows() {
+      for (const entry of entries2.values()) yield entry.row;
+    },
+    size: () => entries2.size,
+    idsOf: (holder) => [...byHolder.get(holder) ?? []],
+    holderCount: (id) => entries2.get(id)?.holders.size ?? 0,
+    retain,
+    refresh,
+    release,
+    replace(holder, rows) {
+      const keep = new Set(idsOf(rows));
+      const stale = [...byHolder.get(holder) ?? []].filter((id) => !keep.has(id));
+      const writes = retain(holder, rows);
+      return { ...writes, removed: release(holder, stale) };
+    },
+    hold(holder, ids) {
+      for (const id of ids) {
+        const entry = entries2.get(id);
+        if (entry) link(id, entry, holder);
+      }
+    },
+    releaseAll(id) {
+      const entry = entries2.get(id);
+      if (!entry) return false;
+      for (const holder of [...entry.holders]) unlink(id, entry, holder);
+      remove(id, entry);
+      return true;
+    },
+    holders: () => [...byHolder.keys()],
+    track() {
+      const undo = [];
+      journal = undo;
+      const stop = () => {
+        if (journal === undo) journal = void 0;
+      };
+      return {
+        commit() {
+          stop();
+          undo.length = 0;
+        },
+        rollback() {
+          stop();
+          for (const step of undo.reverse()) step();
+          undo.length = 0;
+        }
+      };
+    },
+    clear() {
+      entries2.clear();
+      byHolder.clear();
+    }
+  };
+}
+
+// src/loaded-subsets.ts
+function createLoadedSubsets() {
+  const marks = /* @__PURE__ */ new Map();
+  function forgetValue(marked, value) {
+    if (typeof value === "string") marked.delete(value);
+    else if (Array.isArray(value)) {
+      for (const item of value) if (typeof item === "string") marked.delete(item);
+    }
+  }
+  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));
+    },
+    forgetRow(row) {
+      if (!row || typeof row !== "object") return;
+      for (const [field, marked] of marks) {
+        forgetValue(marked, row[field]);
+      }
+    },
+    clear() {
+      marks.clear();
+    }
+  };
+}
+
+// src/membership.ts
+var NO_WRITES = { inserted: [], updated: [] };
+function createMembership(deps) {
+  const { ledger, store } = deps;
+  function writesFor(rows, changes, removed) {
+    const inserted = new Set(changes.inserted.map(idOf));
+    const updated = new Set(changes.updated.map(idOf));
+    const seen = /* @__PURE__ */ new Set();
+    const writes = [];
+    for (const row of rows) {
+      const id = idOf(row);
+      if (id === void 0 || seen.has(id) || !(inserted.has(id) || updated.has(id))) continue;
+      const stored = ledger.row(id);
+      if (stored === void 0) continue;
+      seen.add(id);
+      writes.push({ type: inserted.has(id) ? "insert" : "update", value: stored });
+    }
+    for (const key of removed) writes.push({ type: "delete", key });
+    return writes;
+  }
+  function rowsBefore(ids) {
+    const rows = /* @__PURE__ */ new Map();
+    for (const id of ids) {
+      const row = ledger.row(id);
+      if (row) rows.set(id, row);
+    }
+    return rows;
+  }
+  function pick(rows, ids) {
+    return ids.map((id) => rows.get(id)).filter((row) => row !== void 0);
+  }
+  function releaseKept(keeper, holders, ids) {
+    const kept = new Set(ledger.idsOf(keeper));
+    const covered = [...ids].filter((id) => kept.has(id));
+    for (const holder of holders) {
+      const removed = ledger.release(holder, covered);
+      if (removed.length > 0) {
+        throw new Error(
+          `${deps.collectionName}: releasing a kept row removed ${removed.join(", ")}`
+        );
+      }
+    }
+  }
+  function apply(change) {
+    if (!store.isAttached()) return false;
+    const tracked = ledger.track();
+    let receipt;
+    let gone;
+    try {
+      const result = change();
+      gone = result.gone;
+      receipt = store.transact(result.writes);
+    } catch (error) {
+      tracked.rollback();
+      throw error;
+    }
+    tracked.commit();
+    if (gone.length > 0) deps.onRemoved(gone);
+    return receipt;
+  }
+  return {
+    land: (holder, rows) => apply(() => ({ writes: writesFor(rows, ledger.retain(holder, rows), []), gone: [] })),
+    accept: (rows) => apply(() => {
+      const held = new Set(idsOf(rows).filter((id) => ledger.has(id)));
+      const fresh = rows.filter((row) => !held.has(idOf(row) ?? ""));
+      const stale = rows.filter((row) => held.has(idOf(row) ?? ""));
+      const retained = ledger.retain(ACCEPTED, fresh);
+      const refreshed = ledger.refresh(stale);
+      const changes = {
+        inserted: [...retained.inserted, ...refreshed.inserted],
+        updated: [...retained.updated, ...refreshed.updated]
+      };
+      return { writes: writesFor(rows, changes, []), gone: [] };
+    }),
+    reconcile: (holder, rows, releaseAlso = []) => apply(() => {
+      const before = rowsBefore(ledger.idsOf(holder));
+      const { removed, ...changes } = ledger.replace(holder, rows);
+      releaseKept(holder, releaseAlso, idsOf(rows));
+      return { writes: writesFor(rows, changes, removed), gone: pick(before, removed) };
+    }),
+    confirm: (keeper, holders, ids) => apply(() => {
+      releaseKept(keeper, holders, ids);
+      return { writes: [], gone: [] };
+    }),
+    drop: (holders, ids) => apply(() => {
+      const listed = ids ? [...ids] : void 0;
+      const removed = [];
+      const gone = [];
+      for (const holder of holders) {
+        const held = listed ?? ledger.idsOf(holder);
+        const before = rowsBefore(held);
+        const released = ledger.release(holder, held);
+        removed.push(...released);
+        gone.push(...pick(before, released));
+      }
+      return { writes: writesFor([], NO_WRITES, removed), gone };
+    }),
+    hold: (holders, ids) => apply(() => {
+      const listed = [...ids];
+      for (const holder of holders) ledger.hold(holder, listed);
+      return { writes: [], gone: [] };
+    }),
+    dropAll: (ids) => apply(() => {
+      const present = [...new Set(ids)].filter((id) => ledger.has(id));
+      const gone = pick(rowsBefore(present), present);
+      for (const id of present) ledger.releaseAll(id);
+      return { writes: writesFor([], NO_WRITES, present), gone };
+    })
+  };
+}
+
+// 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 { 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 delivered = /* @__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 deps.transport.subscribe(
+        collectionName,
+        deps.subscribeOptions(),
+        (event) => deps.handleEvent(event, "*", expand)
+      );
+      delivered.add("*");
+      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;
+    const options = filteredOptions(filter);
+    const expand = deps.pendingExpand();
+    try {
+      const unsubscribe = await deps.transport.subscribe(
+        collectionName,
+        options,
+        (event) => deps.handleEvent(event, filter, expand)
+      );
+      delivered.add(filter);
+      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
+      });
+    }
+  }
+  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) {
+    await Promise.all([...filterEntries.keys()].filter((f) => !keep(f)).map(closeFilter));
+  }
+  function releaseClosedTopics() {
+    const wanted = wantedFilters();
+    for (const topic of delivered) {
+      const live = topic === "*" ? isStarOpen() || wantsStar() : filterEntries.has(topic) || wanted.has(topic);
+      if (live) continue;
+      delivered.delete(topic);
+      deps.onEntryClosed(topic);
+    }
+  }
+  async function openWantedFilters() {
+    if (wantsStar()) return;
+    const wanted = [...wantedFilters()];
+    for (const filter of wanted) {
+      if (filterEntries.has(filter) || oversizedFilters.has(filter)) continue;
+      const topicLength = realtimeTopicLength(collectionName, filteredOptions(filter));
+      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
+        });
+      }
+    }
+    if (wantsStar()) return;
+    await Promise.all(wanted.map(openFilter));
+  }
+  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));
+    }
+    releaseClosedTopics();
+    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/realtime-where.ts
+function subscriptionWhere(opts) {
+  const sub = opts.subscription;
+  if (!sub?.options || !("whereExpression" in sub.options)) return { known: false };
+  return { known: true, where: sub.options.whereExpression };
+}
+function chunkExtra(where, subWhere) {
+  if (where === subWhere) return void 0;
+  if (subWhere === void 0) return where;
+  const node = where;
+  if (node?.type === "func" && node.name === "and" && node.args?.length === 2 && node.args[0] === subWhere) {
+    return node.args[1];
+  }
+  return null;
+}
+function realtimeWhereFor(opts) {
+  if (!opts.subscription) return opts.where;
+  const sub = subscriptionWhere(opts);
+  if (!sub.known) return opts.where;
+  const extra = chunkExtra(opts.where, sub.where);
+  if (extra === null) return opts.where;
+  if (extra === void 0) return sub.where;
+  const node = extra;
+  return node?.type === "func" && node.name === "in" ? opts.where : sub.where;
+}
+
+// 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 ?? []);
+  const cursor = convertToPocketBaseFilter(opts?.cursor?.whereFrom);
+  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;
+  if (cursor) request.cursor = cursor;
+  else if (opts?.offset) request.offset = opts.offset;
+  return request;
+}
+function realtimeFiltersFor(request) {
+  if (request.subset) return subsetFilters(request.subset, REALTIME_MAX_FILTER_LENGTH);
+  return request.filter ? [request.filter] : void 0;
+}
+
+// src/sync-adapter.ts
+function createSyncAdapter(deps) {
+  const { collectionName, syncMode, ledger, store, membership: membership2, fetcher, subsets, realtime } = deps;
+  const { subsetGcTime, loadRetryDelays } = deps;
+  let current;
+  const tombstones = /* @__PURE__ */ new Map();
+  function demandFor(opts) {
+    const request = toRequest(deps.registry().withViewExpand(opts));
+    const mode = deps.registry().tagFor(opts)?.realtime ?? deps.realtimeMode;
+    const base = {
+      request,
+      seq: 0,
+      loading: void 0,
+      parked: void 0,
+      landed: false,
+      wake: void 0
+    };
+    if (mode !== "query") return { ...base, filters: void 0, counted: false };
+    const filters = realtimeFiltersFor(toRequest({ where: realtimeWhereFor(opts) }));
+    return { ...base, filters, counted: true };
+  }
+  function keyOf(demand) {
+    return JSON.stringify(
+      [demand.request, demand.filters],
+      (_key, value) => value && typeof value === "object" && !Array.isArray(value) ? Object.fromEntries(Object.entries(value).sort(([a], [b]) => a.localeCompare(b))) : value
+    );
+  }
+  async function settle(applied, wait) {
+    if (applied === true || applied === false) return;
+    const receipt = wait === "accepted" ? whenSyncAccepted(applied) : applied;
+    if (receipt !== true) await receipt;
+  }
+  async function fetchRows(run, request, signal, refetch, filters) {
+    const deleted = /* @__PURE__ */ new Set();
+    tombstones.set(deleted, filters);
+    try {
+      const { rows, fromStore, filings } = await fetcher.fetchRecords(request, {
+        signals: signal ? [run.abort.signal, signal] : [run.abort.signal],
+        refetch
+      });
+      return {
+        rows: rows.filter((row) => !deleted.has(idOf(row) ?? "")),
+        fromStore,
+        filings
+      };
+    } finally {
+      tombstones.delete(deleted);
+    }
+  }
+  function isStopped(run, opts) {
+    return run.abort.signal.aborted || opts.signal?.aborted === true;
+  }
+  function stopped(run, opts, wait) {
+    if (!isStopped(run, opts)) return false;
+    if (wait === "visible") throw new LoadSubsetOperationAbortedError();
+    return true;
+  }
+  function matcherFor(where, unknown) {
+    if (where === void 0) return () => true;
+    let evaluate;
+    try {
+      evaluate = compileSingleRowExpression(where);
+    } catch {
+      return () => unknown;
+    }
+    return (row) => {
+      try {
+        return toBooleanPredicate(evaluate(row));
+      } catch {
+        return unknown;
+      }
+    };
+  }
+  function uncoveredRows(demand) {
+    const holders = [ACCEPTED, ...demand.filters ?? []];
+    const rows = /* @__PURE__ */ new Map();
+    for (const holder of holders) {
+      for (const id of ledger.idsOf(holder)) {
+        const stored = ledger.row(id);
+        if (stored) rows.set(id, stored);
+      }
+    }
+    return { holders, rows };
+  }
+  function releaseOmitted(opts, before, ids) {
+    if (opts.limit !== void 0 || opts.cursor || opts.offset !== void 0) return true;
+    const returned = new Set(ids);
+    const matches = matcherFor(opts.where, false);
+    const omitted = [...before.rows].filter(([id, stored]) => !returned.has(id) && ledger.row(id) === stored).filter(([, stored]) => matches(stored)).map(([id]) => id);
+    return omitted.length > 0 ? membership2.drop(before.holders, omitted) : true;
+  }
+  async function install(run, opts, wait, before, result) {
+    const applied = membership2.reconcile(opts, result.rows);
+    if (applied === false) {
+      result.filings.undo();
+      return [];
+    }
+    result.filings.commit();
+    const demand = run.demands.get(opts);
+    if (demand) demand.landed = true;
+    const ids = idsOf(result.rows);
+    const released = result.fromStore ? true : releaseOmitted(opts, before, ids);
+    await settle(applied, wait);
+    await settle(released, wait);
+    if (!stopped(run, opts, wait)) membership2.confirm(opts, [ACCEPTED], ids);
+    return ids;
+  }
+  function superseded(run, opts, demand, seq) {
+    return isStopped(run, opts) || run.demands.get(opts) !== demand || demand.seq !== seq;
+  }
+  function statusOf(error) {
+    const status = error?.status;
+    return typeof status === "number" ? status : void 0;
+  }
+  function isRetryable(error) {
+    const status = statusOf(error);
+    if (status === void 0 || status < 400 || status >= 500) return true;
+    return status === 401 || status === 408 || status === 429;
+  }
+  function retryDelay(attempt, error) {
+    if (statusOf(error) === 401) return void 0;
+    const base = loadRetryDelays[Math.min(attempt, loadRetryDelays.length - 1)];
+    return base === void 0 ? void 0 : Math.round(base * (0.75 + Math.random() * 0.5));
+  }
+  function sleep(ms, onWake) {
+    return new Promise((resolve) => {
+      const timer = ms === void 0 ? void 0 : setTimeout(resolve, ms);
+      onWake(() => {
+        if (timer !== void 0) clearTimeout(timer);
+        resolve();
+      });
+    });
+  }
+  function wakeRetries(run) {
+    run.eagerWake?.();
+    for (const demand of run.demands.values()) demand.wake?.();
+  }
+  async function retryAllowed(run, opts, demand, seq, attempt, error) {
+    if (superseded(run, opts, demand, seq)) return false;
+    if (loadRetryDelays.length === 0 || !isRetryable(error)) throw error;
+    const delay = retryDelay(attempt, error);
+    logger.warn("Subset load failed; retrying", { collectionName, attempt, delay, error });
+    await sleep(delay, (wake) => {
+      demand.wake = wake;
+    });
+    demand.wake = void 0;
+    return !superseded(run, opts, demand, seq);
+  }
+  async function fetchWithRetry(run, opts, demand, seq, refetch) {
+    for (let attempt = 0; ; attempt++) {
+      try {
+        return await fetchRows(run, demand.request, opts.signal, refetch, demand.filters);
+      } catch (error) {
+        if (!await retryAllowed(run, opts, demand, seq, attempt, error)) return void 0;
+      }
+    }
+  }
+  function load(run, opts, demand, wait, refetch) {
+    demand.wake?.();
+    const seq = ++demand.seq;
+    const before = uncoveredRows(demand);
+    const loading = (async () => {
+      const result = await fetchWithRetry(run, opts, demand, seq, refetch);
+      if (result !== void 0 && !superseded(run, opts, demand, seq)) {
+        return install(run, opts, wait, before, result);
+      }
+      result?.filings.undo();
+      if (demand.seq !== seq) return demand.loading ?? [];
+      stopped(run, opts, wait);
+      return [];
+    })();
+    demand.loading = loading;
+    return loading;
+  }
+  function expire(run, opts) {
+    const demand = run.demands.get(opts);
+    if (!demand) return;
+    if (demand.parked !== void 0) clearTimeout(demand.parked);
+    demand.wake?.();
+    run.demands.delete(opts);
+    if (demand.counted) realtime.releaseQueryFilters(demand.filters);
+    membership2.drop([opts]);
+  }
+  function unloadSubset(run, opts) {
+    try {
+      const demand = run.demands.get(opts);
+      if (!demand) return;
+      if (subsetGcTime <= 0 || demand.parked !== void 0 || !demand.landed) {
+        expire(run, opts);
+        return;
+      }
+      demand.parked = setTimeout(() => {
+        if (current === run) expire(run, opts);
+      }, subsetGcTime);
+    } catch (error) {
+      logger.error("unloadSubset failed", { collectionName, error });
+    }
+  }
+  function expireParked(run) {
+    for (const [opts, demand] of [...run.demands]) {
+      if (demand.parked !== void 0) expire(run, opts);
+    }
+  }
+  function unpark(run, demand) {
+    const key = keyOf(demand);
+    for (const [opts, parked] of run.demands) {
+      if (parked.parked === void 0 || keyOf(parked) !== key) continue;
+      clearTimeout(parked.parked);
+      run.demands.delete(opts);
+      return opts;
+    }
+    return void 0;
+  }
+  function serve(opts, demand) {
+    if (opts.refetch) return false;
+    const served = fetcher.serveFromStore(demand.request);
+    if (!served) return false;
+    demand.seq += 1;
+    demand.loading = void 0;
+    demand.landed = true;
+    return membership2.reconcile(opts, served, [ACCEPTED]);
+  }
+  function adopt(opts, parkedOpts) {
+    const rows = [];
+    for (const id of ledger.idsOf(parkedOpts)) {
+      const row = ledger.row(id);
+      if (row) rows.push(row);
+    }
+    return membership2.reconcile(opts, rows, [ACCEPTED, parkedOpts]);
+  }
+  function startFromHeld(opts, demand, parkedOpts) {
+    if (parkedOpts === void 0) return serve(opts, demand);
+    const adopted = adopt(opts, parkedOpts);
+    demand.landed = true;
+    return opts.refetch === true ? false : adopted;
+  }
+  function refetchAdopted(run, opts, demand) {
+    void load(run, opts, demand, "accepted", true).catch(
+      (error) => logger.error("Refetch after adopting a parked subset failed", { collectionName, error })
+    );
+  }
+  function startHeld(run, opts, demand, parkedOpts) {
+    try {
+      const applied = startFromHeld(opts, demand, parkedOpts);
+      if (applied !== false && parkedOpts !== void 0 && reloading) {
+        refetchAdopted(run, opts, demand);
+      }
+      return applied;
+    } catch (error) {
+      expire(run, opts);
+      throw error;
+    }
+  }
+  function loadSubsetIn(run) {
+    return (opts) => {
+      if (run.demands.has(opts)) expire(run, opts);
+      const demand = demandFor(opts);
+      const parkedOpts = unpark(run, demand);
+      run.demands.set(opts, demand);
+      if (parkedOpts === void 0 && demand.counted) {
+        realtime.retainQueryFilters(demand.filters);
+      }
+      const applied = startHeld(run, opts, demand, parkedOpts);
+      if (applied !== false) return applied;
+      return load(run, opts, demand, "visible", opts.refetch === true).then(() => void 0);
+    };
+  }
+  async function fetchEagerWithRetry(run, seq) {
+    for (let attempt = 0; ; attempt++) {
+      try {
+        return await fetchRows(run, {}, void 0, false, void 0);
+      } catch (error) {
+        const stale = () => run.abort.signal.aborted || run.eagerSeq !== seq;
+        if (loadRetryDelays.length === 0 || !isRetryable(error) || stale()) throw error;
+        const delay = retryDelay(attempt, error);
+        logger.warn("Eager load failed; retrying", {
+          collectionName,
+          attempt,
+          delay,
+          error
+        });
+        await sleep(delay, (wake) => {
+          run.eagerWake = wake;
+        });
+        run.eagerWake = void 0;
+        if (stale()) throw error;
+      }
+    }
+  }
+  function loadEagerRows(run) {
+    run.eagerWake?.();
+    const seq = ++run.eagerSeq;
+    const loading = (async () => {
+      const { rows, filings } = await fetchEagerWithRetry(run, seq);
+      if (run.abort.signal.aborted || run.eagerSeq !== seq) {
+        filings.undo();
+        return run.eagerSeq !== seq ? run.eagerLoad ?? [] : [];
+      }
+      const applied = membership2.reconcile(EAGER, rows, [ACCEPTED]);
+      if (applied === false) {
+        filings.undo();
+        return [];
+      }
+      filings.commit();
+      await settle(applied, "accepted");
+      return idsOf(rows);
+    })();
+    run.eagerLoad = loading;
+    return loading;
+  }
+  async function startEager(run, markReady, markError) {
+    try {
+      await loadEagerRows(run);
+    } catch (error) {
+      if (run.abort.signal.aborted) return;
+      logger.error("Initial load failed", { collectionName, error });
+      markError(error);
+      return;
+    }
+    if (!run.abort.signal.aborted) markReady();
+  }
+  function releasable() {
+    return ledger.holders().filter((holder) => holder === ACCEPTED || typeof holder === "string").map((holder) => [holder, ledger.idsOf(holder)]);
+  }
+  async function reloadRows(run) {
+    const loaded = syncMode === "eager" ? [await loadEagerRows(run)] : await Promise.all(
+      [...run.demands].map(
+        ([opts, demand]) => load(run, opts, demand, "accepted", true)
+      )
+    );
+    return new Set(loaded.flat());
+  }
+  async function releaseUnconfirmed(run, before, confirmed) {
+    for (const [holder, ids] of before) {
+      if (run.abort.signal.aborted) return;
+      const unconfirmed = ids.filter((id) => !confirmed.has(id));
+      if (unconfirmed.length > 0) {
+        await settle(membership2.drop([holder], unconfirmed), "accepted");
+      }
+    }
+  }
+  async function reloadNow() {
+    const run = current;
+    if (!run || !store.isAttached()) return;
+    expireParked(run);
+    const before = releasable();
+    let confirmed;
+    try {
+      confirmed = await reloadRows(run);
+    } catch (error) {
+      if (run.abort.signal.aborted) return;
+      throw error;
+    }
+    await releaseUnconfirmed(run, before, confirmed);
+  }
+  let reloading;
+  let queued;
+  function reload() {
+    if (current) wakeRetries(current);
+    if (!reloading) {
+      reloading = reloadNow().finally(() => {
+        reloading = void 0;
+      });
+      return reloading;
+    }
+    queued ?? (queued = reloading.catch(() => void 0).then(() => {
+      queued = void 0;
+      return reload();
+    }));
+    return queued;
+  }
+  return {
+    sync: (params) => {
+      const channel = params;
+      const run = {
+        abort: new AbortController(),
+        demands: /* @__PURE__ */ new Map(),
+        eagerSeq: 0,
+        eagerLoad: void 0,
+        eagerWake: void 0
+      };
+      current = run;
+      store.attach(channel);
+      const cleanup = () => {
+        run.abort.abort();
+        run.eagerWake?.();
+        for (const demand of run.demands.values()) {
+          if (demand.parked !== void 0) clearTimeout(demand.parked);
+          demand.wake?.();
+        }
+        run.demands.clear();
+        if (current === run) current = void 0;
+        store.detach(channel);
+        ledger.clear();
+        subsets.clear();
+        if (syncMode === "on-demand") realtime.resetQueryFilters();
+        deps.onCleanup();
+      };
+      if (syncMode === "eager") {
+        void startEager(run, params.markReady, params.markError);
+        return { cleanup };
+      }
+      params.markReady();
+      return {
+        loadSubset: loadSubsetIn(run),
+        unloadSubset: (opts) => unloadSubset(run, opts),
+        cleanup
+      };
+    },
+    reload,
+    subsetsFor: (filter) => [...current?.demands ?? []].filter(([, demand]) => demand.filters?.includes(filter)).map(([opts]) => opts),
+    noteDeleted: (id, topic) => {
+      for (const [deleted, filters] of tombstones) {
+        if (topic === "*" || filters?.includes(topic)) deleted.add(id);
+      }
+    },
+    isDeleted: (id) => [...tombstones.keys()].some((deleted) => deleted.has(id)),
+    expireParked: () => {
+      if (current) expireParked(current);
+    },
+    wakeRetries: () => {
+      if (current) wakeRetries(current);
+    },
+    holdersFor: (row) => {
+      if (!current) return [];
+      if (syncMode === "eager") return [EAGER];
+      return [...current.demands].filter(
+        ([opts, demand]) => demand.parked === void 0 && demand.landed && matcherFor(opts.where, true)(row)
+      ).map(([opts]) => opts);
+    }
+  };
+}
+
+// src/synced-store.ts
+function createSyncedStore(collectionName) {
+  let session;
+  return {
+    attach(channel) {
+      session = channel;
+    },
+    detach(channel) {
+      if (session === channel) session = void 0;
+    },
+    isAttached: () => session !== void 0,
+    transact(writes) {
+      const channel = session;
+      if (!channel) return false;
+      if (writes.length === 0) return true;
+      channel.begin();
+      try {
+        for (const write of writes) channel.write(write);
+      } catch (error) {
+        try {
+          const cancel = new AbortController();
+          cancel.abort();
+          channel.commit(cancel.signal);
+        } catch {
+        }
+        throw new Error(`${collectionName}: sync write failed`, { cause: error });
+      }
+      return channel.commit();
+    }
+  };
+}
+
+// src/realtime-client.ts
+var RealtimeTopicTooLongError = class extends Error {
+  constructor(length) {
+    super(
+      `Realtime topic is ${length} characters; the server accepts ${REALTIME_TOPIC_MAX_LENGTH}`
+    );
+    this.name = "RealtimeTopicTooLongError";
+  }
+};
+var RealtimeDisconnectedError = class extends Error {
+  constructor() {
+    super("Realtime client was disconnected before this subscription was confirmed");
+    this.name = "RealtimeDisconnectedError";
+  }
+};
+var REALTIME_BACKOFF_MS = [200, 300, 500, 1e3, 1200, 1500, 2e3];
+function createRealtimeClient(deps) {
+  const backoff = deps.backoff ?? REALTIME_BACKOFF_MS;
+  const openSource = deps.eventSource ?? ((url) => new EventSource(url));
+  const listeners = /* @__PURE__ */ new Map();
+  const dispatchers = /* @__PURE__ */ new Map();
+  let source;
+  let connected = false;
+  let clientId;
+  let lastSeq;
+  let confirmed = [];
+  let waiters = [];
+  let submitQueued = false;
+  let submitting = false;
+  let resubmit = false;
+  let attempts = 0;
+  let reconnectTimer;
+  let everConnected = false;
+  let session = 0;
+  let disabled = false;
+  function topics() {
+    return [...listeners.keys()];
+  }
+  function dispatcherFor(topic) {
+    let dispatch = dispatchers.get(topic);
+    if (!dispatch) {
+      dispatch = (ev) => {
+        const message = ev;
+        let event;
+        try {
+          event = JSON.parse(String(message.data));
+        } catch {
+          return;
+        }
+        if (typeof event.seq === "number") lastSeq = event.seq;
+        for (const listener of listeners.get(topic) ?? []) listener(event);
+      };
+      dispatchers.set(topic, dispatch);
+    }
+    return dispatch;
+  }
+  function sameList(a, b) {
+    return a.length === b.length && a.every((topic) => b.includes(topic));
+  }
+  function settleWaiters(pending, error) {
+    for (const waiter of pending) error === void 0 ? waiter.resolve() : waiter.reject(error);
+  }
+  async function sendTopics() {
+    const list = topics();
+    if (list.length === 0) {
+      close(true);
+      clientId = void 0;
+      lastSeq = void 0;
+      return;
+    }
+    if (sameList(list, confirmed)) return;
+    const id = clientId;
+    if (!id) return;
+    await deps.send({ clientId: id, subscriptions: list });
+    if (clientId === id) confirmed = list;
+  }
+  function requeueStale(pending) {
+    if (disabled) {
+      settleWaiters(pending);
+      return;
+    }
+    waiters = [...pending, ...waiters];
+    resubmit = true;
+  }
+  function settleWhileDisconnected() {
+    if (listeners.size > 0) return;
+    const pending = waiters;
+    waiters = [];
+    close(true);
+    clientId = void 0;
+    lastSeq = void 0;
+    settleWaiters(pending);
+  }
+  async function postTopics(pending, startedSession) {
+    try {
+      await sendTopics();
+      if (session !== startedSession) requeueStale(pending);
+      else settleWaiters(pending);
+    } catch (error) {
+      if (session !== startedSession) {
+        requeueStale(pending);
+      } else {
+        logger.error("Failed to set realtime subscriptions", { error });
+        settleWaiters(pending, error);
+      }
+    }
+  }
+  async function runSubmit() {
+    if (submitting) {
+      resubmit = true;
+      return;
+    }
+    if (!connected || !clientId) {
+      settleWhileDisconnected();
+      return;
+    }
+    submitting = true;
+    const pending = waiters;
+    waiters = [];
+    try {
+      await postTopics(pending, session);
+    } finally {
+      submitting = false;
+      if (resubmit) {
+        resubmit = false;
+        void runSubmit();
+      }
+    }
+  }
+  function submit() {
+    const done = new Promise((resolve, reject) => {
+      waiters.push({ resolve, reject });
+    });
+    if (!submitQueued) {
+      submitQueued = true;
+      queueMicrotask(() => {
+        submitQueued = false;
+        void runSubmit();
+      });
+    }
+    return done;
+  }
+  function attachAll(target) {
+    for (const topic of listeners.keys()) target.addEventListener(topic, dispatcherFor(topic));
+  }
+  function connectUrl() {
+    if (!clientId) return deps.url;
+    const params = new URLSearchParams({ resume: clientId });
+    if (lastSeq !== void 0) params.set("after", String(lastSeq));
+    return `${deps.url}${deps.url.includes("?") ? "&" : "?"}${params}`;
+  }
+  function close(forget) {
+    if (reconnectTimer !== void 0) clearTimeout(reconnectTimer);
+    reconnectTimer = void 0;
+    source?.close();
+    source = void 0;
+    connected = false;
+    if (forget) {
+      confirmed = [];
+      everConnected = false;
+      session += 1;
+    }
+  }
+  function forgetSession() {
+    if (reconnectTimer !== void 0) clearTimeout(reconnectTimer);
+    reconnectTimer = void 0;
+    source?.close();
+    source = void 0;
+    connected = false;
+    confirmed = [];
+    clientId = void 0;
+    lastSeq = void 0;
+    attempts = 0;
+    session += 1;
+    if (listeners.size > 0) {
+      try {
+        connect();
+      } catch (error) {
+        logger.error("Failed to reconnect after reset", { error });
+      }
+    }
+  }
+  function scheduleReconnect() {
+    const delay = backoff[Math.min(attempts, backoff.length - 1)] ?? 0;
+    attempts += 1;
+    reconnectTimer = setTimeout(() => {
+      reconnectTimer = void 0;
+      if (listeners.size > 0) connect();
+    }, delay);
+  }
+  function handleConnectionLost(target) {
+    if (source !== target) return;
+    logger.debug("Realtime connection lost", { clientId });
+    close(false);
+    scheduleReconnect();
+  }
+  function connect() {
+    if (source || disabled) return;
+    const previousId = clientId;
+    const target = openSource(connectUrl());
+    source = target;
+    target.addEventListener("error", () => handleConnectionLost(target));
+    target.addEventListener("PB_CONNECT", (ev) => {
+      if (source !== target) return;
+      const message = ev;
+      let data = {};
+      try {
+        data = JSON.parse(String(message.data));
+      } catch {
+        data = {};
+      }
+      const id = message.lastEventId || data.clientId;
+      if (!id) return;
+      const resumed = data.resumed === true && id === previousId;
+      clientId = id;
+      connected = true;
+      if (!resumed) {
+        lastSeq = void 0;
+        confirmed = [];
+      }
+      attachAll(target);
+      const isReconnect = everConnected;
+      everConnected = true;
+      submit().then(
+        () => {
+          if (source !== target) return;
+          attempts = 0;
+          if (isReconnect) deps.onReconnect?.(resumed);
+        },
+        () => {
+          if (source !== target || !isReconnect) return;
+          close(false);
+          scheduleReconnect();
+        }
+      );
+    });
+  }
+  return {
+    subscribe(topic, listener) {
+      if (topic.length > REALTIME_TOPIC_MAX_LENGTH) {
+        return Promise.reject(new RealtimeTopicTooLongError(topic.length));
+      }
+      if (!source) {
+        try {
+          connect();
+        } catch (error) {
+          return Promise.reject(error);
+        }
+      }
+      let set = listeners.get(topic);
+      const isNew = set === void 0;
+      if (!set) {
+        set = /* @__PURE__ */ new Set();
+        listeners.set(topic, set);
+      }
+      set.add(listener);
+      if (isNew && source && connected) source.addEventListener(topic, dispatcherFor(topic));
+      const ready = disabled ? Promise.resolve() : submit();
+      const unsubscribe = async () => {
+        const current = listeners.get(topic);
+        if (!current?.delete(listener)) return;
+        if (current.size > 0) return;
+        listeners.delete(topic);
+        const dispatch = dispatchers.get(topic);
+        if (dispatch) {
+          source?.removeEventListener(topic, dispatch);
+          dispatchers.delete(topic);
+        }
+        await submit().catch(() => void 0);
+      };
+      return ready.then(
+        () => unsubscribe,
+        (error) => {
+          const current = listeners.get(topic);
+          if (current?.delete(listener) && current.size === 0) {
+            listeners.delete(topic);
+            const dispatch = dispatchers.get(topic);
+            if (dispatch) {
+              source?.removeEventListener(topic, dispatch);
+              dispatchers.delete(topic);
+            }
+          }
+          throw error;
+        }
+      );
+    },
+    topics,
+    isConnected: () => connected,
+    clientId: () => clientId,
+    disconnect() {
+      close(true);
+      clientId = void 0;
+      lastSeq = void 0;
+      const pending = waiters;
+      waiters = [];
+      listeners.clear();
+      dispatchers.clear();
+      settleWaiters(pending, new RealtimeDisconnectedError());
+    },
+    simulateDisconnect() {
+      if (source) handleConnectionLost(source);
+    },
+    reset: forgetSession,
+    // Pending subscribes settle: their topics are registered and go out
+    // with the first POST after enable(), the same as a subscribe made
+    // while disabled.
+    disable() {
+      disabled = true;
+      forgetSession();
+      const pending = waiters;
+      waiters = [];
+      settleWaiters(pending);
+    },
+    enable() {
+      if (!disabled) return;
+      disabled = false;
+      if (listeners.size > 0) connect();
+    },
+    isEnabled: () => !disabled
+  };
+}
+
+// src/transport.ts
+var entries = /* @__PURE__ */ new WeakMap();
+function watchAuth(pb, entry) {
+  let authId = pb.authStore.record?.id;
+  pb.authStore.onChange((_token, record) => {
+    if (record?.id === authId) return;
+    authId = record?.id;
+    for (const listener of entry.authListeners) listener();
+    entry.client.reset();
+  });
+}
+function entryFor(pb) {
+  let entry = entries.get(pb);
+  if (!entry) {
+    const reconnectListeners = /* @__PURE__ */ new Set();
+    const client = createRealtimeClient({
+      url: pb.buildURL("/api/realtime"),
+      send: (body) => pb.send("/api/realtime", { method: "POST", body, requestKey: null }),
+      onReconnect: (resumed) => {
+        for (const listener of reconnectListeners) listener(resumed);
+      }
+    });
+    entry = { client, reconnectListeners, authListeners: /* @__PURE__ */ new Set() };
+    watchAuth(pb, entry);
+    entries.set(pb, entry);
+  }
+  return entry;
+}
+function resetRealtime(pb) {
+  const client = entries.get(pb)?.client;
+  if (!client) return;
+  client.reset();
+  client.enable();
+}
+function disconnectRealtime(pb) {
+  entryFor(pb).client.disable();
+}
+function transportFor(pb) {
+  const entry = entryFor(pb);
+  return {
+    subscribe: (collectionName, options, handler) => entry.client.subscribe(
+      realtimeTopic(collectionName, options),
+      (event) => handler(event)
+    ),
+    onReconnect(listener) {
+      entry.reconnectListeners.add(listener);
+      return () => {
+        entry.reconnectListeners.delete(listener);
+      };
+    },
+    onAuthChange(listener) {
+      entry.authListeners.add(listener);
+      return () => {
+        entry.authListeners.delete(listener);
+      };
+    },
+    reconnectListenerCount: () => entry.reconnectListeners.size
+  };
+}
+
+// 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 buildCollection(input) {
+  const { pb, 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 refetchOnMutation = options?.refetchOnMutation ?? false;
+  const subsetGcTime = options?.subsetGcTime ?? 5e3;
+  const loadRetryDelays = options?.loadRetryDelays ?? [1e3, 2e3, 4e3, 8e3, 15e3, 3e4];
+  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.clear();
+    if (syncMode === "on-demand") membership2.drop([ACCEPTED]);
+  }
+  function releaseTopic(topic) {
+    if (syncMode === "eager") return;
+    if (membership2.drop([topic]) === false) {
+      logger.debug("Ignoring topic release while sync is not running", {
+        collectionName,
+        topic
+      });
+    }
+  }
+  const parentHolder = { parent: collectionName };
+  const ledger = createLedger();
+  const store = createSyncedStore(collectionName);
+  const subsets = createLoadedSubsets();
+  const membership2 = createMembership({
+    collectionName,
+    ledger,
+    store,
+    onRemoved: (rows) => {
+      for (const row of rows) {
+        subsets.forgetRow(row);
+        const id = idOf(row);
+        if (id !== void 0) held.forgetParentRow(id);
+      }
+    }
+  });
+  const held = createHeldTargets(collectionName, parentHolder);
+  const filer = createExpandFiler({
+    collectionName,
+    setFiled: held.setFiled,
+    holder: parentHolder,
+    isStale: (record) => {
+      const id = idOf(record);
+      if (id === void 0) return true;
+      if (adapter.isDeleted(id)) return true;
+      const incoming = updatedAtOf(record);
+      const stored = updatedAtOf(ledger.row(id));
+      return incoming !== void 0 && stored !== void 0 && incoming < stored;
+    }
+  });
+  const fetcher = createFetcher({
+    pb,
+    collectionName,
+    relationTargets,
+    activeExpand,
+    syncedRow: ledger.row,
+    syncedRows: ledger.rows,
+    subsets,
+    filer
+  });
+  const transport = transportFor(pb);
+  const realtime = createRealtimeSubscription({
+    transport,
+    collectionName,
+    handleEvent: (event, topic, expand) => handleRealtimeEvent(event, topic, expand),
+    pendingExpand: pendingSubscribeExpand,
+    subscribeOptions: realtimeSubscribeOptions,
+    onEntryOpened: () => held.sync(targetsAlong(splitPaths(pendingSubscribeExpand()), relationTargets)),
+    onEntryClosed: releaseTopic,
+    onIdle: releaseAll
+  });
+  const adapter = createSyncAdapter({
+    collectionName,
+    syncMode,
+    realtimeMode,
+    subsetGcTime,
+    loadRetryDelays,
+    ledger,
+    store,
+    membership: membership2,
+    fetcher,
+    subsets,
+    realtime,
+    registry: () => registry,
+    onCleanup: () => {
+      held.clearFiled();
+      for (const timer of acceptedTimers) clearTimeout(timer);
+      acceptedTimers.clear();
+    }
+  });
+  function resolveHandler(option, fallback) {
+    return option === false ? void 0 : option ?? fallback;
+  }
+  function landServerRows(rows) {
+    const result = membership2.accept(rows);
+    if (result === false) {
+      logger.debug("Dropping write-back while sync is not running", { collectionName });
+      return;
+    }
+    expireAccepted(rows);
+  }
+  const acceptedTimers = /* @__PURE__ */ new Set();
+  function settleAccepted(ids) {
+    for (const id of ids) {
+      const row = ledger.row(id);
+      if (!row) continue;
+      const holders = adapter.holdersFor(row);
+      if (holders.length > 0) membership2.hold(holders, [id]);
+    }
+    membership2.drop([ACCEPTED], ids);
+  }
+  function expireAccepted(rows) {
+    if (subsetGcTime <= 0) return;
+    const ids = rows.map(idOf).filter((id) => id !== void 0);
+    const timer = setTimeout(() => {
+      acceptedTimers.delete(timer);
+      settleAccepted(ids);
+    }, subsetGcTime);
+    acceptedTimers.add(timer);
+  }
+  async function settleHandler() {
+    if (refetchOnMutation) await adapter.reload();
+  }
+  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);
+      })
+    );
+    landServerRows(created);
+    await settleHandler();
+  };
+  const defaultUpdate = async ({ transaction }) => {
+    const updated = await Promise.all(
+      transaction.mutations.map(
+        (mutation) => pb.collection(collectionName).update(mutation.original.id, mutation.changes)
+      )
+    );
+    landServerRows(updated);
+    await settleHandler();
+  };
+  async function evict(ids) {
+    for (const id of ids) adapter.noteDeleted(id, "*");
+    await whenAccepted(membership2.dropAll(ids));
+  }
+  const defaultDelete = async ({ transaction }) => {
+    const ids = await Promise.all(
+      transaction.mutations.map(async (mutation) => {
+        await pb.collection(collectionName).delete(mutation.original.id);
+        return mutation.original.id;
+      })
+    );
+    await evict(ids);
+    await settleHandler();
+  };
+  const collection = createCollection$1({
+    autoIndex: "eager",
+    defaultIndexType: BTreeIndex,
+    ...options?.collectionOptions,
+    id: collectionName,
+    syncMode,
+    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;
+    },
+    sync: { sync: adapter.sync, rowUpdateMode: "full" },
+    onInsert: resolveHandler(options?.onInsert, defaultInsert),
+    onUpdate: resolveHandler(options?.onUpdate, defaultUpdate),
+    onDelete: resolveHandler(options?.onDelete, defaultDelete),
+    utils: { accept, reload: adapter.reload, evict }
+  });
+  function reloadFor(reason) {
+    void adapter.reload().catch(
+      (error) => logger.error(`Failed to reload after ${reason}`, { collectionName, error })
+    );
+  }
+  let removeTransportListeners;
+  collection.on("status:change", (event) => {
+    if (event.status === "cleaned-up") subsets.clear();
+    if (!removeTransportListeners && (event.status === "loading" || event.status === "ready")) {
+      const removeReconnect = transport.onReconnect((resumed) => {
+        if (resumed || !realtime.isOpen()) return;
+        if (!collection.isReady()) {
+          adapter.wakeRetries();
+          return;
+        }
+        reloadFor("realtime reconnect");
+      });
+      const removeAuth = transport.onAuthChange(() => {
+        adapter.expireParked();
+        for (const timer of acceptedTimers) clearTimeout(timer);
+        acceptedTimers.clear();
+        membership2.drop([ACCEPTED]);
+        if (store.isAttached()) reloadFor("auth change");
+      });
+      removeTransportListeners = () => {
+        removeReconnect();
+        removeAuth();
+      };
+    } else if (removeTransportListeners && event.status === "cleaned-up") {
+      removeTransportListeners();
+      removeTransportListeners = void 0;
+    }
+  });
+  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 handleRealtimeEvent(event, topic, expand) {
+    const id = idOf(event.record);
+    if (!id) return;
+    if (event.action === "delete") {
+      adapter.noteDeleted(id, topic);
+      const applied = topic === "*" ? membership2.dropAll([id]) : membership2.drop(
+        [
+          topic,
+          ...adapter.subsetsFor(topic),
+          ...holdersByFilter.get(topic) ?? [],
+          ACCEPTED
+        ],
+        [id]
+      );
+      if (applied === false) {
+        logger.debug("Ignoring delete echo while sync is not running", {
+          collectionName,
+          id
+        });
+      }
+      return;
+    }
+    const [stored] = stripFetchedRelations([event.record], pendingSubscribeExpand());
+    const land = () => {
+      const applied = membership2.land(topic, [stored]);
+      if (applied !== false) membership2.drop([ACCEPTED], [id]);
+      return applied !== false;
+    };
+    const paths = splitPaths(expand);
+    if (filer.canFileFirst([event.record], relationTargets)) {
+      filer.fileExpanded([event.record], relationTargets, paths).then((change) => {
+        if (land()) {
+          change.commit();
+          return;
+        }
+        change.undo();
+        logger.debug("Ignoring realtime echo while sync is not running", {
+          collectionName,
+          id
+        });
+      }).catch(
+        (error) => logger.error("Failed to file expanded records from realtime echo", {
+          collectionName,
+          error
+        })
+      );
+      return;
+    }
+    if (!land()) {
+      logger.debug("Ignoring realtime echo while sync is not running", { collectionName, id });
+      return;
+    }
+    filer.upsertExpanded([event.record], relationTargets, paths).catch(
+      (error) => logger.error("Failed to upsert expanded records from realtime echo", {
+        collectionName,
+        error
+      })
+    );
+  }
+  async function ensureSyncing() {
+    if (collection.isReady()) return true;
+    if (collection.status === "error") return false;
+    const idle = collection.status === "idle" || collection.status === "cleaned-up";
+    if (syncMode === "eager") {
+      if (idle) return false;
+      await collection.preload();
+      return true;
+    }
+    if (idle) collection.startSyncImmediate();
+    if (!collection.isReady()) {
+      await new Promise((resolve) => {
+        collection.onFirstReady(resolve);
+      });
+    }
+    return true;
+  }
+  async function writeFiled(records, holder) {
+    if (!await ensureSyncing()) {
+      logger.warn(
+        `not syncing filed rows into ${collectionName} because store is not yet ready`
+      );
+      return false;
+    }
+    return membership2.land(holder, withoutExpand(records)) !== false;
+  }
+  async function whenAccepted(applied) {
+    if (applied === true || applied === false) return;
+    const accepted = whenSyncAccepted(applied);
+    if (accepted !== true) await accepted;
+  }
+  async function accept(rows) {
+    if (!await ensureSyncing()) {
+      throw new Error(`Collection '${collectionName}' is not syncing; accept() has no store`);
+    }
+    const applied = membership2.accept(rows);
+    if (applied !== false) expireAccepted(rows);
+    await whenAccepted(applied);
+  }
+  const holdersByFilter = /* @__PURE__ */ new Map();
+  function swapHolderFilters(holder, previous, next) {
+    for (const filter of previous) {
+      const holders = holdersByFilter.get(filter);
+      holders?.delete(holder);
+      if (holders?.size === 0) holdersByFilter.delete(filter);
+    }
+    for (const filter of next) {
+      let holders = holdersByFilter.get(filter);
+      if (!holders) {
+        holders = /* @__PURE__ */ new Set();
+        holdersByFilter.set(filter, holders);
+      }
+      holders.add(holder);
+    }
+    realtime.swapHoldFilters(previous, next);
+  }
+  function holdLive(holder) {
+    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)];
+        swapHolderFilters(holder, current, next);
+        current = next;
+      },
+      release: () => {
+        if (released) return;
+        released = true;
+        swapHolderFilters(holder, current, []);
+        current = [];
+        membership2.drop([holder]);
+        subscription.unsubscribe();
+      }
+    };
+  }
+  function releaseFiled(ids, holder) {
+    if (membership2.drop([holder], ids) === false) {
+      logger.debug("Ignoring filed-row release while sync is not running", {
+        collectionName
+      });
+    }
+  }
+  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 adapter.reload().catch(
+        (error) => logger.error("Failed to reload after widening expand", {
+          collectionName,
+          error
+        })
+      );
+    }
+    realtime.restart();
+  }
+  Object.assign(collection, {
+    collectionName,
+    relationTargets,
+    waitForSubscription: realtime.wait,
+    isSubscribed: realtime.isOpen,
+    heldRelationTargetCount: held.count,
+    markSubsetLoaded: subsets.mark,
+    loadedSubsetCount: subsets.count,
+    holdLive,
+    writeFiled,
+    releaseFiled,
+    expectFiling: fetcher.expectFiling,
+    accept,
+    reload: adapter.reload,
+    evict,
+    fetchRelations: views.fetchRelations,
+    withRealtime: views.withRealtime
+  });
+  return collection;
+}
+
+// src/collection.ts
+function createCollection(pb, factoryOptions) {
+  return (collectionName, options) => {
+    return buildCollection({
+      pb,
+      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 { convertToPocketBaseFilter, convertToPocketBaseSort, createCollection, disconnectRealtime, newRecordId, resetLogger, resetRealtime, setLogger };
+//# sourceMappingURL=chunk-4CRCARB3.js.map
+//# sourceMappingURL=chunk-4CRCARB3.js.map