@arbidocs/react 0.5.110 → 0.5.112

package/dist/documents/documents-data.js

@@ -0,0 +1,128 @@
+import { useCallback } from "react";
+import { useQuery, useQueryClient } from "@tanstack/react-query";
+import { useArbi } from "../useArbi.js";
+import { arbiQueryKeys } from "../hooks.js";
+import { invalidateTagTables, patchWorkspaceTags } from "../tags.js";
+import {
+  getCachedDocuments,
+  setCachedDocument,
+  upsertDocuments
+} from "./documents-cache.js";
+import { loadDocuments } from "./documents-loader.js";
+import { FINISHED_DOCUMENT_STATUSES, isRowNewer } from "./processing-order.js";
+import { useArbiWsStore } from "../websocket/store.js";
+function openWorkspaceId(arbi) {
+  return arbi.hasWorkspace ? arbi.getWorkspaceId() : null;
+}
+function useDocuments(workspaceId, options) {
+  const arbi = useArbi();
+  const qc = useQueryClient();
+  const workspace = workspaceId ?? openWorkspaceId(arbi) ?? "";
+  return useQuery({
+    queryKey: arbiQueryKeys.documents(workspace),
+    queryFn: ({ signal }) => {
+      if (openWorkspaceId(arbi) !== workspace)
+        return Promise.reject(new Error("The selected workspace changed."));
+      return loadDocuments(qc, arbi, workspace, signal);
+    },
+    enabled: (options?.enabled ?? true) && !!workspace && arbi.hasWorkspace,
+    staleTime: Infinity,
+    refetchOnMount: false,
+    refetchOnReconnect: false,
+    refetchOnWindowFocus: false
+  });
+}
+const DOCUMENT_STATUS_POLL_MS = 4e3;
+function processingInterval(doc) {
+  return doc?.status && !FINISHED_DOCUMENT_STATUSES.has(doc.status) ? DOCUMENT_STATUS_POLL_MS : false;
+}
+function useDocument(docId, options) {
+  const arbi = useArbi();
+  return useQuery({
+    queryKey: arbiQueryKeys.document(docId ?? ""),
+    queryFn: async () => (await arbi.documents.get([docId]))[0] ?? null,
+    enabled: (options?.enabled ?? true) && !!docId && arbi.isLoggedIn,
+    refetchInterval: options?.pollWhileProcessing ? (query) => processingInterval(query.state.data) : false
+  });
+}
+const SIMILARITY_THRESHOLD = 0.98;
+function useSimilarDocuments(options) {
+  const arbi = useArbi();
+  const workspace = openWorkspaceId(arbi) ?? "";
+  return useQuery({
+    queryKey: arbiQueryKeys.similarDocuments(workspace, SIMILARITY_THRESHOLD),
+    queryFn: () => arbi.readInWorkspace(
+      workspace,
+      () => arbi.documents.similar({ threshold: SIMILARITY_THRESHOLD })
+    ),
+    enabled: (options?.enabled ?? true) && !!workspace
+  });
+}
+let readSeq = 0;
+const latestReadByDoc = /* @__PURE__ */ new Map();
+async function refreshDocuments(qc, arbi, docIds) {
+  if (!docIds.length) return [];
+  const seq = ++readSeq;
+  for (const id of docIds) latestReadByDoc.set(id, seq);
+  try {
+    const read = await arbi.documents.get(docIds);
+    const fresh = read.filter((doc) => latestReadByDoc.get(doc.external_id) === seq).map((doc) => {
+      const live = useArbiWsStore.getState().tasks[doc.external_id];
+      return live && FINISHED_DOCUMENT_STATUSES.has(live.status) && doc.status !== live.status && isRowNewer(doc, live) !== true ? { ...doc, status: live.status } : doc;
+    });
+    if (!fresh.length) return [];
+    reconcileTagCounts(qc, fresh);
+    upsertDocuments(qc, fresh);
+    for (const doc of fresh) setCachedDocument(qc, doc);
+    return fresh;
+  } catch (error) {
+    console.error("Re-reading documents failed; the cached ones are kept:", error);
+    return [];
+  } finally {
+    for (const id of docIds) if (latestReadByDoc.get(id) === seq) latestReadByDoc.delete(id);
+  }
+}
+function useRefreshDocuments() {
+  const qc = useQueryClient();
+  const arbi = useArbi();
+  return useCallback((docIds) => refreshDocuments(qc, arbi, docIds), [qc, arbi]);
+}
+function reconcileTagCounts(qc, fresh) {
+  const byWorkspace = /* @__PURE__ */ new Map();
+  for (const doc of fresh) {
+    const cached = getCachedDocuments(qc, doc.workspace_ext_id)?.find(
+      (d) => d.external_id === doc.external_id
+    );
+    const before = new Set((cached?.doctags ?? []).map((dt) => dt.tag_ext_id));
+    const after = new Set((doc.doctags ?? []).map((dt) => dt.tag_ext_id));
+    const delta = byWorkspace.get(doc.workspace_ext_id) ?? /* @__PURE__ */ new Map();
+    for (const id of after) if (!before.has(id)) delta.set(id, (delta.get(id) ?? 0) + 1);
+    for (const id of before) if (!after.has(id)) delta.set(id, (delta.get(id) ?? 0) - 1);
+    byWorkspace.set(doc.workspace_ext_id, delta);
+  }
+  for (const [workspaceId, delta] of byWorkspace) adjustTagCounts(qc, workspaceId, delta);
+}
+function adjustTagCounts(qc, workspaceId, delta) {
+  if (![...delta.values()].some(Boolean)) return;
+  patchWorkspaceTags(
+    qc,
+    workspaceId,
+    (tags) => tags.map((tag) => {
+      const change = delta.get(tag.external_id);
+      return change ? { ...tag, doctag_count: Math.max(0, tag.doctag_count + change) } : tag;
+    })
+  );
+  void invalidateTagTables(qc, workspaceId);
+}
+export {
+  DOCUMENT_STATUS_POLL_MS,
+  FINISHED_DOCUMENT_STATUSES,
+  SIMILARITY_THRESHOLD,
+  adjustTagCounts,
+  refreshDocuments,
+  useDocument,
+  useDocuments,
+  useRefreshDocuments,
+  useSimilarDocuments
+};
+//# sourceMappingURL=documents-data.js.map

