@ai-matrx/records 0.87.32 → 0.92.0

package/dist/react/index.js

@@ -171,9 +171,18 @@ function stableFilterKey(filter) {
   return `{${parts.join(",")}}`;
 }
 function liftWithheld(rows) {
+  let shared;
+  for (const row of rows) {
+    const m = (row.measures ?? {})["_withheld"];
+    if (m !== void 0 && m !== null && typeof m === "object") {
+      shared = m;
+      break;
+    }
+  }
   return rows.map((row) => {
     const measures = row.measures ?? {};
-    const marker = measures["_withheld"];
+    const own = measures["_withheld"];
+    const marker = own !== void 0 && own !== null && typeof own === "object" ? own : shared;
     const rowCount = row.row_count ?? 0;
     if (marker === void 0 || marker === null || typeof marker !== "object") {
       return rowCount === row.row_count ? row : { ...row, row_count: rowCount };
@@ -4785,12 +4794,15 @@ function createRecordsClient(given) {
           () => true
         );
       }
-      const door = await callDoor(
-        DOORS.readRecord,
-        { p_organization_id: org, p_record_id: record_id },
-        "recordRead"
-      );
+      const [door, header] = await Promise.all([
+        callDoor(DOORS.readRecord, { p_organization_id: org, p_record_id: record_id }, "recordRead"),
+        // A version that cannot be read never takes the record away: it comes back as null.
+        callDoor(DOORS.recordHeaders, { p_organization_id: org, p_ids: [record_id] }, "recordRead.version").catch(
+          () => null
+        )
+      ]);
       if (!door.ok) return err(door.error);
+      const version = header && header.ok ? header.data?.find((h) => h.id === record_id)?.version ?? null : null;
       const { document, hidden } = unfold(door.data);
       let computed = [];
       let computedUnavailable = null;
@@ -4803,7 +4815,7 @@ function createRecordsClient(given) {
         if (provenance.ok) computed = provenance.data ?? [];
         else computedUnavailable = provenance.error;
       }
-      return ok({ record_id, document, hidden, computed, computedUnavailable });
+      return ok({ record_id, document, hidden, computed, computedUnavailable, version });
     },
     async listByIds({ table_id, ids }) {
       if (ids.length === 0) return ok([]);
@@ -8440,11 +8452,14 @@ function liveRowsFor(tableId, order = { sortFields: [], narrowed: false }) {
       );
     };
     let timer = null;
-    const stopLocal = onRecordChanged(() => {
+    const written = /* @__PURE__ */ new Set();
+    const stopLocal = onRecordChanged((changed) => {
+      written.add(changed);
       if (timer !== null) clearTimeout(timer);
       timer = setTimeout(() => {
         timer = null;
-        const ids = (entry.snapshot.data?.rows ?? []).map((row) => row.id);
+        const ids = [.../* @__PURE__ */ new Set([...(entry.snapshot.data?.rows ?? []).map((row) => row.id), ...written])];
+        written.clear();
         if (ids.length > 0) patchIds(ids).catch(() => entry.refetch());
       }, 250);
     });
@@ -8572,6 +8587,24 @@ function useRecordPage(tableId, options = {}) {
   const { live, liveReason } = liveStatus(useRecordsClient(), tableId);
   return { ...useSharedRows(useKeptPage(tableId, base)), live, liveReason };
 }
+function useRecordWrites() {
+  const [writes, setWrites] = useState(0);
+  useEffect3(() => {
+    let timer = null;
+    const stop = onRecordChanged(() => {
+      if (timer !== null) clearTimeout(timer);
+      timer = setTimeout(() => {
+        timer = null;
+        setWrites((n) => n + 1);
+      }, 250);
+    });
+    return () => {
+      if (timer !== null) clearTimeout(timer);
+      stop();
+    };
+  }, []);
+  return writes;
+}
 function useRecordChangeRevision(recordId) {
   const [revision, setRevision] = useState(0);
   useEffect3(() => {
@@ -9596,7 +9629,7 @@ function archivedTableOf(error) {
 }
 
 // src/react/useStoreTable.ts
-import { useEffect as useEffect7, useMemo as useMemo4 } from "react";
+import { useEffect as useEffect6, useMemo as useMemo3 } from "react";
 
 // src/typed-table/store-table.ts
 function storeTable(def) {
@@ -10689,7 +10722,7 @@ function blankToNull(type, value, field2) {
 }
 function createTableDataPort({ client, aliases }) {
   const shapes = /* @__PURE__ */ new Map();
-  let warnedNotLive2 = false;
+  let warnedNotLive = false;
   function bindingOf(alias) {
     return Object.prototype.hasOwnProperty.call(aliases, alias) ? aliases[alias] : null;
   }
@@ -10889,8 +10922,8 @@ function createTableDataPort({ client, aliases }) {
       }
       const realtime = client.config.realtime;
       if (!realtime) {
-        if (!warnedNotLive2) {
-          warnedNotLive2 = true;
+        if (!warnedNotLive) {
+          warnedNotLive = true;
           console.warn("[@ai-matrx/records/data] This host bound no realtime port, so other people's changes will not appear until a re-read.");
         }
         return () => {
@@ -10910,517 +10943,8 @@ function createTableDataPort({ client, aliases }) {
   };
 }
 
-// src/data/react.tsx
-import { createContext as createContext4, createElement as createElement4, useContext as useContext4, useEffect as useEffect6, useMemo as useMemo3, useRef as useRef4 } from "react";
-import {
-  QueryClient as QueryClientClass,
-  QueryClientContext,
-  QueryClientProvider,
-  hashKey,
-  useInfiniteQuery,
-  useQuery
-} from "@tanstack/react-query";
-var RECORDS_QUERY_ROOT = "@ai-matrx/records";
-var DATA_LIVE_GRACE_MS = 3e4;
-var BUMP_BATCH_MS = 40;
-var dataKeys = {
-  all: (portKey) => [RECORDS_QUERY_ROOT, "data", portKey],
-  sources: (portKey) => [RECORDS_QUERY_ROOT, "data", portKey, "sources"],
-  alias: (portKey, alias) => [RECORDS_QUERY_ROOT, "data", portKey, "alias", alias],
-  columns: (portKey, alias) => [...dataKeys.alias(portKey, alias), "columns"],
-  rowsPrefix: (portKey, alias) => [...dataKeys.alias(portKey, alias), "rows"],
-  rows: (portKey, alias, query) => [...dataKeys.rowsPrefix(portKey, alias), stableQuery(query)],
-  row: (portKey, alias, id) => [...dataKeys.alias(portKey, alias), "row", id]
-};
-function stableQuery(query) {
-  const sortKeys = (value) => {
-    if (Array.isArray(value)) return value.map(sortKeys);
-    if (value && typeof value === "object") {
-      return Object.fromEntries(
-        Object.keys(value).sort().filter((k) => value[k] !== void 0).map((k) => [k, sortKeys(value[k])])
-      );
-    }
-    return value;
-  };
-  return JSON.stringify(sortKeys(query ?? {}));
-}
-var DataRefusal = class extends Error {
-  error;
-  constructor(error) {
-    super(error.message);
-    this.name = "DataRefusal";
-    this.error = error;
-  }
-};
-function unwrap(answer) {
-  if (answer.ok) return answer.data;
-  throw new DataRefusal(answer.error);
-}
-function asRecordsError(thrown) {
-  if (!thrown) return null;
-  if (thrown instanceof DataRefusal) return thrown.error;
-  return { code: "unreachable", message: `The data could not be reached: ${thrown instanceof Error ? thrown.message : String(thrown)}` };
-}
-function retryable(failureCount, thrown) {
-  const code = thrown instanceof DataRefusal ? thrown.error.code : "unreachable";
-  return (code === "unreachable" || code === "timed_out") && failureCount < 2;
-}
-var DataPortContext = createContext4(null);
-function hostEvents(port) {
-  return { on: (event, listener) => port.subscribe(event, listener) };
-}
-var warnedNotLive = false;
-function useDataPort(scope) {
-  const held = useContext4(DataPortContext);
-  if (scope) return scope;
-  if (!held) {
-    throw new Error(
-      "A data hook was called outside <DataPortProvider>. The frame mounts it once with the host's DataPort and this Applet's portKey."
-    );
-  }
-  return held;
-}
-function forEachRowsEntry(qc, portKey, alias, fn) {
-  for (const [key, data] of qc.getQueriesData({ queryKey: dataKeys.rowsPrefix(portKey, alias) })) {
-    if (!data) continue;
-    const next = fn(key, data);
-    if (next && next !== data) qc.setQueryData(key, next);
-  }
-}
-var LANDED_MS = 3e4;
-var LANDED_KEY = /* @__PURE__ */ Symbol.for("@ai-matrx/records/data-landed");
-function landedHome(qc) {
-  const holder = qc;
-  let home = holder[LANDED_KEY];
-  if (!home) {
-    const made = { byAlias: /* @__PURE__ */ new Map(), unsubscribe: () => {
-    } };
-    made.unsubscribe = qc.getQueryCache().subscribe((event) => {
-      if (event.type !== "updated" || event.action.type !== "success") return;
-      const key = event.query.queryKey;
-      if (key[0] !== RECORDS_QUERY_ROOT || key[1] !== "data" || key[3] !== "alias" || key[5] !== "rows") return;
-      const portKey = String(key[2]);
-      const alias = String(key[4]);
-      const landed = made.byAlias.get(`${portKey}
${alias}`);
-      if (!landed || landed.size === 0) return;
-      reapplyLanded(qc, event.query.queryKey, landed);
-    });
-    holder[LANDED_KEY] = made;
-    home = made;
-  }
-  return home;
-}
-function remember(qc, portKey, alias, id, row) {
-  const home = landedHome(qc);
-  const key = `${portKey}
${alias}`;
-  let landed = home.byAlias.get(key);
-  if (!landed) home.byAlias.set(key, landed = /* @__PURE__ */ new Map());
-  const now = Date.now();
-  for (const [oldId, entry] of landed) if (now - entry.at > LANDED_MS) landed.delete(oldId);
-  landed.set(id, { row, at: now });
-}
-function reapplyLanded(qc, key, landed) {
-  const data = qc.getQueryData(key);
-  if (!data) return;
-  const now = Date.now();
-  let changed = false;
-  const pages = data.pages.map((page2) => {
-    let rows = null;
-    page2.rows.forEach((r, i) => {
-      const entry = landed.get(r._id);
-      if (!entry || now - entry.at > LANDED_MS) return;
-      if (entry.row === null) {
-        rows ??= page2.rows.slice();
-        rows[i] = null;
-      } else if (entry.row._version > r._version) {
-        rows ??= page2.rows.slice();
-        rows[i] = entry.row;
-      }
-    });
-    if (!rows) return page2;
-    changed = true;
-    return { ...page2, rows: rows.filter((r) => r !== null) };
-  });
-  if (changed) qc.setQueryData(key, { ...data, pages });
-}
-function patchRow(qc, portKey, alias, row, options = {}) {
-  if (options.fromStore) remember(qc, portKey, alias, row._id, row);
-  let held = false;
-  forEachRowsEntry(qc, portKey, alias, (_key, data) => {
-    let changed = false;
-    const pages = data.pages.map((page2) => {
-      const i = page2.rows.findIndex((r) => r._id === row._id);
-      if (i < 0) return page2;
-      held = true;
-      if (!options.force && page2.rows[i]._version > row._version) return page2;
-      changed = true;
-      const rows = page2.rows.slice();
-      rows[i] = row;
-      return { ...page2, rows };
-    });
-    return changed ? { ...data, pages } : data;
-  });
-  const rowKey = dataKeys.row(portKey, alias, row._id);
-  const current = qc.getQueryData(rowKey);
-  if (options.force || !current || current._version <= row._version) qc.setQueryData(rowKey, row);
-  return held;
-}
-function dropRow(qc, portKey, alias, id, options = {}) {
-  if (options.fromStore) remember(qc, portKey, alias, id, null);
-  forEachRowsEntry(qc, portKey, alias, (_key, data) => {
-    let changed = false;
-    const pages = data.pages.map((page2) => {
-      if (!page2.rows.some((r) => r._id === id)) return page2;
-      changed = true;
-      return { ...page2, rows: page2.rows.filter((r) => r._id !== id), total: page2.total === null ? null : Math.max(0, page2.total - 1) };
-    });
-    return changed ? { ...data, pages } : data;
-  });
-  qc.setQueryData(dataKeys.row(portKey, alias, id), null);
-}
-function findRow(qc, portKey, alias, id) {
-  const direct = qc.getQueryData(dataKeys.row(portKey, alias, id));
-  if (direct) return direct;
-  for (const [, data] of qc.getQueriesData({ queryKey: dataKeys.rowsPrefix(portKey, alias) })) {
-    for (const page2 of data?.pages ?? []) {
-      const hit = page2.rows.find((r) => r._id === id);
-      if (hit) return hit;
-    }
-  }
-  return null;
-}
-var LIVE_KEY = /* @__PURE__ */ Symbol.for("@ai-matrx/records/data-live");
-function liveHome(qc) {
-  const holder = qc;
-  let home = holder[LIVE_KEY];
-  if (!home) {
-    home = /* @__PURE__ */ new Map();
-    holder[LIVE_KEY] = home;
-  }
-  return home;
-}
-function isPlainNewestFirst(key) {
-  try {
-    const q = JSON.parse(String(key[key.length - 1]));
-    return !(q.where && q.where.length) && !q.search?.trim() && !(q.sort && q.sort.length);
-  } catch {
-    return false;
-  }
-}
-var REREAD_PAGES_MAX = 2;
-async function sourceKind(qc, port, portKey, alias) {
-  try {
-    const sources = await qc.ensureQueryData({ queryKey: dataKeys.sources(portKey), queryFn: async () => unwrap(await port.sources()) });
-    return sources.find((s) => s.alias === alias)?.kind ?? null;
-  } catch {
-    return null;
-  }
-}
-var DEFERRED_KEY = /* @__PURE__ */ Symbol.for("@ai-matrx/records/data-deferred-rereads");
-var OWED_KEY = /* @__PURE__ */ Symbol.for("@ai-matrx/records/data-owed-pages");
-function owedPages(qc) {
-  const holder = qc;
-  return holder[OWED_KEY] ??= /* @__PURE__ */ new Map();
-}
-function owedPage(qc, hash) {
-  const owed = owedPages(qc).get(hash);
-  if (!owed) return null;
-  const query = qc.getQueryCache().get(hash);
-  const data = query?.state.data;
-  const last = data?.pages[data.pages.length - 1];
-  if (!query || query.state.status === "error" || !data || data.pages.length >= owed.pages || !last?.cursor) {
-    owedPages(qc).delete(hash);
-    return null;
-  }
-  return owed;
-}
-function rereadList(qc, key) {
-  const query = qc.getQueryCache().find({ queryKey: key, exact: true });
-  if (!query || query.state.fetchStatus !== "fetching" && !owedPage(qc, query.queryHash)) {
-    void qc.invalidateQueries({ queryKey: key, exact: true });
-    return;
-  }
-  const holder = qc;
-  const waiting = holder[DEFERRED_KEY] ??= /* @__PURE__ */ new Set();
-  if (waiting.has(query.queryHash)) return;
-  waiting.add(query.queryHash);
-  const settle = () => {
-    if (query.state.fetchStatus === "fetching") return;
-    const owed = owedPage(qc, query.queryHash);
-    if (owed) {
-      owed.fetchNext();
-      return;
-    }
-    stop();
-    waiting.delete(query.queryHash);
-    void qc.invalidateQueries({ queryKey: key, exact: true });
-  };
-  const stop = qc.getQueryCache().subscribe((event) => {
-    if (event.query === query) settle();
-  });
-  settle();
-}
-function rereadOrCount(qc, key, data, count) {
-  if (data.pages.length <= REREAD_PAGES_MAX) rereadList(qc, key);
-  else qc.setQueryData(key, { ...data, newer: (data.newer ?? 0) + count });
-}
-function placeUnseen(qc, portKey, alias, rows, kind) {
-  for (const [key, data] of qc.getQueriesData({ queryKey: dataKeys.rowsPrefix(portKey, alias) })) {
-    if (!data || data.pages.length === 0) continue;
-    const missing = rows.filter((row) => !data.pages.some((page2) => page2.rows.some((r) => r._id === row._id)));
-    if (missing.length === 0) continue;
-    if (kind === "table" && isPlainNewestFirst(key)) {
-      const [first, ...rest] = data.pages;
-      qc.setQueryData(key, {
-        ...data,
-        pages: [{ ...first, rows: [...missing, ...first.rows], total: first.total === null ? null : first.total + missing.length }, ...rest]
-      });
-    } else {
-      rereadOrCount(qc, key, data, missing.length);
-    }
-  }
-}
-async function rereadIds(qc, port, portKey, alias, ids) {
-  const answers = await Promise.all(ids.map((id) => port.get(alias, id).then((a) => [id, a])));
-  const unseen = [];
-  for (const [id, answer] of answers) {
-    if (!answer.ok) continue;
-    if (answer.data === null) {
-      dropRow(qc, portKey, alias, id, { fromStore: true });
-    } else if (!patchRow(qc, portKey, alias, answer.data, { fromStore: true })) {
-      unseen.push(answer.data);
-    }
-  }
-  if (unseen.length > 0) placeUnseen(qc, portKey, alias, unseen, await sourceKind(qc, port, portKey, alias));
-}
-function rereadUnknown(qc, portKey, alias) {
-  for (const [key, data] of qc.getQueriesData({ queryKey: dataKeys.rowsPrefix(portKey, alias) })) {
-    if (!data || data.pages.length === 0) {
-      rereadList(qc, key);
-      continue;
-    }
-    if (data.pages.length <= REREAD_PAGES_MAX) rereadList(qc, key);
-    else qc.setQueryData(key, { ...data, newer: Math.max(data.newer ?? 0, 1) });
-  }
-  void qc.invalidateQueries({ queryKey: [...dataKeys.alias(portKey, alias), "row"] });
-}
-function onBump(qc, port, portKey, alias, entry, event) {
-  if (event.shape) {
-    void qc.invalidateQueries({ queryKey: dataKeys.alias(portKey, alias) });
-    return;
-  }
-  if (event.ids === null) entry.unknown = true;
-  else for (const id of event.ids) entry.pending.add(id);
-  if (entry.flush) return;
-  entry.flush = setTimeout(() => {
-    entry.flush = null;
-    const ids = [...entry.pending];
-    const unknown = entry.unknown;
-    entry.pending.clear();
-    entry.unknown = false;
-    if (unknown) rereadUnknown(qc, portKey, alias);
-    else if (ids.length > 0) void rereadIds(qc, port, portKey, alias, ids);
-  }, BUMP_BATCH_MS);
-}
-function acquireLive(qc, port, events, portKey, alias) {
-  const home = liveHome(qc);
-  const key = `${portKey}
${alias}`;
-  let entry = home.get(key);
-  if (!entry) {
-    const made = { refs: 0, stop: () => {
-    }, timer: null, pending: /* @__PURE__ */ new Set(), unknown: false, flush: null };
-    if (events) {
-      made.stop = events.on(`rows:${alias}`, (event) => onBump(qc, port, portKey, alias, made, event));
-    } else if (!warnedNotLive) {
-      warnedNotLive = true;
-      console.warn("[@ai-matrx/records/data/react] No event stream was given to DataPortProvider, so this view is not live.");
-    }
-    home.set(key, made);
-    entry = made;
-  }
-  const mine = entry;
-  mine.refs += 1;
-  if (mine.timer) {
-    clearTimeout(mine.timer);
-    mine.timer = null;
-  }
-  return () => {
-    mine.refs -= 1;
-    if (mine.refs > 0) return;
-    mine.timer = setTimeout(() => {
-      if (mine.refs > 0) return;
-      if (mine.flush) clearTimeout(mine.flush);
-      mine.stop();
-      if (home.get(key) === mine) home.delete(key);
-    }, DATA_LIVE_GRACE_MS);
-  };
-}
-var FALLBACK_KEY = /* @__PURE__ */ Symbol.for("@ai-matrx/records/data-query-client");
-function useRecordsQueryClient() {
-  const provided = useContext4(QueryClientContext);
-  if (provided) return provided;
-  const g = globalThis;
-  let held = g[FALLBACK_KEY];
-  if (!held) {
-    held = new QueryClientClass({ defaultOptions: { queries: { staleTime: 3e4, refetchOnWindowFocus: false } } });
-    g[FALLBACK_KEY] = held;
-  }
-  return held;
-}
-function useLive(alias, scope) {
-  const qc = useRecordsQueryClient();
-  const { port, portKey, events } = useDataPort(scope);
-  useEffect6(() => {
-    if (!alias) return;
-    return acquireLive(qc, port, events, portKey, alias);
-  }, [qc, port, events, portKey, alias]);
-}
-function useDataRows(alias, query = {}, scope, seed) {
-  const { port, portKey } = useDataPort(scope);
-  const qc = useRecordsQueryClient();
-  useLive(alias, scope);
-  const rowsKey = dataKeys.rows(portKey, alias, query);
-  const q = useInfiniteQuery(
-    {
-      queryKey: rowsKey,
-      queryFn: async ({ pageParam }) => unwrap(await port.list(alias, query, pageParam ?? void 0)),
-      initialPageParam: null,
-      getNextPageParam: (last) => last.cursor ?? void 0,
-      retry: retryable,
-      ...seed ? { initialData: { pages: [seed.data], pageParams: [null] }, initialDataUpdatedAt: seed.at } : {}
-    },
-    qc
-  );
-  const rows = useMemo3(() => {
-    const seen = /* @__PURE__ */ new Set();
-    const out = [];
-    for (const page2 of q.data?.pages ?? []) {
-      for (const row of page2.rows) {
-        if (seen.has(row._id)) continue;
-        seen.add(row._id);
-        out.push(row);
-      }
-    }
-    return out;
-  }, [q.data]);
-  const want = useRef4({ key: "", pages: 0 });
-  const keyHash = hashKey(rowsKey);
-  const loaded = q.data?.pages.length ?? 0;
-  const { isFetching, hasNextPage, isFetchNextPageError, fetchNextPage } = q;
-  useEffect6(() => {
-    const w = want.current;
-    if (w.key !== keyHash || isFetching || loaded >= w.pages) return;
-    if (!hasNextPage || isFetchNextPageError) {
-      want.current = { key: keyHash, pages: 0 };
-      owedPages(qc).delete(keyHash);
-      return;
-    }
-    void fetchNextPage({ cancelRefetch: false });
-  }, [qc, keyHash, isFetching, loaded, hasNextPage, isFetchNextPageError, fetchNextPage]);
-  return {
-    rows,
-    total: q.data?.pages[0]?.total ?? null,
-    loading: q.isPending,
-    loadingMore: q.isFetchingNextPage,
-    hasMore: Boolean(q.hasNextPage),
-    error: asRecordsError(q.error),
-    loadMore: () => {
-      if (!q.hasNextPage || q.isFetchingNextPage) return;
-      want.current = { key: keyHash, pages: loaded + 1 };
-      owedPages(qc).set(keyHash, { pages: loaded + 1, fetchNext: () => void q.fetchNextPage({ cancelRefetch: false }) });
-      if (!q.isFetching) void q.fetchNextPage({ cancelRefetch: false });
-    },
-    newer: q.data?.newer ?? 0,
-    refresh: () => void q.refetch()
-  };
-}
-var tempCounter = 0;
-function drawPatch(before, patch) {
-  const drawn = { ...before, ...patch, _id: before._id, _version: before._version, _organization_id: before._organization_id };
-  if (patch._custom && typeof patch._custom === "object") {
-    drawn._custom = { ...before._custom ?? {}, ...patch._custom };
-  } else if (before._custom !== void 0) {
-    drawn._custom = before._custom;
-  }
-  return drawn;
-}
-function useDataMutations(alias, scope) {
-  const qc = useRecordsQueryClient();
-  const { port, portKey } = useDataPort(scope);
-  return useMemo3(() => {
-    const snapshotRows = () => qc.getQueriesData({ queryKey: dataKeys.rowsPrefix(portKey, alias) });
-    const putBack = (snap) => {
-      for (const [key, data] of snap) qc.setQueryData(key, data);
-    };
-    return {
-      async create(values) {
-        const tempId = `pending-${Date.now().toString(36)}-${tempCounter += 1}`;
-        const drawn = { ...values, _id: tempId, _version: 0, _organization_id: "", _pending: true };
-        await qc.cancelQueries({ queryKey: dataKeys.rowsPrefix(portKey, alias) });
-        forEachRowsEntry(qc, portKey, alias, (_key, data) => {
-          if (data.pages.length === 0) return data;
-          const [first, ...rest] = data.pages;
-          return { ...data, pages: [{ ...first, rows: [drawn, ...first.rows], total: first.total === null ? null : first.total + 1 }, ...rest] };
-        });
-        const answer = await port.create(alias, values);
-        forEachRowsEntry(qc, portKey, alias, (_key, data) => {
-          const pages = data.pages.map((page2) => {
-            if (!page2.rows.some((r) => r._id === tempId)) return page2;
-            const rows = answer.ok ? page2.rows.map((r) => r._id === tempId ? answer.data : r) : page2.rows.filter((r) => r._id !== tempId);
-            return { ...page2, rows, total: answer.ok || page2.total === null ? page2.total : Math.max(0, page2.total - 1) };
-          });
-          return { ...data, pages };
-        });
-        if (answer.ok) qc.setQueryData(dataKeys.row(portKey, alias, answer.data._id), answer.data);
-        return answer;
-      },
-      async update(id, patch, options = {}) {
-        const before = findRow(qc, portKey, alias, id);
-        const baseVersion = options.baseVersion ?? before?._version;
-        if (typeof baseVersion !== "number") {
-          return { ok: false, error: { code: "stale_read", message: "Nothing was saved: this row's version is not known here.", hint: "Read the row first, then change it." } };
-        }
-        await qc.cancelQueries({ queryKey: dataKeys.alias(portKey, alias) });
-        const rowKey = dataKeys.row(portKey, alias, id);
-        const rowBefore = qc.getQueryData(rowKey);
-        if (before) patchRow(qc, portKey, alias, drawPatch(before, patch), { force: true });
-        const answer = await port.update(alias, id, patch, baseVersion);
-        if (answer.ok) {
-          patchRow(qc, portKey, alias, answer.data, { force: true, fromStore: true });
-          return answer;
-        }
-        if (before) patchRow(qc, portKey, alias, before, { force: true });
-        qc.setQueryData(rowKey, rowBefore);
-        void rereadIds(qc, port, portKey, alias, [id]);
-        return answer;
-      },
-      async archive(id) {
-        await qc.cancelQueries({ queryKey: dataKeys.rowsPrefix(portKey, alias) });
-        const snap = snapshotRows();
-        const rowKey = dataKeys.row(portKey, alias, id);
-        const rowBefore = qc.getQueryData(rowKey);
-        dropRow(qc, portKey, alias, id);
-        const answer = await port.archive(alias, id);
-        if (!answer.ok) {
-          putBack(snap);
-          qc.setQueryData(rowKey, rowBefore);
-          void qc.invalidateQueries({ queryKey: dataKeys.rowsPrefix(portKey, alias) });
-        }
-        return answer;
-      },
-      async restore(id) {
-        const answer = await port.restore(alias, id);
-        if (answer.ok) {
-          void qc.invalidateQueries({ queryKey: dataKeys.rowsPrefix(portKey, alias) });
-          void qc.invalidateQueries({ queryKey: dataKeys.row(portKey, alias, id) });
-        }
-        return answer;
-      }
-    };
-  }, [qc, port, portKey, alias]);
-}
-
 // src/react/useStoreTable.ts
+import { hostEvents, useDataMutations, useDataRows } from "@ai-matrx/records/data/react";
 var PAGE3 = 500;
 function columnRefusal2(table, column) {
   return {
@@ -11449,7 +10973,7 @@ function toNamed(table, row) {
 function useStoreTable(table, options = {}) {
   const client = useRecordsClient();
   const alias = table.id;
-  const scope = useMemo4(
+  const scope = useMemo3(
     () => {
       const port = createTableDataPort({ client, aliases: { [alias]: { kind: "table", tableId: table.id, organizationId: table.organizationId, label: table.name } } });
       return { port, events: hostEvents(port), portKey: `store-table|${client.config.organizationId ?? "-"}|${client.config.actor.user_id ?? "-"}` };
@@ -11457,7 +10981,7 @@ function useStoreTable(table, options = {}) {
     [client, alias, table.id, table.organizationId, table.name]
   );
   const asked = JSON.stringify(options);
-  const built = useMemo4(() => {
+  const built = useMemo3(() => {
     const where = [];
     for (const [name, value] of Object.entries(options.where ?? {})) {
       const column = table.columns[name];
@@ -11484,10 +11008,10 @@ function useStoreTable(table, options = {}) {
   const limit = Math.min(options.limit ?? STORE_ROWS_CEILING, STORE_ROWS_CEILING);
   const read = useDataRows(alias, built.ok ? built.data : { pageSize: 1 }, scope);
   const write = useDataMutations(alias, scope);
-  useEffect7(() => {
+  useEffect6(() => {
     if (built.ok && read.hasMore && !read.loadingMore && !read.loading && !read.error && read.rows.length < limit) read.loadMore();
   }, [built.ok, read.hasMore, read.loadingMore, read.loading, read.error, read.rows.length, limit, read]);
-  const rows = useMemo4(() => read.rows.slice(0, limit).filter((r) => r["_pending"] !== true).map((r) => toNamed(table, r)), [read.rows, limit, table]);
+  const rows = useMemo3(() => read.rows.slice(0, limit).filter((r) => r["_pending"] !== true).map((r) => toNamed(table, r)), [read.rows, limit, table]);
   const total = built.ok ? read.total : null;
   return {
     rows: built.ok ? rows : [],
@@ -13234,6 +12758,7 @@ export {
   useRecordChangeRevision,
   useRecordMutation,
   useRecordPage,
+  useRecordWrites,
   useRecords,
   useRecordsActor,
   useRecordsClient,