pbtsdb 0.8.0 → 0.9.1

package/dist/{chunk-KMR6I4ZC.js → chunk-LT7BDI37.js}

@@ -1,57 +1,109 @@
-import { BTreeIndex, createCollection as createCollection$1, parseWhereExpression, parseOrderByExpression, deepEquals } from '@tanstack/db';
-export { BTreeIndex, BasicIndex, ReverseIndex, createEffect, toArray } from '@tanstack/db';
+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-merge.ts
-function sameRelationValue(a, b) {
-  if (Array.isArray(a) && Array.isArray(b)) {
-    return a.length === b.length && a.every((value, index) => value === b[index]);
+// 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 a === b;
+  return [...set].sort();
 }
-function storedIsNewer(incoming, stored) {
-  const a = incoming;
-  const b = stored;
-  if (!a || !b || a.id !== b.id) return false;
-  if (typeof a.updated !== "string" || typeof b.updated !== "string") return false;
-  return b.updated > a.updated;
+function splitPaths(csv) {
+  return csv ? normalizePaths(csv.split(",")) : [];
 }
-function newerEntry(incoming, stored) {
-  if (Array.isArray(incoming) && Array.isArray(stored)) {
-    let changed = false;
-    const merged = incoming.map((entry) => {
-      const match = stored.find(
-        (candidate) => candidate?.id === entry?.id
+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`
       );
-      if (!storedIsNewer(entry, match)) return entry;
-      changed = true;
-      return match;
-    });
-    return changed ? merged : incoming;
+    }
+    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;
   }
-  return storedIsNewer(incoming, stored) ? stored : incoming;
 }
-function mergeExpand(incoming, existing) {
-  const stored = existing?.expand;
-  if (!stored) return incoming;
-  const row = incoming;
-  const merged = { ...row.expand ?? {} };
-  let carried = false;
-  for (const [relation, value] of Object.entries(stored)) {
-    if (relation in merged) {
-      const kept = newerEntry(merged[relation], value);
-      if (kept === merged[relation]) continue;
-      merged[relation] = kept;
-      carried = true;
-      continue;
-    }
-    if (!sameRelationValue(row[relation], existing[relation])) continue;
-    merged[relation] = value;
-    carried = true;
-  }
-  return carried ? { ...row, expand: merged } : incoming;
+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
@@ -84,112 +136,6 @@ function setLogger(customLogger) {
 function resetLogger() {
   currentLogger = defaultLogger;
 }
-
-// src/expand-patch.ts
-function embeddedId(value) {
-  return value?.id;
-}
-function patchUpdate(row, field, record) {
-  const embedded = row.expand?.[field];
-  if (embedded === void 0) return void 0;
-  let next;
-  if (Array.isArray(embedded)) {
-    const index = embedded.findIndex((entry) => embeddedId(entry) === record.id);
-    if (index === -1) return void 0;
-    const replaced = mergeExpand(record, embedded[index]);
-    next = embedded.map((entry, i) => i === index ? replaced : entry);
-  } else {
-    if (embeddedId(embedded) !== record.id) return void 0;
-    next = mergeExpand(record, embedded);
-  }
-  if (deepEquals(next, embedded)) return void 0;
-  return { ...row, expand: { ...row.expand, [field]: next } };
-}
-function patchDelete(row, field, id) {
-  const value = row[field];
-  const embedded = row.expand?.[field];
-  if (Array.isArray(value)) {
-    if (!value.includes(id)) return void 0;
-    const patched2 = { ...row, [field]: value.filter((item) => item !== id) };
-    if (Array.isArray(embedded)) {
-      patched2.expand = {
-        ...row.expand,
-        [field]: embedded.filter((entry) => embeddedId(entry) !== id)
-      };
-    }
-    return patched2;
-  }
-  if (value !== id) return void 0;
-  const patched = { ...row, [field]: "" };
-  if (embedded !== void 0) {
-    const expand = { ...row.expand };
-    delete expand[field];
-    patched.expand = expand;
-  }
-  return patched;
-}
-function patchEmbedded(row, field, action, record) {
-  const current = row;
-  const patched = action === "delete" ? patchDelete(current, field, record.id) : patchUpdate(current, field, record);
-  return patched;
-}
-function fieldsByParent(dependents) {
-  const grouped = /* @__PURE__ */ new Map();
-  for (const { field, parent } of dependents) {
-    const fields = grouped.get(parent);
-    if (fields) fields.push(field);
-    else grouped.set(parent, [field]);
-  }
-  return grouped;
-}
-function propagateRelatedChange(source, action, record, visited) {
-  for (const [parent, fields] of fieldsByParent(source.relationDependents ?? [])) {
-    try {
-      parent.applyRelatedChange?.(fields, action, record, visited);
-    } catch (error) {
-      logger.error("Failed to patch a relation dependent", {
-        collectionName: source.collectionName,
-        dependent: parent.collectionName,
-        fields,
-        error
-      });
-    }
-  }
-}
-
-// 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;
-}
-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;
-  }
-}
 function escapeValue(value) {
   if (value === null) {
     return "null";
@@ -289,22 +235,55 @@ function convertToPocketBaseSort(orderBy) {
 
 // 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 alwaysExpand = normalizePaths(options?.alwaysExpand ?? []);
-  for (const path of alwaysExpand) validateExpandPath(collectionName, relationTargets, path);
+  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 filter = convertToPocketBaseFilter(opts?.where);
+    const subset = subsetFromWhere(opts?.where);
+    const filter = subset ? void 0 : convertToPocketBaseFilter(opts?.where);
     const sort = convertToPocketBaseSort(opts?.orderBy);
-    const expand2 = joinPaths(opts?.expand ?? []);
+    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 (expand2) request.expand = expand2;
+    if (expand) request.expand = expand;
     return request;
   }
   function queryKeyFor(opts) {
@@ -313,18 +292,46 @@ function buildCollection(input) {
   }
   function activeExpand(request) {
     return joinPaths([
-      ...alwaysExpand,
+      ...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, 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;
+    if (!target.utils) return false;
     if (!target.isReady()) {
       if (target.config?.syncMode === "on-demand") {
         await target._sync.startSync();
@@ -334,48 +341,148 @@ function buildCollection(input) {
         logger.warn(
           `not syncing ${key} on ${collectionName} because store is not yet ready`
         );
-        return;
+        return false;
       }
     }
-    target.utils.writeUpsert(values);
+    target.utils.writeUpsert(withoutExpand(values));
+    return true;
   }
-  async function upsertExpandedField(key, value, targets) {
+  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];
-    await upsertInto(key, target, values);
+    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);
+        await upsertExpandedField(key, value, targets, parentId);
       }
     }
   }
+  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 { filter, sort, limit } = request;
-    const expand2 = activeExpand(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: expand2
+        expand
       });
       return result.items;
     }
     return await pb.collection(collectionName).getFullList({
       filter,
       sort,
-      expand: expand2
+      expand
     });
   }
   const inFlightConfirmedIds = /* @__PURE__ */ new Set();
@@ -408,6 +515,13 @@ function buildCollection(input) {
   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 {
@@ -422,50 +536,14 @@ function buildCollection(input) {
         throw error;
       }
       await upsertExpanded(items, relationTargets);
-      if (request.expand) writeExpandedRows(items);
-      return withRowsConfirmedMidFlight(items, confirmedMidFlight);
+      return withRowsConfirmedMidFlight(
+        stripFetchedRelations(items, activeExpand(request)),
+        confirmedMidFlight
+      );
     } finally {
       inFlightConfirmedIds.delete(confirmedMidFlight);
-    }
-  }
-  function writeExpandedRows(items) {
-    if (!collection.utils || !collection.isReady()) return;
-    collection.utils.writeUpsert(items);
-  }
-  function patchRowFields(row, fields, action, record) {
-    let current;
-    for (const field of fields) {
-      const next = patchEmbedded(current ?? row, field, action, record);
-      if (next) current = next;
-    }
-    return current;
-  }
-  function patchedRows(fields, action, record, visited) {
-    const patched = [];
-    for (const row of collection._state.syncedData.values()) {
-      const id = row.id;
-      if (typeof id !== "string") continue;
-      const key = `${collectionName}:${id}`;
-      if (visited.has(key)) continue;
-      const next = patchRowFields(row, fields, action, record);
-      if (!next) continue;
-      visited.add(key);
-      patched.push(next);
-    }
-    return patched;
-  }
-  function applyRelatedChange(fields, action, record, visited) {
-    if (!collection.utils || !collection.isReady()) return;
-    const patched = patchedRows(fields, action, record, visited);
-    if (patched.length === 0) return;
-    writeOwn(() => collection.utils.writeUpsert(patched));
-    for (const row of patched) {
-      propagateRelatedChange(
-        collection,
-        "update",
-        row,
-        visited
-      );
+      settleFiling();
+      for (const unregister of unregisterFilings) unregister();
     }
   }
   const queryCollectionConfig = queryCollectionOptions({
@@ -575,22 +653,14 @@ function buildCollection(input) {
     const paths = (opts.subscription && viewPaths.get(opts.subscription)) ?? subscribingViewPaths;
     return paths ? { ...opts, expand: paths } : opts;
   }
-  function mergedWriteValue(op) {
-    const key = syncedWriteKey(op);
-    const existing = key === null ? void 0 : collection._state.syncedData.get(key);
-    return mergeExpand(op.value, existing);
-  }
   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;
-        if ((op.type === "insert" || op.type === "update") && op.value && typeof op.value === "object") {
-          const merged = mergedWriteValue(op);
-          if (merged !== op.value) return params.write({ ...message, value: merged });
-        }
         return params.write(message);
       };
       const res = innerSync({ ...params, write: guardedWrite });
@@ -604,14 +674,6 @@ function buildCollection(input) {
     }
   };
   const collection = createCollection$1(collectionOptions);
-  const relationDependents = [];
-  for (const [field, target] of Object.entries(relationTargets ?? {})) {
-    target.relationDependents ?? (target.relationDependents = []);
-    target.relationDependents.push({
-      field,
-      parent: collection
-    });
-  }
   const views = /* @__PURE__ */ new Map();
   function createView(paths) {
     const view = Object.create(collection);
@@ -630,18 +692,18 @@ function buildCollection(input) {
           }
         }
       },
-      expand: {
+      fetchRelations: {
         value: () => {
-          throw new Error(`A view of "${collectionName}" cannot be expanded further`);
+          throw new Error(`A view of "${collectionName}" cannot fetch further relations`);
         }
       }
     });
     return view;
   }
-  function expand(...paths) {
+  function fetchRelations(...paths) {
     for (const path of paths) validateExpandPath(collectionName, relationTargets, path);
-    const all = normalizePaths([...alwaysExpand, ...paths]);
-    if (all.every((path) => alwaysExpand.includes(path))) return collection;
+    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) {
@@ -698,15 +760,16 @@ function buildCollection(input) {
     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(event.record);
+              collection.utils.writeInsert(stored);
               break;
             case "update":
-              collection.utils.writeUpsert(event.record);
+              collection.utils.writeUpsert(stored);
               break;
             case "delete":
               if (event.record && "id" in event.record) {
@@ -734,15 +797,9 @@ function buildCollection(input) {
         })
       );
     }
-    propagateRelatedChange(
-      collection,
-      event.action,
-      event.record,
-      /* @__PURE__ */ new Set()
-    );
   };
   function pendingSubscribeExpand() {
-    return joinPaths([...alwaysExpand, ...requestedExpand]);
+    return joinPaths([...alwaysFetch, ...requestedExpand]);
   }
   function activeExpandTargets() {
     const targets = /* @__PURE__ */ new Set();
@@ -789,11 +846,11 @@ function buildCollection(input) {
   }
   function realtimeSubscribeOptions() {
     const base = factoryOptions?.subscribeOptions?.();
-    const expand2 = joinPaths([
+    const expand = joinPaths([
       ...splitPaths(pendingSubscribeExpand()),
       ...splitPaths(base?.expand)
     ]);
-    return expand2 ? { ...base, expand: expand2 } : base;
+    return expand ? { ...base, expand } : base;
   }
   const doStartSubscription = async () => {
     if (isSubscribed) return;
@@ -821,7 +878,11 @@ function buildCollection(input) {
     }
   };
   const doStopSubscription = async (releaseTargets = true) => {
-    if (releaseTargets) syncHeldSubscriptions(/* @__PURE__ */ new Set());
+    if (releaseTargets) {
+      syncHeldSubscriptions(/* @__PURE__ */ new Set());
+      invalidateAllMarkedSubsets();
+      loadedSubsets.clear();
+    }
     if (!isSubscribed || !unsubscribeFn) return;
     try {
       await unsubscribeFn();
@@ -909,15 +970,22 @@ function buildCollection(input) {
       }
     }
   );
+  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,
-    expand,
-    relationDependents,
-    applyRelatedChange
+    markSubsetLoaded,
+    loadedSubsetCount,
+    fetchRelations
   });
   return collection;
 }
@@ -946,5 +1014,5 @@ function newRecordId() {
 }
 
 export { createCollection, newRecordId, resetLogger, setLogger };
-//# sourceMappingURL=chunk-KMR6I4ZC.js.map
-//# sourceMappingURL=chunk-KMR6I4ZC.js.map
+//# sourceMappingURL=chunk-LT7BDI37.js.map
+//# sourceMappingURL=chunk-LT7BDI37.js.map