pbtsdb 0.9.2 → 0.10.0

package/dist/chunk-I6UWXRAH.js

@@ -1,1033 +0,0 @@
-import { BTreeIndex, createCollection as createCollection$1, parseWhereExpression, parseOrderByExpression } from '@tanstack/db';
-export { BTreeIndex, BasicIndex, ReverseIndex, createEffect, materialize, toArray } from '@tanstack/db';
-import { queryCollectionOptions, DeleteOperationItemNotFoundError } from '@tanstack/query-db-collection';
-
-// src/core.ts
-
-// src/expand-paths.ts
-function normalizePaths(paths) {
-  const set = /* @__PURE__ */ new Set();
-  for (const path of paths) {
-    const trimmed = path.trim();
-    if (trimmed) set.add(trimmed);
-  }
-  return [...set].sort();
-}
-function splitPaths(csv) {
-  return csv ? normalizePaths(csv.split(",")) : [];
-}
-function joinPaths(paths) {
-  const normalized = normalizePaths(paths);
-  return normalized.length > 0 ? normalized.join(",") : void 0;
-}
-var BACK_RELATION_EXPAND_CAP = 1e3;
-function parseViaKey(key) {
-  const index = key.indexOf("_via_");
-  if (index < 0) return void 0;
-  const field = key.slice(index + "_via_".length);
-  return field ? { field } : void 0;
-}
-function markFiledSubset(target, key, values, parentId) {
-  const via = parseViaKey(key);
-  if (!via || values.length >= BACK_RELATION_EXPAND_CAP) return;
-  target.markSubsetLoaded?.(via.field, parentId);
-}
-function validateExpandPath(collectionName, targets, path) {
-  if (!targets) {
-    throw new Error(
-      `Cannot expand "${path}" on collection "${collectionName}": no relations declared`
-    );
-  }
-  let current = targets;
-  for (const segment of path.split(".")) {
-    const next = current?.[segment];
-    if (!next) {
-      throw new Error(
-        `Cannot expand "${path}" on collection "${collectionName}": segment "${segment}" is not a declared relation`
-      );
-    }
-    current = next.relationTargets;
-  }
-}
-
-// src/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;
-}
-
-// 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;
-}
-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(".");
-}
-function convertToPocketBaseFilter(where) {
-  if (!where) {
-    return void 0;
-  }
-  const result = parseWhereExpression(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(" || ")})`;
-      },
-      not: (condition) => {
-        return `!(${condition})`;
-      },
-      in: (field, values) => {
-        const valueArray = Array.isArray(values) ? values : [values];
-        const uniqueValues = [...new Set(valueArray)];
-        const fieldStr = fieldPathToString(field);
-        const conditions = uniqueValues.map((v) => `${fieldStr} = ${escapeValue(v)}`);
-        return conditions.length > 1 ? `(${conditions.join(" || ")})` : conditions[0];
-      },
-      like: (field, value) => {
-        return `${fieldPathToString(field)} ~ ${escapeValue(value)}`;
-      },
-      isNull: (field) => {
-        return `${fieldPathToString(field)} = null`;
-      },
-      isUndefined: (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/build-collection.ts
-var viewPaths = /* @__PURE__ */ new WeakMap();
-var pendingFilings = /* @__PURE__ */ new WeakMap();
-function registerPendingFiling(target, field, settles) {
-  let byField = pendingFilings.get(target);
-  if (!byField) {
-    byField = /* @__PURE__ */ new Map();
-    pendingFilings.set(target, byField);
-  }
-  let pending = byField.get(field);
-  if (!pending) {
-    pending = [];
-    byField.set(field, pending);
-  }
-  pending.push(settles);
-  return () => {
-    const index = pending.indexOf(settles);
-    if (index !== -1) pending.splice(index, 1);
-    if (pending.length === 0) byField.delete(field);
-    if (byField.size === 0) pendingFilings.delete(target);
-  };
-}
-async function awaitPendingFiling(target, field) {
-  const pending = pendingFilings.get(target)?.get(field);
-  if (!pending || pending.length === 0) return;
-  await Promise.all(pending);
-}
-function registerMarkInvalidationEvents(collection, clearMarks) {
-  collection.onStatusChange((event) => {
-    if (event.status === "cleaned-up") clearMarks();
-  });
-  collection.onTruncate(() => clearMarks());
-}
-function buildCollection(input) {
-  const { pb, queryClient, factoryOptions, collectionName, options } = input;
-  const relationTargets = options?.relations;
-  const alwaysFetch = normalizePaths(options?.alwaysFetchRelations ?? []);
-  for (const path of alwaysFetch) validateExpandPath(collectionName, relationTargets, path);
-  const syncMode = options?.syncMode ?? "eager";
-  const requestedExpand = /* @__PURE__ */ new Set();
-  function toRequest(opts) {
-    const request = {};
-    const subset = subsetFromWhere(opts?.where);
-    const filter = subset ? void 0 : convertToPocketBaseFilter(opts?.where);
-    const sort = convertToPocketBaseSort(opts?.orderBy);
-    const expand = joinPaths(opts?.expand ?? []);
-    if (subset) request.subset = subset;
-    if (filter) request.filter = filter;
-    if (sort) request.sort = sort;
-    if (opts?.limit) request.limit = opts.limit;
-    if (expand) request.expand = expand;
-    return request;
-  }
-  function queryKeyFor(opts) {
-    const request = toRequest(opts);
-    return Object.keys(request).length === 0 ? [collectionName] : [collectionName, request];
-  }
-  function activeExpand(request) {
-    return joinPaths([
-      ...alwaysFetch,
-      ...splitPaths(request.expand),
-      ...syncMode === "eager" ? requestedExpand : []
-    ]);
-  }
-  function backRelationTargetsFor(request) {
-    if (!relationTargets) return [];
-    const results = [];
-    for (const key of splitPaths(activeExpand(request)).map((path) => path.split(".")[0])) {
-      const target = relationTargets[key];
-      const via = target && parseViaKey(key);
-      if (target && via) results.push({ target, key, field: via.field });
-    }
-    return results;
-  }
-  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;
-    });
-  }
-  const ignoreAutoCancellation = options?.ignoreAutoCancellation ?? true;
-  const refetchOnMutation = options?.refetchOnMutation ?? false;
-  function eagerSyncInFlight(target) {
-    return target.status !== void 0 && target.status !== "idle" && target.status !== "cleaned-up";
-  }
-  function withoutExpand(values) {
-    return values.map((value) => {
-      const { expand: _expand, ...plain } = value;
-      return plain;
-    });
-  }
-  async function upsertInto(key, target, values) {
-    if (!target.utils) return false;
-    if (!target.isReady()) {
-      if (target.config?.syncMode === "on-demand") {
-        await target._sync.startSync();
-      } else if (target.preload && eagerSyncInFlight(target)) {
-        await target.preload();
-      } else {
-        logger.warn(
-          `not syncing ${key} on ${collectionName} because store is not yet ready`
-        );
-        return false;
-      }
-    }
-    target.utils.writeUpsert(withoutExpand(values));
-    return true;
-  }
-  async function upsertExpandedField(key, value, targets, parentId) {
-    const target = targets[key];
-    if (!target) {
-      logger.debug("No relation target for expanded field", { collectionName, key });
-      return;
-    }
-    const values = Array.isArray(value) ? value : [value];
-    const filed = await upsertInto(key, target, values);
-    await upsertExpanded(values, target.relationTargets);
-    if (filed && parentId !== void 0) markFiledSubset(target, key, values, parentId);
-  }
-  async function upsertExpanded(records, targets) {
-    if (!targets) return;
-    for (const record of records) {
-      const expandData = record.expand;
-      if (!expandData) continue;
-      const id = record.id;
-      const parentId = typeof id === "string" ? id : void 0;
-      for (const [key, value] of Object.entries(expandData)) {
-        await upsertExpandedField(key, value, targets, parentId);
-      }
-    }
-  }
-  function markEmptyBackRelations(items, request) {
-    const heads = backRelationTargetsFor(request);
-    if (heads.length === 0) return;
-    for (const item of items) {
-      const { id, expand } = item;
-      if (typeof id !== "string") continue;
-      for (const { target, key, field } of heads) {
-        if (expand?.[key] === void 0) target.markSubsetLoaded?.(field, id);
-      }
-    }
-  }
-  function subsetFilter({ field, values }) {
-    return values.map((value) => `${field} = "${value.replace(/"/g, '\\"')}"`).join(" || ");
-  }
-  const loadedSubsets = /* @__PURE__ */ new Map();
-  function markSubsetLoaded(field, value) {
-    let values = loadedSubsets.get(field);
-    if (!values) {
-      values = /* @__PURE__ */ new Set();
-      loadedSubsets.set(field, values);
-    }
-    values.add(value);
-  }
-  function loadedSubsetCount() {
-    let count = 0;
-    for (const values of loadedSubsets.values()) count += values.size;
-    return count;
-  }
-  function subsetIsLoaded({ field, values }) {
-    const marked = loadedSubsets.get(field);
-    return marked !== void 0 && values.every((value) => marked.has(value));
-  }
-  function forgetMarkedValue(marked, value) {
-    if (typeof value === "string") return marked.delete(value) ? [value] : [];
-    if (!Array.isArray(value)) return [];
-    return value.filter((item) => typeof item === "string" && marked.delete(item));
-  }
-  function matchesMarkedSubset(query, isMarked) {
-    if (query.queryKey[0] !== collectionName) return false;
-    const request = query.queryKey[1];
-    if (!request?.subset) return false;
-    const { field, values } = request.subset;
-    return values.some((value) => isMarked(field, value));
-  }
-  function invalidateMarkedQueries(isMarked) {
-    void queryClient.invalidateQueries({ predicate: (query) => matchesMarkedSubset(query, isMarked) }).catch(
-      (error) => logger.error("Failed to invalidate marked subset queries", {
-        collectionName,
-        error
-      })
-    );
-  }
-  function invalidateForgottenSubset(field, values) {
-    invalidateMarkedQueries(
-      (queryField, value) => queryField === field && values.includes(value)
-    );
-  }
-  function invalidateAllMarkedSubsets() {
-    invalidateMarkedQueries((field, value) => loadedSubsets.get(field)?.has(value) ?? false);
-  }
-  function forgetMarksFor(row) {
-    if (!row || typeof row !== "object") return;
-    for (const [field, marked] of loadedSubsets) {
-      const forgotten = forgetMarkedValue(marked, row[field]);
-      if (forgotten.length > 0) {
-        queueMicrotask(() => invalidateForgottenSubset(field, forgotten));
-      }
-    }
-  }
-  function rowsFromStore(ids) {
-    const rows = [];
-    for (const id of ids) {
-      const row = collection._state.syncedData.get(id);
-      if (!row) return void 0;
-      rows.push(row);
-    }
-    return rows;
-  }
-  function idSubsetFromStore(subset, limit) {
-    const present = rowsFromStore(subset.values);
-    if (!present) return void 0;
-    return limit ? present.slice(0, limit) : present;
-  }
-  function fieldSubsetFromStore(subset, limit) {
-    if (!subsetIsLoaded(subset)) return void 0;
-    const wanted = new Set(subset.values);
-    const rows = [...collection._state.syncedData.values()].filter(
-      (row) => matchesSubset(row, subset.field, wanted)
-    );
-    return limit ? rows.slice(0, limit) : rows;
-  }
-  function servedFromStore(request) {
-    const { subset, sort, limit } = request;
-    if (!subset) return void 0;
-    if (subset.values.length === 0) return [];
-    if (request.expand) return void 0;
-    if (sort && limit) return void 0;
-    return subset.field === "id" ? idSubsetFromStore(subset, limit) : fieldSubsetFromStore(subset, limit);
-  }
-  async function fetchItems(request) {
-    const served = servedFromStore(request);
-    if (served) return served;
-    if (request.subset && request.subset.field !== "id" && backRelationTargetsFor(request).length === 0) {
-      await awaitPendingFiling(collection, request.subset.field);
-      const servedAfterFiling = servedFromStore(request);
-      if (servedAfterFiling) return servedAfterFiling;
-    }
-    const { sort, limit, subset } = request;
-    const filter = subset ? subsetFilter(subset) : request.filter;
-    const expand = activeExpand(request);
-    if (limit) {
-      const result = await pb.collection(collectionName).getList(1, limit, {
-        filter,
-        sort,
-        skipTotal: true,
-        // Optimize by skipping total count
-        expand
-      });
-      const items2 = result.items;
-      markEmptyBackRelations(items2, request);
-      return items2;
-    }
-    const items = await pb.collection(collectionName).getFullList({
-      filter,
-      sort,
-      expand
-    });
-    markEmptyBackRelations(items, request);
-    return items;
-  }
-  const inFlightConfirmedIds = /* @__PURE__ */ new Set();
-  function markConfirmedPresent(records) {
-    if (inFlightConfirmedIds.size === 0) return;
-    for (const record of records) {
-      const id = record?.id;
-      if (typeof id !== "string") continue;
-      for (const confirmed of inFlightConfirmedIds) confirmed.add(id);
-    }
-  }
-  function withRowsConfirmedMidFlight(items, confirmedMidFlight) {
-    if (confirmedMidFlight.size === 0) return items;
-    const resultIds = new Set(
-      items.map((item) => item?.id)
-    );
-    const mergedIds = [...confirmedMidFlight].filter(
-      (id) => !resultIds.has(id) && collection._state.syncedData.has(id)
-    );
-    if (mergedIds.length === 0) return items;
-    logger.debug("Merging rows confirmed while fetch was in flight", {
-      collectionName,
-      ids: mergedIds
-    });
-    return [
-      ...items,
-      ...mergedIds.map((id) => collection._state.syncedData.get(id))
-    ];
-  }
-  async function fetchRecords(request, queryKey) {
-    const confirmedMidFlight = /* @__PURE__ */ new Set();
-    inFlightConfirmedIds.add(confirmedMidFlight);
-    let settleFiling = () => void 0;
-    const filed = new Promise((resolve) => {
-      settleFiling = resolve;
-    });
-    const unregisterFilings = backRelationTargetsFor(request).map(
-      ({ target, field }) => registerPendingFiling(target, field, filed)
-    );
-    try {
-      let items;
-      try {
-        items = await fetchItems(request);
-      } catch (error) {
-        if (ignoreAutoCancellation && error instanceof Error && error.message.includes("autocancelled")) {
-          return withRowsConfirmedMidFlight(
-            queryClient.getQueryData(queryKey) ?? [],
-            confirmedMidFlight
-          );
-        }
-        throw error;
-      }
-      await upsertExpanded(items, relationTargets);
-      return withRowsConfirmedMidFlight(
-        stripFetchedRelations(items, activeExpand(request)),
-        confirmedMidFlight
-      );
-    } finally {
-      inFlightConfirmedIds.delete(confirmedMidFlight);
-      settleFiling();
-      for (const unregister of unregisterFilings) unregister();
-    }
-  }
-  const queryCollectionConfig = queryCollectionOptions({
-    autoIndex: "eager",
-    defaultIndexType: BTreeIndex,
-    ...options?.collectionOptions,
-    queryClient,
-    queryKey: queryKeyFor,
-    syncMode,
-    queryFn: async (ctx) => {
-      const request = ctx.queryKey[1] ?? {};
-      return fetchRecords(request, ctx.queryKey);
-    },
-    getKey: (item) => {
-      const record = item;
-      if (!record || typeof record !== "object" || !("id" in record)) {
-        throw new Error(
-          `Record in collection '${collectionName}' is missing required 'id' field. Received: ${JSON.stringify(item)}`
-        );
-      }
-      return record.id;
-    },
-    onInsert: options?.onInsert === false ? void 0 : options?.onInsert ?? (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);
-        })
-      );
-      writeBackAfterPersisted(transaction, created);
-      return { refetch: refetchOnMutation };
-    }),
-    onUpdate: options?.onUpdate === false ? void 0 : options?.onUpdate ?? (async ({ transaction }) => {
-      const updated = await Promise.all(
-        transaction.mutations.map(async (mutation) => {
-          const recordWithId = mutation.original;
-          return pb.collection(collectionName).update(recordWithId.id, mutation.changes);
-        })
-      );
-      writeBackAfterPersisted(transaction, updated);
-      return { refetch: refetchOnMutation };
-    }),
-    onDelete: options?.onDelete === false ? void 0 : options?.onDelete ?? (async ({ transaction }) => {
-      await Promise.all(
-        transaction.mutations.map(async (mutation) => {
-          const recordWithId = mutation.original;
-          await pb.collection(collectionName).delete(recordWithId.id);
-        })
-      );
-      return { refetch: refetchOnMutation };
-    })
-  });
-  const collectionOptions = options?.collectionOptions?.gcTime === void 0 ? queryCollectionConfig : { ...queryCollectionConfig, gcTime: options.collectionOptions.gcTime };
-  function writeBackAfterPersisted(transaction, records) {
-    markConfirmedPresent(records);
-    void transaction.isPersisted.promise.then(
-      () => {
-        if (!collection.utils || !collection.isReady()) return;
-        const fresh = records.filter((record) => !isStaleServerRecord(record));
-        if (fresh.length === 0) return;
-        writeOwn(() => collection.utils.writeUpsert(fresh));
-      },
-      // A rejected transaction rolled its draft back; there is
-      // nothing to write and nothing to report here.
-      () => void 0
-    );
-  }
-  let applyingOwnWrite = false;
-  function writeOwn(fn) {
-    applyingOwnWrite = true;
-    try {
-      fn();
-    } finally {
-      applyingOwnWrite = false;
-    }
-  }
-  function syncedWriteKey(op) {
-    if (op.type !== "insert" && op.type !== "update") return null;
-    if (typeof op.key === "string") return op.key;
-    const id = op.value?.id;
-    return typeof id === "string" ? id : null;
-  }
-  function shouldDropSyncedWrite(op) {
-    const key = syncedWriteKey(op);
-    if (key === null) return false;
-    if (!applyingOwnWrite && hasPendingOptimisticMutation(key) && collection._state.syncedData.has(key)) {
-      logger.debug("Dropping synced write for optimistically-pending row", {
-        collectionName,
-        id: key
-      });
-      return true;
-    }
-    if (isStaleServerRecord(op.value)) {
-      logger.debug("Dropping stale synced write", { collectionName, id: key });
-      return true;
-    }
-    return false;
-  }
-  let subscribingViewPaths;
-  function withViewExpand(opts) {
-    const paths = (opts.subscription && viewPaths.get(opts.subscription)) ?? subscribingViewPaths;
-    return paths ? { ...opts, expand: paths } : opts;
-  }
-  const innerSync = collectionOptions.sync.sync;
-  collectionOptions.sync = {
-    ...collectionOptions.sync,
-    sync: (params) => {
-      const guardedWrite = (message) => {
-        const op = message;
-        if (op.type === "delete" && !applyingOwnWrite) forgetMarksFor(op.value);
-        if (shouldDropSyncedWrite(op)) return;
-        return params.write(message);
-      };
-      const res = innerSync({ ...params, write: guardedWrite });
-      if (!res || typeof res === "function") return res;
-      const { loadSubset, unloadSubset } = res;
-      return {
-        ...res,
-        loadSubset: loadSubset ? (opts) => loadSubset(withViewExpand(opts)) : void 0,
-        unloadSubset: unloadSubset ? (opts) => unloadSubset(withViewExpand(opts)) : void 0
-      };
-    }
-  };
-  const collection = createCollection$1(collectionOptions);
-  const views = /* @__PURE__ */ new Map();
-  function createView(paths) {
-    const view = Object.create(collection);
-    Object.defineProperties(view, {
-      id: { value: `${collectionName}?expand=${paths.join(",")}` },
-      subscribeChanges: {
-        value: (...args) => {
-          noteViewSubscribed(paths);
-          subscribingViewPaths = paths;
-          try {
-            const subscription = collection.subscribeChanges(...args);
-            viewPaths.set(subscription, paths);
-            return subscription;
-          } finally {
-            subscribingViewPaths = void 0;
-          }
-        }
-      },
-      fetchRelations: {
-        value: () => {
-          throw new Error(`A view of "${collectionName}" cannot fetch further relations`);
-        }
-      }
-    });
-    return view;
-  }
-  function fetchRelations(...paths) {
-    for (const path of paths) validateExpandPath(collectionName, relationTargets, path);
-    const all = normalizePaths([...alwaysFetch, ...paths]);
-    if (all.every((path) => alwaysFetch.includes(path))) return collection;
-    const key = all.join(",");
-    let view = views.get(key);
-    if (!view) {
-      view = createView(all);
-      views.set(key, view);
-    }
-    return view;
-  }
-  function hasPendingOptimisticMutation(key) {
-    const state = collection._state;
-    return state.optimisticUpserts.has(key) || state.optimisticDeletes.has(key);
-  }
-  function recordUpdatedAt(record) {
-    const updated = record?.updated;
-    return typeof updated === "string" && updated !== "" ? updated : void 0;
-  }
-  function isStaleServerRecord(record) {
-    const id = record?.id;
-    if (typeof id !== "string") return false;
-    const incoming = recordUpdatedAt(record);
-    if (!incoming) return false;
-    const current = recordUpdatedAt(
-      collection._state.syncedData.get(id)
-    );
-    if (current === void 0) return false;
-    return incoming < current;
-  }
-  function isStaleEcho(event) {
-    if (event.action !== "create" && event.action !== "update") return false;
-    if (!isStaleServerRecord(event.record)) return false;
-    logger.debug("Ignoring stale realtime echo", {
-      collectionName,
-      id: event.record?.id
-    });
-    return true;
-  }
-  let unsubscribeFn = null;
-  let isSubscribed = false;
-  let subscriptionPromise = null;
-  let subscriptionResolve = null;
-  let subscribedExpand;
-  let subscriptionWork = Promise.resolve();
-  function enqueueSubscriptionWork(fn) {
-    const run = subscriptionWork.then(fn, fn).catch((error) => {
-      logger.error("Subscription work failed", { collectionName, error });
-    });
-    subscriptionWork = run;
-    return run;
-  }
-  function markEchoPresence(event) {
-    if (event.action !== "delete") markConfirmedPresent([event.record]);
-  }
-  const handleRealtimeEvent = (event) => {
-    if (!collection.utils) return;
-    markEchoPresence(event);
-    if (isStaleEcho(event)) return;
-    const [stored] = stripFetchedRelations([event.record], pendingSubscribeExpand());
-    try {
-      writeOwn(
-        () => collection.utils.writeBatch(() => {
-          switch (event.action) {
-            case "create":
-              collection.utils.writeInsert(stored);
-              break;
-            case "update":
-              collection.utils.writeUpsert(stored);
-              break;
-            case "delete":
-              if (event.record && "id" in event.record) {
-                collection.utils.writeDelete(event.record.id);
-              }
-              break;
-          }
-        })
-      );
-    } catch (error) {
-      if (error instanceof DeleteOperationItemNotFoundError) {
-        logger.debug("Ignoring delete echo for already-removed record", {
-          collectionName,
-          id: event.record?.id
-        });
-      } else {
-        throw error;
-      }
-    }
-    if (event.action !== "delete") {
-      upsertExpanded([event.record], relationTargets).catch(
-        (error) => logger.error("Failed to upsert expanded records from realtime echo", {
-          collectionName,
-          error
-        })
-      );
-    }
-  };
-  function pendingSubscribeExpand() {
-    return joinPaths([...alwaysFetch, ...requestedExpand]);
-  }
-  function activeExpandTargets() {
-    const targets = /* @__PURE__ */ new Set();
-    for (const path of splitPaths(pendingSubscribeExpand())) {
-      let current = relationTargets;
-      for (const segment of path.split(".")) {
-        const target = current?.[segment];
-        if (!target) break;
-        targets.add(target);
-        current = target.relationTargets;
-      }
-    }
-    return targets;
-  }
-  const heldTargetSubscriptions = /* @__PURE__ */ new Map();
-  function releaseHeldTarget(target) {
-    const held = heldTargetSubscriptions.get(target);
-    if (!held) return;
-    heldTargetSubscriptions.delete(target);
-    try {
-      held.unsubscribe();
-    } catch (error) {
-      logger.error("Failed to release relation target subscription", {
-        collectionName,
-        error
-      });
-    }
-  }
-  function holdTarget(target) {
-    if (heldTargetSubscriptions.has(target) || !target.subscribeChanges) return;
-    try {
-      const held = target.subscribeChanges(() => {
-      }, { includeInitialState: false });
-      heldTargetSubscriptions.set(target, held);
-    } catch (error) {
-      logger.error("Failed to hold relation target subscription", { collectionName, error });
-    }
-  }
-  function syncHeldSubscriptions(desired) {
-    for (const target of [...heldTargetSubscriptions.keys()]) {
-      if (!desired.has(target)) releaseHeldTarget(target);
-    }
-    for (const target of desired) holdTarget(target);
-  }
-  function realtimeSubscribeOptions() {
-    const base = factoryOptions?.subscribeOptions?.();
-    const expand = joinPaths([
-      ...splitPaths(pendingSubscribeExpand()),
-      ...splitPaths(base?.expand)
-    ]);
-    return expand ? { ...base, expand } : base;
-  }
-  const doStartSubscription = async () => {
-    if (isSubscribed) return;
-    if (!subscriptionPromise) {
-      subscriptionPromise = new Promise((resolve) => {
-        subscriptionResolve = resolve;
-      });
-    }
-    const pendingExpand = pendingSubscribeExpand();
-    try {
-      unsubscribeFn = await pb.collection(collectionName).subscribe("*", handleRealtimeEvent, realtimeSubscribeOptions());
-      isSubscribed = true;
-      subscribedExpand = pendingExpand;
-      syncHeldSubscriptions(activeExpandTargets());
-      logger.debug("Subscription started", { collectionName });
-      if (subscriptionResolve) {
-        subscriptionResolve();
-      }
-    } catch (error) {
-      logger.error("Failed to start subscription", { collectionName, error });
-    }
-    if (pendingSubscribeExpand() !== subscribedExpand) {
-      enqueueSubscriptionWork(doRestartSubscription).catch(() => {
-      });
-    }
-  };
-  const doStopSubscription = async (releaseTargets = true) => {
-    if (releaseTargets) {
-      syncHeldSubscriptions(/* @__PURE__ */ new Set());
-      invalidateAllMarkedSubsets();
-      loadedSubsets.clear();
-    }
-    if (!isSubscribed || !unsubscribeFn) return;
-    try {
-      await unsubscribeFn();
-      logger.debug("Subscription stopped", { collectionName });
-    } catch (error) {
-      logger.debug("Unsubscribe failed (expected if connection closed)", {
-        collectionName,
-        error
-      });
-    } finally {
-      unsubscribeFn = null;
-      isSubscribed = false;
-      subscribedExpand = void 0;
-      subscriptionPromise = null;
-      subscriptionResolve = null;
-    }
-  };
-  const doRestartSubscription = async () => {
-    if (!isSubscribed) return;
-    await doStopSubscription(false);
-    await doStartSubscription();
-  };
-  const startSubscription = () => enqueueSubscriptionWork(doStartSubscription);
-  const stopSubscription = () => enqueueSubscriptionWork(() => doStopSubscription());
-  const restartSubscription = () => enqueueSubscriptionWork(doRestartSubscription);
-  function noteViewSubscribed(paths) {
-    let grew = false;
-    for (const path of paths) {
-      if (requestedExpand.has(path)) continue;
-      requestedExpand.add(path);
-      grew = true;
-    }
-    if (!grew) return;
-    if (syncMode === "eager" && collection.status !== "idle" && collection.status !== "cleaned-up") {
-      void collection.utils.refetch().catch(
-        (error) => logger.error("Failed to refetch after widening expand", {
-          collectionName,
-          error
-        })
-      );
-    }
-    restartSubscription().catch(
-      (error) => logger.error("Failed to restart subscription with wider expand", {
-        collectionName,
-        error
-      })
-    );
-  }
-  const waitForSubscription = async (timeout = 5e3) => {
-    if (isSubscribed) return;
-    if (!subscriptionPromise) {
-      await new Promise((resolve) => {
-        const checkInterval = setInterval(() => {
-          if (subscriptionPromise) {
-            clearInterval(checkInterval);
-            resolve();
-          }
-        }, 10);
-        setTimeout(() => {
-          clearInterval(checkInterval);
-          resolve();
-        }, timeout);
-      });
-    }
-    if (subscriptionPromise) {
-      await Promise.race([
-        subscriptionPromise,
-        new Promise(
-          (_, reject) => setTimeout(() => reject(new Error("Subscription timeout")), timeout)
-        )
-      ]);
-    }
-  };
-  collection.on(
-    "subscribers:change",
-    (event) => {
-      const newCount = event.subscriberCount;
-      const previousCount = event.previousSubscriberCount;
-      if (newCount > 0 && previousCount === 0) {
-        startSubscription().catch(() => {
-        });
-      } else if (newCount === 0 && previousCount > 0) {
-        stopSubscription().catch(() => {
-        });
-      }
-    }
-  );
-  registerMarkInvalidationEvents(
-    {
-      onStatusChange: (callback) => collection.on("status:change", callback),
-      onTruncate: (callback) => collection.on("truncate", callback)
-    },
-    () => loadedSubsets.clear()
-  );
-  Object.assign(collection, {
-    collectionName,
-    relationTargets,
-    waitForSubscription,
-    isSubscribed: () => isSubscribed,
-    heldRelationTargetCount: () => heldTargetSubscriptions.size,
-    markSubsetLoaded,
-    loadedSubsetCount,
-    fetchRelations
-  });
-  return collection;
-}
-
-// src/collection.ts
-function createCollection(pb, queryClient, factoryOptions) {
-  return (collectionName, options) => {
-    return buildCollection({
-      pb,
-      queryClient,
-      factoryOptions,
-      collectionName,
-      options
-    });
-  };
-}
-
-// src/util.ts
-function newRecordId() {
-  const chars = "abcdefghijklmnopqrstuvwxyz0123456789";
-  let result = "";
-  for (let i = 0; i < 15; i++) {
-    result += chars.charAt(Math.floor(Math.random() * chars.length));
-  }
-  return result;
-}
-
-export { createCollection, newRecordId, resetLogger, setLogger };
-//# sourceMappingURL=chunk-I6UWXRAH.js.map
-//# sourceMappingURL=chunk-I6UWXRAH.js.map