package/dist/documents/documents-data.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/documents/documents-data.ts"],
+  "sourcesContent": ["/**\n * Reading documents: a workspace's list (`useDocuments`, progressive, read once and then patched in\n * place), one document (`useDocument`, for a viewer), a set of documents by id, near-duplicate pairs\n * (`useSimilarDocuments`), and {@link refreshDocuments}, which re-reads just the documents an event\n * named and patches them into every cache that shows them.\n */\n\nimport { useCallback } from 'react'\nimport { useQuery, useQueryClient, type QueryClient } from '@tanstack/react-query'\nimport type { Arbi } from '@arbidocs/sdk/browser'\nimport { useArbi } from '../useArbi'\nimport { arbiQueryKeys } from '../hooks'\nimport { invalidateTagTables, patchWorkspaceTags } from '../tags'\nimport {\n  getCachedDocuments,\n  setCachedDocument,\n  upsertDocuments,\n  type WorkspaceDocument,\n} from './documents-cache'\nimport { loadDocuments } from './documents-loader'\nimport { FINISHED_DOCUMENT_STATUSES, isRowNewer } from './processing-order'\nimport { useArbiWsStore } from '../websocket/store'\n\nexport { FINISHED_DOCUMENT_STATUSES }\n\n/** The workspace open on `arbi`, or `null`. */\nfunction openWorkspaceId(arbi: Arbi): string | null {\n  return arbi.hasWorkspace ? arbi.getWorkspaceId() : null\n}\n\n/**\n * A workspace's documents (default: the open one). Read progressively: the first page is the\n * result, the remaining pages arrive in the background (`useDocumentsLoading`). After that the list\n * is never re-read on its own (mounting, focus, reconnecting): writes, processing events and\n * {@link refreshDocuments} patch it in place, as re-reading 100k documents is slow and tells\n * nothing new. Invalidating it re-reads it.\n */\nexport function useDocuments(workspaceId?: string | null, options?: { enabled?: boolean }) {\n  const arbi = useArbi()\n  const qc = useQueryClient()\n  const workspace = workspaceId ?? openWorkspaceId(arbi) ?? ''\n  return useQuery({\n    queryKey: arbiQueryKeys.documents(workspace),\n    queryFn: ({ signal }) => {\n      if (openWorkspaceId(arbi) !== workspace)\n        return Promise.reject(new Error('The selected workspace changed.'))\n      return loadDocuments(qc, arbi, workspace, signal)\n    },\n    enabled: (options?.enabled ?? true) && !!workspace && arbi.hasWorkspace,\n    staleTime: Infinity,\n    refetchOnMount: false,\n    refetchOnReconnect: false,\n    refetchOnWindowFocus: false,\n  })\n}\n\n/** How often a document still being processed is re-read (`useDocument`'s `pollWhileProcessing`). */\nexport const DOCUMENT_STATUS_POLL_MS = 4000\n\n/** Re-read a document while it is processing (a viewer waiting for its pages). */\nfunction processingInterval(doc: WorkspaceDocument | null | undefined): number | false {\n  return doc?.status && !FINISHED_DOCUMENT_STATUSES.has(doc.status)\n    ? DOCUMENT_STATUS_POLL_MS\n    : false\n}\n\n/**\n * One document (`null`: not found or not visible). `pollWhileProcessing` re-reads it every few\n * seconds until its processing is over. Writes here keep it current.\n */\nexport function useDocument(\n  docId: string | null | undefined,\n  options?: { enabled?: boolean; pollWhileProcessing?: boolean }\n) {\n  const arbi = useArbi()\n  return useQuery({\n    queryKey: arbiQueryKeys.document(docId ?? ''),\n    queryFn: async (): Promise<WorkspaceDocument | null> =>\n      (await arbi.documents.get([docId as string]))[0] ?? null,\n    enabled: (options?.enabled ?? true) && !!docId && arbi.isLoggedIn,\n    refetchInterval: options?.pollWhileProcessing\n      ? (query) => processingInterval(query.state.data)\n      : false,\n  })\n}\n\n/**\n * The similarity at or above which two documents count as near duplicates (the Related column).\n * The server keeps every pair above 0.75 but returns only those at or above what is asked.\n */\nexport const SIMILARITY_THRESHOLD = 0.98\n\n/** Near-duplicate document pairs in the open workspace, at or above {@link SIMILARITY_THRESHOLD}. */\nexport function useSimilarDocuments(options?: { enabled?: boolean }) {\n  const arbi = useArbi()\n  const workspace = openWorkspaceId(arbi) ?? ''\n  return useQuery({\n    queryKey: arbiQueryKeys.similarDocuments(workspace, SIMILARITY_THRESHOLD),\n    queryFn: () =>\n      arbi.readInWorkspace(workspace, () =>\n        arbi.documents.similar({ threshold: SIMILARITY_THRESHOLD })\n      ),\n    enabled: (options?.enabled ?? true) && !!workspace,\n  })\n}\n\n// Each re-read gets a number; only the latest one issued for a document may write it. Events can\n// return out of order, and an older read must not undo tags a newer one applied.\nlet readSeq = 0\nconst latestReadByDoc = new Map<string, number>()\n\n/**\n * Re-read `docIds` and patch them into the caches that show them: their workspace's list (added\n * when new), their own entries, and the tag list's document counts (tags the server applied, e.g.\n * AI fields). For events that name documents (a batch finished, a version saved, an upload): the\n * list is never re-read for them. A failed read leaves the caches as they were.\n */\nexport async function refreshDocuments(\n  qc: QueryClient,\n  arbi: Arbi,\n  docIds: string[]\n): Promise<WorkspaceDocument[]> {\n  if (!docIds.length) return []\n  const seq = ++readSeq\n  for (const id of docIds) latestReadByDoc.set(id, seq)\n  try {\n    const read = await arbi.documents.get(docIds)\n    const fresh = read\n      .filter((doc) => latestReadByDoc.get(doc.external_id) === seq)\n      .map((doc) => {\n        // A finished status heard live wins over a read that predates it (the row may not be\n        // committed yet), never over a row that finished after it.\n        const live = useArbiWsStore.getState().tasks[doc.external_id]\n        return live &&\n          FINISHED_DOCUMENT_STATUSES.has(live.status) &&\n          doc.status !== live.status &&\n          isRowNewer(doc, live) !== true\n          ? { ...doc, status: live.status }\n          : doc\n      })\n    if (!fresh.length) return []\n    reconcileTagCounts(qc, fresh)\n    upsertDocuments(qc, fresh)\n    for (const doc of fresh) setCachedDocument(qc, doc)\n    return fresh\n  } catch (error) {\n    // Leave the caches as they were: re-reading the whole list would shrink it to its first page.\n    console.error('Re-reading documents failed; the cached ones are kept:', error)\n    return []\n  } finally {\n    for (const id of docIds) if (latestReadByDoc.get(id) === seq) latestReadByDoc.delete(id)\n  }\n}\n\n/** `refreshDocuments` on this host's cache and `Arbi`, for a component or a hook. */\nexport function useRefreshDocuments(): (docIds: string[]) => Promise<WorkspaceDocument[]> {\n  const qc = useQueryClient()\n  const arbi = useArbi()\n  return useCallback((docIds: string[]) => refreshDocuments(qc, arbi, docIds), [qc, arbi])\n}\n\n/** Move each tag's document count by the tags the re-read documents gained or lost. */\nfunction reconcileTagCounts(qc: QueryClient, fresh: WorkspaceDocument[]): void {\n  const byWorkspace = new Map<string, Map<string, number>>()\n  for (const doc of fresh) {\n    const cached = getCachedDocuments(qc, doc.workspace_ext_id)?.find(\n      (d) => d.external_id === doc.external_id\n    )\n    const before = new Set((cached?.doctags ?? []).map((dt) => dt.tag_ext_id))\n    const after = new Set((doc.doctags ?? []).map((dt) => dt.tag_ext_id))\n    const delta = byWorkspace.get(doc.workspace_ext_id) ?? new Map<string, number>()\n    for (const id of after) if (!before.has(id)) delta.set(id, (delta.get(id) ?? 0) + 1)\n    for (const id of before) if (!after.has(id)) delta.set(id, (delta.get(id) ?? 0) - 1)\n    byWorkspace.set(doc.workspace_ext_id, delta)\n  }\n  for (const [workspaceId, delta] of byWorkspace) adjustTagCounts(qc, workspaceId, delta)\n}\n\n/** Add `delta` (tag id \u2192 change) to the tags' document counts; the tag tables re-read. */\nexport function adjustTagCounts(\n  qc: QueryClient,\n  workspaceId: string,\n  delta: Map<string, number>\n): void {\n  if (![...delta.values()].some(Boolean)) return\n  patchWorkspaceTags(qc, workspaceId, (tags) =>\n    tags.map((tag) => {\n      const change = delta.get(tag.external_id)\n      return change ? { ...tag, doctag_count: Math.max(0, tag.doctag_count + change) } : tag\n    })\n  )\n  void invalidateTagTables(qc, workspaceId)\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/documents/documents-loader.js

@@ -0,0 +1,113 @@
+import { useSyncExternalStore } from "react";
+import { patchDocuments } from "./documents-cache.js";
+const DOCUMENTS_FIRST_PAGE_SIZE = 500;
+const DOCUMENTS_PAGE_SIZE = 2e3;
+const DOCUMENTS_FIRST_PAGE_MEASURE = "arbi:document-list:page1";
+const FIRST_PAGE_MEASURE = DOCUMENTS_FIRST_PAGE_MEASURE;
+const FIRST_PAGE_START = "arbi:document-list:start";
+function mark(name) {
+  try {
+    performance.mark(name);
+  } catch {
+  }
+}
+function measure(name, start) {
+  try {
+    performance.measure(name, start);
+  } catch {
+  }
+}
+const backgroundReads = /* @__PURE__ */ new Map();
+const loadingListeners = /* @__PURE__ */ new Set();
+function emitLoading() {
+  for (const listener of loadingListeners) listener();
+}
+function subscribeLoading(listener) {
+  loadingListeners.add(listener);
+  return () => {
+    loadingListeners.delete(listener);
+  };
+}
+function isDocumentsLoading() {
+  return backgroundReads.size > 0;
+}
+function useDocumentsLoading() {
+  return useSyncExternalStore(subscribeLoading, isDocumentsLoading, () => false);
+}
+function stopDocumentsLoading(workspaceId) {
+  const controller = backgroundReads.get(workspaceId);
+  if (!controller) return;
+  controller.abort();
+  backgroundReads.delete(workspaceId);
+  emitLoading();
+}
+async function loadDocuments(qc, arbi, workspaceId, signal) {
+  let stopped = false;
+  for (const [id, controller2] of backgroundReads) {
+    if (id === workspaceId) continue;
+    controller2.abort();
+    backgroundReads.delete(id);
+    stopped = true;
+  }
+  if (stopped) emitLoading();
+  const controller = new AbortController();
+  signal?.addEventListener("abort", () => controller.abort(), { once: true });
+  const pages = arbi.documents.listPaginated({
+    workspaceId,
+    pageSize: DOCUMENTS_PAGE_SIZE,
+    firstPageSize: DOCUMENTS_FIRST_PAGE_SIZE,
+    signal: controller.signal
+  });
+  mark(FIRST_PAGE_START);
+  const first = await pages.next();
+  const firstPage = first.done ? [] : first.value;
+  measure(FIRST_PAGE_MEASURE, FIRST_PAGE_START);
+  if (first.done || firstPage.length < DOCUMENTS_FIRST_PAGE_SIZE) return firstPage;
+  if (backgroundReads.has(workspaceId)) {
+    controller.abort();
+    return firstPage;
+  }
+  backgroundReads.set(workspaceId, controller);
+  emitLoading();
+  void appendRemainingPages(qc, workspaceId, pages, controller.signal).finally(() => {
+    if (backgroundReads.get(workspaceId) !== controller) return;
+    backgroundReads.delete(workspaceId);
+    emitLoading();
+  });
+  return firstPage;
+}
+async function appendRemainingPages(qc, workspaceId, pages, signal) {
+  await Promise.resolve();
+  try {
+    for await (const page of pages) {
+      if (signal.aborted) return;
+      patchDocuments(
+        qc,
+        (old) => {
+          const known = new Set(old.map((doc) => doc.external_id));
+          const fresh = page.filter((doc) => !known.has(doc.external_id));
+          return fresh.length ? [...old, ...fresh] : old;
+        },
+        workspaceId
+      );
+    }
+  } catch (error) {
+    if (!signal.aborted) console.error(`Reading the documents of ${workspaceId} failed:`, error);
+  }
+}
+function resetDocumentsLoadingForTests() {
+  for (const controller of backgroundReads.values()) controller.abort();
+  backgroundReads.clear();
+  emitLoading();
+}
+export {
+  DOCUMENTS_FIRST_PAGE_MEASURE,
+  DOCUMENTS_FIRST_PAGE_SIZE,
+  DOCUMENTS_PAGE_SIZE,
+  isDocumentsLoading,
+  loadDocuments,
+  resetDocumentsLoadingForTests,
+  stopDocumentsLoading,
+  useDocumentsLoading
+};
+//# sourceMappingURL=documents-loader.js.map

package/dist/documents/documents-loader.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/documents/documents-loader.ts"],
+  "sourcesContent": ["/**\n * Reading a workspace's documents progressively: the first page is the query's result, so the\n * list shows within a few hundred milliseconds even for 100k documents, and the remaining pages\n * are appended to the same cache entry in the background as they arrive. One background read per\n * workspace; opening another workspace stops the previous one. Whether a background read is\n * running is observable ({@link useDocumentsLoading}), for a \"still loading\" indicator.\n */\n\nimport { useSyncExternalStore } from 'react'\nimport type { QueryClient } from '@tanstack/react-query'\nimport type { Arbi } from '@arbidocs/sdk/browser'\nimport { patchDocuments, type WorkspaceDocument } from './documents-cache'\n\n/** First page: small, so rows are on screen in a few hundred ms even in a large workspace. */\nexport const DOCUMENTS_FIRST_PAGE_SIZE = 500\n\n/** Later pages: larger, fewer round trips (the server caps a page at 10 000). */\nexport const DOCUMENTS_PAGE_SIZE = 2000\n\n/**\n * The time to the first page, as a `performance` measure of this name (a host reporting\n * performance can observe it).\n */\nexport const DOCUMENTS_FIRST_PAGE_MEASURE = 'arbi:document-list:page1'\nconst FIRST_PAGE_MEASURE = DOCUMENTS_FIRST_PAGE_MEASURE\nconst FIRST_PAGE_START = 'arbi:document-list:start'\n\nfunction mark(name: string): void {\n  try {\n    performance.mark(name)\n  } catch {\n    // No performance timeline here (an old runtime, a test): nothing to record.\n  }\n}\n\nfunction measure(name: string, start: string): void {\n  try {\n    performance.measure(name, start)\n  } catch {\n    // The start mark is missing: nothing to record.\n  }\n}\n\nconst backgroundReads = new Map<string, AbortController>()\nconst loadingListeners = new Set<() => void>()\n\nfunction emitLoading(): void {\n  for (const listener of loadingListeners) listener()\n}\n\nfunction subscribeLoading(listener: () => void): () => void {\n  loadingListeners.add(listener)\n  return () => {\n    loadingListeners.delete(listener)\n  }\n}\n\n/** Whether a workspace's remaining document pages are being read in the background. */\nexport function isDocumentsLoading(): boolean {\n  return backgroundReads.size > 0\n}\n\n/** True while the remaining pages of a documents list are still arriving. */\nexport function useDocumentsLoading(): boolean {\n  return useSyncExternalStore(subscribeLoading, isDocumentsLoading, () => false)\n}\n\n/** Stop a workspace's background read (closing the workspace). */\nexport function stopDocumentsLoading(workspaceId: string): void {\n  const controller = backgroundReads.get(workspaceId)\n  if (!controller) return\n  controller.abort()\n  backgroundReads.delete(workspaceId)\n  emitLoading()\n}\n\n/**\n * Read a workspace's documents: resolves with the first page and appends the rest to\n * `arbiQueryKeys.documents(workspaceId)` in the background. The query function of `useDocuments`.\n */\nexport async function loadDocuments(\n  qc: QueryClient,\n  arbi: Arbi,\n  workspaceId: string,\n  signal?: AbortSignal\n): Promise<WorkspaceDocument[]> {\n  let stopped = false\n  for (const [id, controller] of backgroundReads) {\n    if (id === workspaceId) continue\n    controller.abort()\n    backgroundReads.delete(id)\n    stopped = true\n  }\n  if (stopped) emitLoading()\n\n  const controller = new AbortController()\n  signal?.addEventListener('abort', () => controller.abort(), { once: true })\n  // Named, not the session's open workspace: the pages are this workspace's whatever the server\n  // session is in, so a list read across a workspace switch can never be another's.\n  const pages = arbi.documents.listPaginated({\n    workspaceId,\n    pageSize: DOCUMENTS_PAGE_SIZE,\n    firstPageSize: DOCUMENTS_FIRST_PAGE_SIZE,\n    signal: controller.signal,\n  })\n  mark(FIRST_PAGE_START)\n  const first = await pages.next()\n  const firstPage = first.done ? [] : first.value\n  measure(FIRST_PAGE_MEASURE, FIRST_PAGE_START)\n  if (first.done || firstPage.length < DOCUMENTS_FIRST_PAGE_SIZE) return firstPage\n  if (backgroundReads.has(workspaceId)) {\n    controller.abort()\n    return firstPage\n  }\n\n  backgroundReads.set(workspaceId, controller)\n  emitLoading()\n  void appendRemainingPages(qc, workspaceId, pages, controller.signal).finally(() => {\n    if (backgroundReads.get(workspaceId) !== controller) return\n    backgroundReads.delete(workspaceId)\n    emitLoading()\n  })\n  return firstPage\n}\n\nasync function appendRemainingPages(\n  qc: QueryClient,\n  workspaceId: string,\n  pages: AsyncGenerator<WorkspaceDocument[]>,\n  signal: AbortSignal\n): Promise<void> {\n  // Let the query store the first page before the second is appended to it.\n  await Promise.resolve()\n  try {\n    for await (const page of pages) {\n      if (signal.aborted) return\n      // A write may already have added some of these (an upload finishing meanwhile).\n      patchDocuments(\n        qc,\n        (old) => {\n          const known = new Set(old.map((doc) => doc.external_id))\n          const fresh = page.filter((doc) => !known.has(doc.external_id))\n          return fresh.length ? [...old, ...fresh] : old\n        },\n        workspaceId\n      )\n    }\n  } catch (error) {\n    if (!signal.aborted) console.error(`Reading the documents of ${workspaceId} failed:`, error)\n  }\n}\n\n/** Test-only: stop every background read. @internal */\nexport function resetDocumentsLoadingForTests(): void {\n  for (const controller of backgroundReads.values()) controller.abort()\n  backgroundReads.clear()\n  emitLoading()\n}\n"],
+  "mappings": "AAQA,SAAS,4BAA4B;AAGrC,SAAS,sBAA8C;AAGhD,MAAM,4BAA4B;AAGlC,MAAM,sBAAsB;AAM5B,MAAM,+BAA+B;AAC5C,MAAM,qBAAqB;AAC3B,MAAM,mBAAmB;AAEzB,SAAS,KAAK,MAAoB;AAChC,MAAI;AACF,gBAAY,KAAK,IAAI;AAAA,EACvB,QAAQ;AAAA,EAER;AACF;AAEA,SAAS,QAAQ,MAAc,OAAqB;AAClD,MAAI;AACF,gBAAY,QAAQ,MAAM,KAAK;AAAA,EACjC,QAAQ;AAAA,EAER;AACF;AAEA,MAAM,kBAAkB,oBAAI,IAA6B;AACzD,MAAM,mBAAmB,oBAAI,IAAgB;AAE7C,SAAS,cAAoB;AAC3B,aAAW,YAAY,iBAAkB,UAAS;AACpD;AAEA,SAAS,iBAAiB,UAAkC;AAC1D,mBAAiB,IAAI,QAAQ;AAC7B,SAAO,MAAM;AACX,qBAAiB,OAAO,QAAQ;AAAA,EAClC;AACF;AAGO,SAAS,qBAA8B;AAC5C,SAAO,gBAAgB,OAAO;AAChC;AAGO,SAAS,sBAA+B;AAC7C,SAAO,qBAAqB,kBAAkB,oBAAoB,MAAM,KAAK;AAC/E;AAGO,SAAS,qBAAqB,aAA2B;AAC9D,QAAM,aAAa,gBAAgB,IAAI,WAAW;AAClD,MAAI,CAAC,WAAY;AACjB,aAAW,MAAM;AACjB,kBAAgB,OAAO,WAAW;AAClC,cAAY;AACd;AAMA,eAAsB,cACpB,IACA,MACA,aACA,QAC8B;AAC9B,MAAI,UAAU;AACd,aAAW,CAAC,IAAIA,WAAU,KAAK,iBAAiB;AAC9C,QAAI,OAAO,YAAa;AACxB,IAAAA,YAAW,MAAM;AACjB,oBAAgB,OAAO,EAAE;AACzB,cAAU;AAAA,EACZ;AACA,MAAI,QAAS,aAAY;AAEzB,QAAM,aAAa,IAAI,gBAAgB;AACvC,UAAQ,iBAAiB,SAAS,MAAM,WAAW,MAAM,GAAG,EAAE,MAAM,KAAK,CAAC;AAG1E,QAAM,QAAQ,KAAK,UAAU,cAAc;AAAA,IACzC;AAAA,IACA,UAAU;AAAA,IACV,eAAe;AAAA,IACf,QAAQ,WAAW;AAAA,EACrB,CAAC;AACD,OAAK,gBAAgB;AACrB,QAAM,QAAQ,MAAM,MAAM,KAAK;AAC/B,QAAM,YAAY,MAAM,OAAO,CAAC,IAAI,MAAM;AAC1C,UAAQ,oBAAoB,gBAAgB;AAC5C,MAAI,MAAM,QAAQ,UAAU,SAAS,0BAA2B,QAAO;AACvE,MAAI,gBAAgB,IAAI,WAAW,GAAG;AACpC,eAAW,MAAM;AACjB,WAAO;AAAA,EACT;AAEA,kBAAgB,IAAI,aAAa,UAAU;AAC3C,cAAY;AACZ,OAAK,qBAAqB,IAAI,aAAa,OAAO,WAAW,MAAM,EAAE,QAAQ,MAAM;AACjF,QAAI,gBAAgB,IAAI,WAAW,MAAM,WAAY;AACrD,oBAAgB,OAAO,WAAW;AAClC,gBAAY;AAAA,EACd,CAAC;AACD,SAAO;AACT;AAEA,eAAe,qBACb,IACA,aACA,OACA,QACe;AAEf,QAAM,QAAQ,QAAQ;AACtB,MAAI;AACF,qBAAiB,QAAQ,OAAO;AAC9B,UAAI,OAAO,QAAS;AAEpB;AAAA,QACE;AAAA,QACA,CAAC,QAAQ;AACP,gBAAM,QAAQ,IAAI,IAAI,IAAI,IAAI,CAAC,QAAQ,IAAI,WAAW,CAAC;AACvD,gBAAM,QAAQ,KAAK,OAAO,CAAC,QAAQ,CAAC,MAAM,IAAI,IAAI,WAAW,CAAC;AAC9D,iBAAO,MAAM,SAAS,CAAC,GAAG,KAAK,GAAG,KAAK,IAAI;AAAA,QAC7C;AAAA,QACA;AAAA,MACF;AAAA,IACF;AAAA,EACF,SAAS,OAAO;AACd,QAAI,CAAC,OAAO,QAAS,SAAQ,MAAM,4BAA4B,WAAW,YAAY,KAAK;AAAA,EAC7F;AACF;AAGO,SAAS,gCAAsC;AACpD,aAAW,cAAc,gBAAgB,OAAO,EAAG,YAAW,MAAM;AACpE,kBAAgB,MAAM;AACtB,cAAY;AACd;",
+  "names": ["controller"]
+}