@arbidocs/react 0.5.111 → 0.5.112

package/dist/documents/pending-sync.js

@@ -0,0 +1,210 @@
+import { useCallback, useMemo, useState } from "react";
+import {
+  partialMatchKey,
+  useMutationState,
+  useQueryClient
+} from "@tanstack/react-query";
+import { create } from "zustand";
+import { arbiMutationKeys } from "../query-keys.js";
+import { isReplayableArbiMutation } from "../offline.js";
+import { useTags } from "../hooks.js";
+import { getDocumentTitle } from "../entities/index.js";
+import { useDocuments } from "./documents-data.js";
+import {
+  rollbackOptimisticDocumentEdit
+} from "./documents-writes.js";
+import { QUEUED_WRITE_BLOCKED_MESSAGE, isBlockedOnWorkspace } from "../queued-writes.js";
+const META_LABELS = {
+  title: "Title",
+  doc_date: "Date",
+  doc_nature: "Type",
+  doc_author: "Author",
+  doc_subject: "Abstract"
+};
+const KIND_BY_KEY = [
+  [arbiMutationKeys.updateDocuments(), "fields"],
+  [arbiMutationKeys.assignDocTags(), "assignTag"],
+  [arbiMutationKeys.removeDocTags(), "removeTag"],
+  [arbiMutationKeys.updateDocTag(), "noteTag"],
+  [arbiMutationKeys.createTag(), "createTag"]
+];
+function kindOf(mutationKey) {
+  return mutationKey ? KIND_BY_KEY.find(([key]) => partialMatchKey(mutationKey, key))?.[1] : void 0;
+}
+function statusOf(isPaused, status, blocked = false) {
+  if (status === "error") return "error";
+  return isPaused || blocked ? "queued" : "syncing";
+}
+function docIdsFromVariables(kind, variables) {
+  if (kind === "fields")
+    return (variables?.documents ?? []).map(
+      (d) => d.external_id
+    );
+  if (kind === "assignTag" || kind === "removeTag")
+    return variables?.docIds ?? [];
+  if (kind === "noteTag") {
+    const docId = variables?.docId;
+    return docId ? [docId] : [];
+  }
+  return [];
+}
+function prevDocsFrom(context) {
+  const edit = context;
+  if (!edit?.optimistic) return /* @__PURE__ */ new Map();
+  return new Map(edit.previous.map((doc) => [doc.external_id, doc]));
+}
+function describeDocEdit(variables, context) {
+  const first = variables?.documents?.[0];
+  if (!first) return "Edited document";
+  const prevDocs = prevDocsFrom(context);
+  if ("folder" in first) {
+    const folder = first.folder ?? null;
+    return folder ? `Moved to ${folder}` : "Removed from folder";
+  }
+  if ("shared" in first) return first.shared ? "Shared in chat" : "Removed from chat";
+  if ("labels" in first) return "Changed labels";
+  if ("doc_metadata" in first) {
+    const nextMeta = first.doc_metadata ?? {};
+    const prevMeta = prevDocs.get(first.external_id)?.doc_metadata ?? {};
+    const changed = [];
+    for (const [key, label] of Object.entries(META_LABELS)) {
+      const next = nextMeta[key] ?? "";
+      const prev = prevMeta[key] ?? "";
+      if (String(next) === String(prev)) continue;
+      changed.push(next ? `${label} \u2192 \u201C${String(next)}\u201D` : `${label} cleared`);
+    }
+    if (changed.length > 0) return changed.join(", ");
+    return "Edited details";
+  }
+  return "Edited document";
+}
+const TAG_VERBS = {
+  assignTag: "Applied",
+  removeTag: "Removed",
+  noteTag: "Edited the note on"
+};
+function describeChange(raw, tagNameById) {
+  const { kind, variables, context } = raw;
+  const verb = TAG_VERBS[kind];
+  if (verb) {
+    const tagId = variables?.tagId;
+    const tagName = tagId ? tagNameById.get(tagId) : void 0;
+    return tagName ? `${verb} tag \u201C${tagName}\u201D` : `${verb} a tag`;
+  }
+  if (kind === "createTag") {
+    const name = variables?.name;
+    return name ? `Created tag \u201C${name}\u201D` : "Created a tag";
+  }
+  return describeDocEdit(variables, context);
+}
+function buildPendingSyncItem(raw, docNameById, tagNameById) {
+  const docIds = docIdsFromVariables(raw.kind, raw.variables);
+  const names = docIds.map((id) => docNameById.get(id)).filter(Boolean);
+  const document = raw.kind === "createTag" ? "Workspace labels" : names.length > 0 ? names.join(", ") : docIds.length > 1 ? `${docIds.length} documents` : "A document";
+  return {
+    mutationId: raw.mutationId,
+    document,
+    change: describeChange(raw, tagNameById),
+    status: raw.status,
+    at: raw.at,
+    docIds,
+    ...raw.blocked ? { notice: QUEUED_WRITE_BLOCKED_MESSAGE } : {}
+  };
+}
+const PENDING_SYNC_PREDICATE = (m) => (
+  // Only real offline EDITS belong in the queue. An incidental paused mutation
+  // (e.g. POST /v1/workspace/{id}/open fired on an offline cold-boot) is not a
+  // user "change" and must not show as a phantom pending item.
+  //
+  // Gated on offline: a mutation only `isPaused` when React Query holds it back
+  // for being offline, so this is the natural "offline mode" gate. We
+  // deliberately do NOT count a plain in-flight (`status === 'pending'`) edit —
+  // that's just a normal ONLINE save mid-request, and counting it made rows
+  // flash "pending/syncing" while fully online. `error` is kept so a failed
+  // sync stays visible to review/undo.
+  // A write held back because its workspace can't be opened (tried again meanwhile) is waiting too.
+  isReplayableArbiMutation(m.options.mutationKey) && (m.state.isPaused || m.state.status === "error" || isBlockedOnWorkspace(m))
+);
+function usePendingSyncItems() {
+  const { data: documents } = useDocuments();
+  const { data: tags } = useTags();
+  const raw = useMutationState({
+    filters: { predicate: PENDING_SYNC_PREDICATE },
+    select: (m) => ({
+      mutationId: m.mutationId,
+      kind: kindOf(m.options.mutationKey) ?? "fields",
+      variables: m.state.variables,
+      context: m.state.context,
+      status: statusOf(m.state.isPaused, m.state.status, isBlockedOnWorkspace(m)),
+      at: m.state.submittedAt,
+      blocked: isBlockedOnWorkspace(m)
+    })
+  });
+  return useMemo(() => {
+    const docNameById = /* @__PURE__ */ new Map();
+    for (const doc of documents ?? [])
+      docNameById.set(doc.external_id, getDocumentTitle(doc, doc.file_name ?? ""));
+    const tagNameById = /* @__PURE__ */ new Map();
+    for (const tag of tags ?? []) tagNameById.set(tag.external_id, tag.name);
+    return raw.map((r) => buildPendingSyncItem(r, docNameById, tagNameById));
+  }, [raw, documents, tags]);
+}
+function usePendingSyncCounts() {
+  const statuses = useMutationState({
+    filters: { predicate: PENDING_SYNC_PREDICATE },
+    select: (m) => m.state.status === "error" ? "error" : "pending"
+  });
+  return useMemo(
+    () => ({ pending: statuses.length, failed: statuses.filter((s) => s === "error").length }),
+    [statuses]
+  );
+}
+function useCancelManyPendingSync() {
+  const queryClient = useQueryClient();
+  return useCallback(
+    (mutationIds) => {
+      const wanted = new Set(mutationIds);
+      const cache = queryClient.getMutationCache();
+      const undoable = cache.getAll().filter((m) => wanted.has(m.mutationId) && (m.state.isPaused || m.state.status === "error")).sort((a, b) => b.state.submittedAt - a.state.submittedAt);
+      for (const mutation of undoable) {
+        rollbackOptimisticDocumentEdit(queryClient, mutation.state.context);
+        cache.remove(mutation);
+      }
+    },
+    [queryClient]
+  );
+}
+const usePendingDocIds = create(() => ({ ids: /* @__PURE__ */ new Set() }));
+const watched = /* @__PURE__ */ new WeakSet();
+function sameSet(a, b) {
+  if (a.size !== b.size) return false;
+  for (const v of a) if (!b.has(v)) return false;
+  return true;
+}
+function watchPendingDocIds(queryClient) {
+  if (watched.has(queryClient)) return;
+  watched.add(queryClient);
+  const cache = queryClient.getMutationCache();
+  const update = () => {
+    const ids = new Set(
+      cache.findAll({ predicate: PENDING_SYNC_PREDICATE }).flatMap((m) => docIdsFromVariables(kindOf(m.options.mutationKey), m.state.variables))
+    );
+    if (!sameSet(usePendingDocIds.getState().ids, ids)) usePendingDocIds.setState({ ids });
+  };
+  update();
+  cache.subscribe(update);
+}
+function useDocumentPendingSync(docId) {
+  const queryClient = useQueryClient();
+  useState(() => watchPendingDocIds(queryClient));
+  return usePendingDocIds((s) => docId ? s.ids.has(docId) : false);
+}
+export {
+  PENDING_SYNC_PREDICATE,
+  buildPendingSyncItem,
+  useCancelManyPendingSync,
+  useDocumentPendingSync,
+  usePendingSyncCounts,
+  usePendingSyncItems
+};
+//# sourceMappingURL=pending-sync.js.map

package/dist/documents/pending-sync.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/documents/pending-sync.ts"],
+  "sourcesContent": ["/**\n * Changes made offline that wait to sync: the documents' writes held back by React Query while\n * offline (paused mutations, persisted by the host's query persister) or that failed when they\n * were replayed. What changed and where (`usePendingSyncItems`), how many (`usePendingSyncCounts`),\n * whether a document has one (`useDocumentPendingSync`), and undoing them before they reach the\n * server (`useCancelManyPendingSync`). These only read the mutation cache (plus the explicit\n * undo), so they never change how online writes behave.\n */\n\nimport { useCallback, useMemo, useState } from 'react'\nimport {\n  partialMatchKey,\n  useMutationState,\n  useQueryClient,\n  type Mutation,\n  type MutationKey,\n  type QueryClient,\n} from '@tanstack/react-query'\nimport { create } from 'zustand'\nimport { arbiMutationKeys } from '../query-keys'\nimport { isReplayableArbiMutation } from '../offline'\nimport { useTags } from '../hooks'\nimport { getDocumentTitle } from '../entities'\nimport { useDocuments } from './documents-data'\nimport {\n  rollbackOptimisticDocumentEdit,\n  type AssignDocTagsInput,\n  type OptimisticDocumentEdit,\n  type UpdateDocTagInput,\n  type UpdateDocumentsInput,\n} from './documents-writes'\nimport type { CreateTagInput } from '../tags'\nimport type { WorkspaceDocument } from './documents-cache'\nimport { QUEUED_WRITE_BLOCKED_MESSAGE, isBlockedOnWorkspace } from '../queued-writes'\n\ntype PendingStatus = 'queued' | 'syncing' | 'error'\n\nexport interface PendingSyncItem {\n  mutationId: number\n  /** Affected document name(s) \u2014 resolved, e.g. \"Exhibit R-007\". */\n  document: string\n  /** The exact change, in plain words \u2014 e.g. \"Moved to Contracts\", \"Title \u2192 \\\"X\\\"\". */\n  change: string\n  status: PendingStatus\n  /** When the change was made (ms epoch). */\n  at: number\n  docIds: string[]\n  /** Why it is held back, when it is: its workspace can't be opened, so it was not sent. */\n  notice?: string\n}\n\n/** Doc-metadata sub-fields the table can edit, with their display labels. */\nconst META_LABELS: Record<string, string> = {\n  title: 'Title',\n  doc_date: 'Date',\n  doc_nature: 'Type',\n  doc_author: 'Author',\n  doc_subject: 'Abstract',\n}\n\n/** Which queued write a pending change is. */\ntype PendingKind = 'fields' | 'assignTag' | 'removeTag' | 'noteTag' | 'createTag'\n\nconst KIND_BY_KEY: ReadonlyArray<readonly [MutationKey, PendingKind]> = [\n  [arbiMutationKeys.updateDocuments(), 'fields'],\n  [arbiMutationKeys.assignDocTags(), 'assignTag'],\n  [arbiMutationKeys.removeDocTags(), 'removeTag'],\n  [arbiMutationKeys.updateDocTag(), 'noteTag'],\n  [arbiMutationKeys.createTag(), 'createTag'],\n]\n\nfunction kindOf(mutationKey: MutationKey | undefined): PendingKind | undefined {\n  return mutationKey\n    ? KIND_BY_KEY.find(([key]) => partialMatchKey(mutationKey, key))?.[1]\n    : undefined\n}\n\n/** The raw projection pulled out of each pending mutation, before enrichment. */\nexport interface RawPending {\n  mutationId: number\n  kind: PendingKind\n  variables: unknown\n  context: unknown\n  status: PendingStatus\n  at: number\n  /** Not sent because its workspace can't be opened (retried, then kept). */\n  blocked?: boolean\n}\n\nfunction statusOf(isPaused: boolean, status: string, blocked = false): PendingStatus {\n  if (status === 'error') return 'error'\n  return isPaused || blocked ? 'queued' : 'syncing'\n}\n\n/** Pull the affected document ext_ids out of a mutation's input. */\nfunction docIdsFromVariables(kind: PendingKind | undefined, variables: unknown): string[] {\n  if (kind === 'fields')\n    return ((variables as UpdateDocumentsInput | undefined)?.documents ?? []).map(\n      (d) => d.external_id\n    )\n  if (kind === 'assignTag' || kind === 'removeTag')\n    return (variables as AssignDocTagsInput | undefined)?.docIds ?? []\n  if (kind === 'noteTag') {\n    const docId = (variables as UpdateDocTagInput | undefined)?.docId\n    return docId ? [docId] : []\n  }\n  return []\n}\n\n/** Map of docId \u2192 the pre-edit document, from a mutation's rollback snapshot. */\nfunction prevDocsFrom(context: unknown): Map<string, WorkspaceDocument> {\n  const edit = context as OptimisticDocumentEdit | undefined\n  if (!edit?.optimistic) return new Map()\n  return new Map(edit.previous.map((doc) => [doc.external_id, doc]))\n}\n\n/** Describe a single document-field edit by diffing the new values vs the snapshot. */\nfunction describeDocEdit(variables: unknown, context: unknown): string {\n  const first = (variables as UpdateDocumentsInput | undefined)?.documents?.[0] as\n    Record<string, unknown> | undefined\n  if (!first) return 'Edited document'\n  const prevDocs = prevDocsFrom(context)\n\n  // Top-level fields carry the value directly.\n  if ('folder' in first) {\n    const folder = (first.folder as string | null) ?? null\n    return folder ? `Moved to ${folder}` : 'Removed from folder'\n  }\n  if ('shared' in first) return first.shared ? 'Shared in chat' : 'Removed from chat'\n  if ('labels' in first) return 'Changed labels'\n\n  // doc_metadata edits: diff against the pre-edit snapshot to name the field(s).\n  if ('doc_metadata' in first) {\n    const nextMeta = (first.doc_metadata ?? {}) as Record<string, unknown>\n    const prevMeta = (prevDocs.get(first.external_id as string)?.doc_metadata ?? {}) as Record<\n      string,\n      unknown\n    >\n    const changed: string[] = []\n    for (const [key, label] of Object.entries(META_LABELS)) {\n      const next = nextMeta[key] ?? ''\n      const prev = prevMeta[key] ?? ''\n      if (String(next) === String(prev)) continue\n      changed.push(next ? `${label} \u2192 \u201C${String(next)}\u201D` : `${label} cleared`)\n    }\n    if (changed.length > 0) return changed.join(', ')\n    return 'Edited details'\n  }\n  return 'Edited document'\n}\n\nconst TAG_VERBS: Partial<Record<PendingKind, string>> = {\n  assignTag: 'Applied',\n  removeTag: 'Removed',\n  noteTag: 'Edited the note on',\n}\n\n/** A human change summary for one pending mutation. */\nfunction describeChange(raw: RawPending, tagNameById: Map<string, string>): string {\n  const { kind, variables, context } = raw\n  const verb = TAG_VERBS[kind]\n  if (verb) {\n    const tagId = (variables as { tagId?: string } | undefined)?.tagId\n    const tagName = tagId ? tagNameById.get(tagId) : undefined\n    return tagName ? `${verb} tag \u201C${tagName}\u201D` : `${verb} a tag`\n  }\n  if (kind === 'createTag') {\n    const name = (variables as CreateTagInput | undefined)?.name\n    return name ? `Created tag \u201C${name}\u201D` : 'Created a tag'\n  }\n  return describeDocEdit(variables, context)\n}\n\n/**\n * Pure enrichment: turn one raw pending mutation into a display item, resolving\n * the document name(s) and change summary from the supplied maps. Exported for\n * direct unit testing (the bug-prone part is name/change resolution, not the\n * thin useMutationState wiring around it).\n */\nexport function buildPendingSyncItem(\n  raw: RawPending,\n  docNameById: Map<string, string>,\n  tagNameById: Map<string, string>\n): PendingSyncItem {\n  const docIds = docIdsFromVariables(raw.kind, raw.variables)\n  const names = docIds.map((id) => docNameById.get(id)).filter(Boolean) as string[]\n  const document =\n    raw.kind === 'createTag'\n      ? 'Workspace labels'\n      : names.length > 0\n        ? names.join(', ')\n        : docIds.length > 1\n          ? `${docIds.length} documents`\n          : 'A document'\n  return {\n    mutationId: raw.mutationId,\n    document,\n    change: describeChange(raw, tagNameById),\n    status: raw.status,\n    at: raw.at,\n    docIds,\n    ...(raw.blocked ? { notice: QUEUED_WRITE_BLOCKED_MESSAGE } : {}),\n  }\n}\n\nexport const PENDING_SYNC_PREDICATE = (m: Mutation): boolean =>\n  // Only real offline EDITS belong in the queue. An incidental paused mutation\n  // (e.g. POST /v1/workspace/{id}/open fired on an offline cold-boot) is not a\n  // user \"change\" and must not show as a phantom pending item.\n  //\n  // Gated on offline: a mutation only `isPaused` when React Query holds it back\n  // for being offline, so this is the natural \"offline mode\" gate. We\n  // deliberately do NOT count a plain in-flight (`status === 'pending'`) edit \u2014\n  // that's just a normal ONLINE save mid-request, and counting it made rows\n  // flash \"pending/syncing\" while fully online. `error` is kept so a failed\n  // sync stays visible to review/undo.\n  // A write held back because its workspace can't be opened (tried again meanwhile) is waiting too.\n  isReplayableArbiMutation(m.options.mutationKey) &&\n  (m.state.isPaused || m.state.status === 'error' || isBlockedOnWorkspace(m))\n\n/**\n * Full, enriched list of unsynced writes for the offline-changes modal \u2014 newest\n * last, each with a resolved document name, the exact change, and a timestamp.\n * Resolves names from the live document + tag caches (reactively, so they fill\n * in as those load \u2014 unlike a one-shot cache read).\n */\nexport function usePendingSyncItems(): PendingSyncItem[] {\n  const { data: documents } = useDocuments()\n  const { data: tags } = useTags()\n\n  const raw = useMutationState<RawPending>({\n    filters: { predicate: PENDING_SYNC_PREDICATE },\n    select: (m) => ({\n      mutationId: m.mutationId,\n      kind: kindOf(m.options.mutationKey) ?? 'fields',\n      variables: m.state.variables,\n      context: m.state.context,\n      status: statusOf(m.state.isPaused, m.state.status, isBlockedOnWorkspace(m)),\n      at: m.state.submittedAt,\n      blocked: isBlockedOnWorkspace(m),\n    }),\n  })\n\n  return useMemo(() => {\n    const docNameById = new Map<string, string>()\n    for (const doc of documents ?? [])\n      docNameById.set(doc.external_id, getDocumentTitle(doc, doc.file_name ?? ''))\n    const tagNameById = new Map<string, string>()\n    for (const tag of tags ?? []) tagNameById.set(tag.external_id, tag.name)\n\n    return raw.map((r) => buildPendingSyncItem(r, docNameById, tagNameById))\n  }, [raw, documents, tags])\n}\n\n/** Cheap counts for the sidebar badge \u2014 no name resolution. */\nexport function usePendingSyncCounts(): { pending: number; failed: number } {\n  const statuses = useMutationState({\n    filters: { predicate: PENDING_SYNC_PREDICATE },\n    select: (m) => (m.state.status === 'error' ? 'error' : 'pending'),\n  })\n  return useMemo(\n    () => ({ pending: statuses.length, failed: statuses.filter((s) => s === 'error').length }),\n    [statuses]\n  )\n}\n\n/**\n * Cancel many changes at once. Rolls back newest-first so layered edits to the\n * same doc restore in LIFO order (matching how they'd replay). Only undoable\n * (queued/failed) mutations are touched \u2014 anything already syncing is left alone.\n */\nexport function useCancelManyPendingSync(): (mutationIds: number[]) => void {\n  const queryClient = useQueryClient()\n  return useCallback(\n    (mutationIds) => {\n      const wanted = new Set(mutationIds)\n      const cache = queryClient.getMutationCache()\n      const undoable = cache\n        .getAll()\n        .filter((m) => wanted.has(m.mutationId) && (m.state.isPaused || m.state.status === 'error'))\n        .sort((a, b) => b.state.submittedAt - a.state.submittedAt)\n      for (const mutation of undoable) {\n        rollbackOptimisticDocumentEdit(queryClient, mutation.state.context)\n        cache.remove(mutation)\n      }\n    },\n    [queryClient]\n  )\n}\n\n/** The documents with a change waiting to sync, kept from one watch of each query client. */\nconst usePendingDocIds = create<{ ids: ReadonlySet<string> }>(() => ({ ids: new Set() }))\nconst watched = new WeakSet<QueryClient>()\n\nfunction sameSet(a: ReadonlySet<string>, b: ReadonlySet<string>): boolean {\n  if (a.size !== b.size) return false\n  for (const v of a) if (!b.has(v)) return false\n  return true\n}\n\n/**\n * Watch a query client's mutation cache once, keeping the set of documents with a pending change:\n * a grid of thousands of status cells then reads one cheap boolean each instead of subscribing to\n * the mutation cache thousands of times.\n */\nfunction watchPendingDocIds(queryClient: QueryClient): void {\n  if (watched.has(queryClient)) return\n  watched.add(queryClient)\n  const cache = queryClient.getMutationCache()\n  const update = () => {\n    const ids = new Set(\n      cache\n        .findAll({ predicate: PENDING_SYNC_PREDICATE })\n        .flatMap((m) => docIdsFromVariables(kindOf(m.options.mutationKey), m.state.variables))\n    )\n    if (!sameSet(usePendingDocIds.getState().ids, ids)) usePendingDocIds.setState({ ids })\n  }\n  update()\n  cache.subscribe(update)\n}\n\n/** Whether a document has a change waiting to sync (a cheap boolean, for per-row status). */\nexport function useDocumentPendingSync(docId: string | null | undefined): boolean {\n  const queryClient = useQueryClient()\n  useState(() => watchPendingDocIds(queryClient))\n  return usePendingDocIds((s) => (docId ? s.ids.has(docId) : false))\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/documents/processing-live.js

@@ -0,0 +1,122 @@
+import { useEffect, useMemo, useState } from "react";
+import { useQueryClient } from "@tanstack/react-query";
+import { useArbi } from "../useArbi.js";
+import { useArbiWsStore } from "../websocket/store.js";
+import { getCachedDocuments, patchDocuments } from "./documents-cache.js";
+import { refreshDocuments } from "./documents-data.js";
+import { subscribeDocumentReads } from "./processing-settle.js";
+import { FINISHED_DOCUMENT_STATUSES, IN_FLIGHT_DOCUMENT_STATUSES } from "./processing-order.js";
+const STALE_TASK_MS = 6 * 60 * 60 * 1e3;
+const ORPHAN_TASK_MS = 15 * 60 * 1e3;
+const SNAPSHOT_MS = 500;
+function applyTaskEvent(queryClient, arbi, message, me) {
+  const workspaceId = message.workspace_ext_id;
+  if (!workspaceId) return;
+  if (FINISHED_DOCUMENT_STATUSES.has(message.status)) {
+    void refreshDocuments(queryClient, arbi, [message.doc_ext_id]);
+    return;
+  }
+  const cached = getCachedDocuments(queryClient, workspaceId);
+  if (!cached || cached.some((d) => d.external_id === message.doc_ext_id)) return;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const placeholder = {
+    external_id: message.doc_ext_id,
+    workspace_ext_id: workspaceId,
+    file_name: message.file_name ?? "Uploading\u2026",
+    status: message.status,
+    folder: message.folder ?? null,
+    wp_type: "source",
+    shared: false,
+    created_by_ext_id: me ?? void 0,
+    doc_metadata: {},
+    doctags: [],
+    created_at: now,
+    updated_at: now
+  };
+  patchDocuments(
+    queryClient,
+    (old) => old.some((d) => d.external_id === message.doc_ext_id) ? old : [...old, placeholder],
+    workspaceId
+  );
+}
+function useWorkspaceProcessing(workspaceId) {
+  const queryClient = useQueryClient();
+  const arbi = useArbi();
+  const [snapshot, setSnapshot] = useState(() => useArbiWsStore.getState().tasks);
+  useEffect(() => {
+    let timer = null;
+    const unsubscribe = useArbiWsStore.subscribe((state, previous) => {
+      if (state.tasks === previous.tasks || timer) return;
+      timer = setTimeout(() => {
+        timer = null;
+        setSnapshot(useArbiWsStore.getState().tasks);
+      }, SNAPSHOT_MS);
+    });
+    return () => {
+      unsubscribe();
+      if (timer) clearTimeout(timer);
+    };
+  }, []);
+  useEffect(() => {
+    if (!workspaceId) return;
+    const store = useArbiWsStore.getState();
+    const documents = getCachedDocuments(queryClient, workspaceId) ?? [];
+    store.settleTasks(documents);
+    const listed = new Set(documents.map((d) => d.external_id));
+    const now = Date.now();
+    for (const task of Object.values(useArbiWsStore.getState().tasks)) {
+      if (task.workspace_ext_id !== workspaceId || !IN_FLIGHT_DOCUMENT_STATUSES.has(task.status))
+        continue;
+      const since = task.startTime ?? task.endTime;
+      const age = since == null ? null : now - since;
+      const stale = age != null && age > STALE_TASK_MS;
+      const orphan = documents.length > 0 && !listed.has(task.doc_ext_id) && age != null && age > ORPHAN_TASK_MS;
+      if (stale || orphan) store.clearTask(task.doc_ext_id);
+    }
+  }, [workspaceId, queryClient]);
+  useEffect(() => {
+    if (!workspaceId) return;
+    const unsubscribeReads = subscribeDocumentReads(
+      queryClient,
+      (rows) => useArbiWsStore.getState().settleTasks(rows)
+    );
+    const recheck = async () => {
+      const ids = Object.values(useArbiWsStore.getState().tasks).filter(
+        (t) => t.workspace_ext_id === workspaceId && IN_FLIGHT_DOCUMENT_STATUSES.has(t.status)
+      ).map((t) => t.doc_ext_id);
+      if (ids.length) await refreshDocuments(queryClient, arbi, ids);
+    };
+    let wasConnected = useArbiWsStore.getState().status === "connected";
+    const unsubscribeStatus = useArbiWsStore.subscribe((state) => {
+      const connected = state.status === "connected";
+      if (connected && !wasConnected) void recheck();
+      wasConnected = connected;
+    });
+    return () => {
+      unsubscribeReads();
+      unsubscribeStatus();
+    };
+  }, [workspaceId, queryClient, arbi]);
+  return useMemo(() => {
+    const allTasks = workspaceId ? Object.values(snapshot).filter((t) => t.workspace_ext_id === workspaceId).sort((a, b) => a.doc_ext_id.localeCompare(b.doc_ext_id)) : [];
+    const count = (statuses) => allTasks.filter(
+      (t) => Array.isArray(statuses) ? statuses.includes(t.status) : statuses.has(t.status)
+    ).length;
+    const { clearTask, clearFinishedTasks } = useArbiWsStore.getState();
+    return {
+      tasks: Object.fromEntries(allTasks.map((t) => [t.doc_ext_id, t])),
+      allTasks,
+      processingCount: count(IN_FLIGHT_DOCUMENT_STATUSES),
+      completedCount: count(["completed", "low-content"]),
+      failedCount: count(["failed"]),
+      skippedCount: count(["skipped"]),
+      clearTask,
+      clearFinishedTasks
+    };
+  }, [workspaceId, snapshot]);
+}
+export {
+  applyTaskEvent,
+  useWorkspaceProcessing
+};
+//# sourceMappingURL=processing-live.js.map

package/dist/documents/processing-live.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/documents/processing-live.ts"],
+  "sourcesContent": ["/**\n * A workspace's documents in processing, live: what every site's file views show while uploads\n * and re-processing run.\n *\n * - `applyTaskEvent` (the provider runs it on each taken `task_update`): an upload appears as a\n *   row the moment it is queued (a light placeholder, so the table and the gallery show it with\n *   its live progress), and a finished document replaces its row with the one read afresh.\n * - `useWorkspaceProcessing(workspaceId)`: the workspace's processing rows and their counts\n *   (a snapshot every half second, so a batch upload does not re-render on every event), kept\n *   honest: stale or orphaned rows are dropped when the workspace opens, rows a document read says\n *   finished are settled, and the in-flight ones are re-checked when the connection comes back.\n */\n\nimport { useEffect, useMemo, useState } from 'react'\nimport { useQueryClient, type QueryClient } from '@tanstack/react-query'\nimport type { Arbi } from '@arbidocs/sdk/browser'\nimport type { WsTaskUpdateMessage } from '@arbidocs/client'\nimport { useArbi } from '../useArbi'\nimport { useArbiWsStore, type LiveTask } from '../websocket/store'\nimport { getCachedDocuments, patchDocuments } from './documents-cache'\nimport { refreshDocuments } from './documents-data'\nimport { subscribeDocumentReads } from './processing-settle'\nimport { FINISHED_DOCUMENT_STATUSES, IN_FLIGHT_DOCUMENT_STATUSES } from './processing-order'\nimport type { WorkspaceDocument } from './documents-cache'\n\n/** A row in flight longer than this is a zombie (its completion was lost): no real run takes it. */\nconst STALE_TASK_MS = 6 * 60 * 60 * 1000\n/** A row whose document is missing from a read list is an orphan only after this long. */\nconst ORPHAN_TASK_MS = 15 * 60 * 1000\n/** How often the workspace's rows are re-read into views while processing runs. */\nconst SNAPSHOT_MS = 500\n\n/** Apply one taken `task_update` to the documents list (`me`: who uploads, i.e. this user). */\nexport function applyTaskEvent(\n  queryClient: QueryClient,\n  arbi: Arbi,\n  message: WsTaskUpdateMessage & { folder?: string | null },\n  me: string | null | undefined\n): void {\n  const workspaceId = message.workspace_ext_id\n  if (!workspaceId) return\n  if (FINISHED_DOCUMENT_STATUSES.has(message.status)) {\n    // The finished document replaces its placeholder row and its own entry.\n    void refreshDocuments(queryClient, arbi, [message.doc_ext_id])\n    return\n  }\n  // Only once the list has been read: a placeholder must not stand in for the first read.\n  const cached = getCachedDocuments(queryClient, workspaceId)\n  if (!cached || cached.some((d) => d.external_id === message.doc_ext_id)) return\n  const now = new Date().toISOString()\n  // The fields the read document will carry, so the row passes the list's filters meanwhile.\n  const placeholder = {\n    external_id: message.doc_ext_id,\n    workspace_ext_id: workspaceId,\n    file_name: message.file_name ?? 'Uploading\u2026',\n    status: message.status,\n    folder: message.folder ?? null,\n    wp_type: 'source',\n    shared: false,\n    created_by_ext_id: me ?? undefined,\n    doc_metadata: {},\n    doctags: [],\n    created_at: now,\n    updated_at: now,\n  } as unknown as WorkspaceDocument\n  patchDocuments(\n    queryClient,\n    (old) => (old.some((d) => d.external_id === message.doc_ext_id) ? old : [...old, placeholder]),\n    workspaceId\n  )\n}\n\n/** The workspace's processing rows (in the order of their document ids) and their counts. */\nexport interface WorkspaceProcessing {\n  tasks: Record<string, LiveTask>\n  allTasks: LiveTask[]\n  processingCount: number\n  completedCount: number\n  failedCount: number\n  skippedCount: number\n  clearTask: (docId: string) => void\n  clearFinishedTasks: () => void\n}\n\nexport function useWorkspaceProcessing(workspaceId: string | undefined): WorkspaceProcessing {\n  const queryClient = useQueryClient()\n  const arbi = useArbi()\n  const [snapshot, setSnapshot] = useState(() => useArbiWsStore.getState().tasks)\n\n  useEffect(() => {\n    let timer: ReturnType<typeof setTimeout> | null = null\n    const unsubscribe = useArbiWsStore.subscribe((state, previous) => {\n      if (state.tasks === previous.tasks || timer) return\n      timer = setTimeout(() => {\n        timer = null\n        setSnapshot(useArbiWsStore.getState().tasks)\n      }, SNAPSHOT_MS)\n    })\n    return () => {\n      unsubscribe()\n      if (timer) clearTimeout(timer)\n    }\n  }, [])\n\n  // When the workspace opens: settle what its list says finished, and drop zombie rows (in flight\n  // for hours) and orphans (their document is gone from the read list).\n  useEffect(() => {\n    if (!workspaceId) return\n    const store = useArbiWsStore.getState()\n    const documents = getCachedDocuments(queryClient, workspaceId) ?? []\n    store.settleTasks(documents)\n    const listed = new Set(documents.map((d) => d.external_id))\n    const now = Date.now()\n    for (const task of Object.values(useArbiWsStore.getState().tasks)) {\n      if (task.workspace_ext_id !== workspaceId || !IN_FLIGHT_DOCUMENT_STATUSES.has(task.status))\n        continue\n      const since = task.startTime ?? task.endTime\n      const age = since == null ? null : now - since\n      const stale = age != null && age > STALE_TASK_MS\n      const orphan =\n        documents.length > 0 && !listed.has(task.doc_ext_id) && age != null && age > ORPHAN_TASK_MS\n      if (stale || orphan) store.clearTask(task.doc_ext_id)\n    }\n  }, [workspaceId, queryClient])\n\n  // Afterwards: every documents read settles the rows it shows finished, and a connection that\n  // comes back re-checks the in-flight ones (the events it missed are gone for good).\n  useEffect(() => {\n    if (!workspaceId) return\n    const unsubscribeReads = subscribeDocumentReads(queryClient, (rows) =>\n      useArbiWsStore.getState().settleTasks(rows)\n    )\n    const recheck = async () => {\n      const ids = Object.values(useArbiWsStore.getState().tasks)\n        .filter(\n          (t) => t.workspace_ext_id === workspaceId && IN_FLIGHT_DOCUMENT_STATUSES.has(t.status)\n        )\n        .map((t) => t.doc_ext_id)\n      if (ids.length) await refreshDocuments(queryClient, arbi, ids)\n    }\n    let wasConnected = useArbiWsStore.getState().status === 'connected'\n    const unsubscribeStatus = useArbiWsStore.subscribe((state) => {\n      const connected = state.status === 'connected'\n      if (connected && !wasConnected) void recheck()\n      wasConnected = connected\n    })\n    return () => {\n      unsubscribeReads()\n      unsubscribeStatus()\n    }\n  }, [workspaceId, queryClient, arbi])\n\n  return useMemo(() => {\n    const allTasks = workspaceId\n      ? Object.values(snapshot)\n          .filter((t) => t.workspace_ext_id === workspaceId)\n          .sort((a, b) => a.doc_ext_id.localeCompare(b.doc_ext_id))\n      : []\n    const count = (statuses: ReadonlySet<string> | string[]) =>\n      allTasks.filter((t) =>\n        Array.isArray(statuses) ? statuses.includes(t.status) : statuses.has(t.status)\n      ).length\n    const { clearTask, clearFinishedTasks } = useArbiWsStore.getState()\n    return {\n      tasks: Object.fromEntries(allTasks.map((t) => [t.doc_ext_id, t])),\n      allTasks,\n      processingCount: count(IN_FLIGHT_DOCUMENT_STATUSES),\n      completedCount: count(['completed', 'low-content']),\n      failedCount: count(['failed']),\n      skippedCount: count(['skipped']),\n      clearTask,\n      clearFinishedTasks,\n    }\n  }, [workspaceId, snapshot])\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/documents/processing-order.js

@@ -0,0 +1,59 @@
+const FINISHED_DOCUMENT_STATUSES = /* @__PURE__ */ new Set([
+  "completed",
+  "low-content",
+  "failed",
+  "skipped",
+  "empty"
+]);
+const IN_FLIGHT_DOCUMENT_STATUSES = /* @__PURE__ */ new Set([
+  "uploading",
+  "queued",
+  "parsing",
+  "encrypting",
+  "indexing",
+  "analysing"
+]);
+function ordered(value) {
+  return typeof value === "number";
+}
+function isStaleTaskUpdate(held, next) {
+  return !!held && ordered(held.seq) && ordered(next.seq) && next.seq <= held.seq;
+}
+function isRowNewer(row, task) {
+  if (!ordered(row.status_seq) || !ordered(task.seq)) return void 0;
+  return row.status_seq > task.seq;
+}
+function resolveDocumentStatus(row, task) {
+  const rowStatus = (row.status ?? "").toLowerCase();
+  const live = task?.status;
+  if (!task || !live) return rowStatus;
+  const rowNewer = isRowNewer(row, task);
+  if (rowNewer !== void 0) return rowNewer ? rowStatus || live : live;
+  if (IN_FLIGHT_DOCUMENT_STATUSES.has(live)) return live;
+  if (FINISHED_DOCUMENT_STATUSES.has(rowStatus)) return rowStatus;
+  return live;
+}
+function settledByRows(tasks, rows) {
+  const inFlight = /* @__PURE__ */ new Map();
+  for (const task of Object.values(tasks))
+    if (IN_FLIGHT_DOCUMENT_STATUSES.has(task.status)) inFlight.set(task.doc_ext_id, task);
+  if (!inFlight.size) return [];
+  const settled = [];
+  for (const row of rows) {
+    const task = inFlight.get(row.external_id);
+    if (!task) continue;
+    const rowStatus = (row.status ?? "").toLowerCase();
+    if (!FINISHED_DOCUMENT_STATUSES.has(rowStatus) || isRowNewer(row, task) === false) continue;
+    settled.push({ ...task, status: rowStatus, seq: row.status_seq ?? task.seq });
+  }
+  return settled;
+}
+export {
+  FINISHED_DOCUMENT_STATUSES,
+  IN_FLIGHT_DOCUMENT_STATUSES,
+  isRowNewer,
+  isStaleTaskUpdate,
+  resolveDocumentStatus,
+  settledByRows
+};
+//# sourceMappingURL=processing-order.js.map

package/dist/documents/processing-order.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/documents/processing-order.ts"],
+  "sourcesContent": ["/**\n * Which is newer: a document's live processing status or its row as last read?\n *\n * Every `task_update` carries `seq`, taken by the server from one sequence for all documents and\n * all of its instances, so a higher seq is a later event however the events arrive. A document row\n * carries `status_seq`: the seq of the last time its processing ended (a finished status written or\n * broadcast). The two compare:\n *  - an event at or below the seq of the one already held is stale (overtaken), and is dropped;\n *  - a row whose `status_seq` is above the live status's seq finished after it: the live status is\n *    over (its final event was lost), and the row wins;\n *  - a live status above the row's `status_seq` is newer than the row: the document is being\n *    processed again (AI fields being filled) although the row still says it finished.\n *\n * Without the seqs (an optimistic \"queued\" set here, a server before them) the older rule stands:\n * a live in-flight status wins, then a finished row, then whatever was heard live.\n */\n\n/** Statuses after which a document's processing is over (`low-content`: indexed, little text). */\nexport const FINISHED_DOCUMENT_STATUSES: ReadonlySet<string> = new Set([\n  'completed',\n  'low-content',\n  'failed',\n  'skipped',\n  'empty',\n])\n\n/** A live processing status and its order (`task_update.seq`). */\nexport interface SequencedTask {\n  status: string\n  seq?: number | null\n}\n\n/** A document row's status and the order of its last finished status (`status_seq`). */\nexport interface SequencedRow {\n  status?: string | null\n  status_seq?: number | null\n}\n\n/** Statuses of a document still being processed. */\nexport const IN_FLIGHT_DOCUMENT_STATUSES: ReadonlySet<string> = new Set([\n  'uploading',\n  'queued',\n  'parsing',\n  'encrypting',\n  'indexing',\n  'analysing',\n])\n\nfunction ordered(value: number | null | undefined): value is number {\n  return typeof value === 'number'\n}\n\n/** Whether `next` is older than (or the same event as) the live status already held. */\nexport function isStaleTaskUpdate(held: SequencedTask | undefined, next: SequencedTask): boolean {\n  return !!held && ordered(held.seq) && ordered(next.seq) && next.seq <= held.seq\n}\n\n/**\n * Whether the row is newer than the live status: `true` / `false` when both are ordered, `undefined`\n * when they cannot be compared.\n */\nexport function isRowNewer(row: SequencedRow, task: SequencedTask): boolean | undefined {\n  if (!ordered(row.status_seq) || !ordered(task.seq)) return undefined\n  return row.status_seq > task.seq\n}\n\n/** The status a document shows now: its row's, or the live one when that is newer. */\nexport function resolveDocumentStatus(row: SequencedRow, task: SequencedTask | undefined): string {\n  const rowStatus = (row.status ?? '').toLowerCase()\n  const live = task?.status\n  if (!task || !live) return rowStatus\n  const rowNewer = isRowNewer(row, task)\n  if (rowNewer !== undefined) return rowNewer ? rowStatus || live : live\n  if (IN_FLIGHT_DOCUMENT_STATUSES.has(live)) return live\n  if (FINISHED_DOCUMENT_STATUSES.has(rowStatus)) return rowStatus\n  return live\n}\n\n/**\n * The live statuses a read of `rows` ends: each in-flight one whose row has since finished. Ordered,\n * the row must be newer (so a reprocess the row predates keeps its progress); unordered, a finished\n * row is enough (the older rule). Returns each such task with the row's status and order. Cheap when\n * nothing is in flight (it runs on every read of a list).\n */\nexport function settledByRows<T extends SequencedTask & { doc_ext_id: string }>(\n  tasks: Readonly<Record<string, T>>,\n  rows: ReadonlyArray<SequencedRow & { external_id: string }>\n): T[] {\n  const inFlight = new Map<string, T>()\n  for (const task of Object.values(tasks))\n    if (IN_FLIGHT_DOCUMENT_STATUSES.has(task.status)) inFlight.set(task.doc_ext_id, task)\n  if (!inFlight.size) return []\n  const settled: T[] = []\n  for (const row of rows) {\n    const task = inFlight.get(row.external_id)\n    if (!task) continue\n    const rowStatus = (row.status ?? '').toLowerCase()\n    if (!FINISHED_DOCUMENT_STATUSES.has(rowStatus) || isRowNewer(row, task) === false) continue\n    settled.push({ ...task, status: rowStatus, seq: row.status_seq ?? task.seq })\n  }\n  return settled\n}\n"],
+  "mappings": "AAkBO,MAAM,6BAAkD,oBAAI,IAAI;AAAA,EACrE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,CAAC;AAeM,MAAM,8BAAmD,oBAAI,IAAI;AAAA,EACtE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,CAAC;AAED,SAAS,QAAQ,OAAmD;AAClE,SAAO,OAAO,UAAU;AAC1B;AAGO,SAAS,kBAAkB,MAAiC,MAA8B;AAC/F,SAAO,CAAC,CAAC,QAAQ,QAAQ,KAAK,GAAG,KAAK,QAAQ,KAAK,GAAG,KAAK,KAAK,OAAO,KAAK;AAC9E;AAMO,SAAS,WAAW,KAAmB,MAA0C;AACtF,MAAI,CAAC,QAAQ,IAAI,UAAU,KAAK,CAAC,QAAQ,KAAK,GAAG,EAAG,QAAO;AAC3D,SAAO,IAAI,aAAa,KAAK;AAC/B;AAGO,SAAS,sBAAsB,KAAmB,MAAyC;AAChG,QAAM,aAAa,IAAI,UAAU,IAAI,YAAY;AACjD,QAAM,OAAO,MAAM;AACnB,MAAI,CAAC,QAAQ,CAAC,KAAM,QAAO;AAC3B,QAAM,WAAW,WAAW,KAAK,IAAI;AACrC,MAAI,aAAa,OAAW,QAAO,WAAW,aAAa,OAAO;AAClE,MAAI,4BAA4B,IAAI,IAAI,EAAG,QAAO;AAClD,MAAI,2BAA2B,IAAI,SAAS,EAAG,QAAO;AACtD,SAAO;AACT;AAQO,SAAS,cACd,OACA,MACK;AACL,QAAM,WAAW,oBAAI,IAAe;AACpC,aAAW,QAAQ,OAAO,OAAO,KAAK;AACpC,QAAI,4BAA4B,IAAI,KAAK,MAAM,EAAG,UAAS,IAAI,KAAK,YAAY,IAAI;AACtF,MAAI,CAAC,SAAS,KAAM,QAAO,CAAC;AAC5B,QAAM,UAAe,CAAC;AACtB,aAAW,OAAO,MAAM;AACtB,UAAM,OAAO,SAAS,IAAI,IAAI,WAAW;AACzC,QAAI,CAAC,KAAM;AACX,UAAM,aAAa,IAAI,UAAU,IAAI,YAAY;AACjD,QAAI,CAAC,2BAA2B,IAAI,SAAS,KAAK,WAAW,KAAK,IAAI,MAAM,MAAO;AACnF,YAAQ,KAAK,EAAE,GAAG,MAAM,QAAQ,WAAW,KAAK,IAAI,cAAc,KAAK,IAAI,CAAC;AAAA,EAC9E;AACA,SAAO;AACT;",
+  "names": []
+}

package/dist/documents/processing-settle.js

@@ -0,0 +1,21 @@
+import { arbiQueryKeys } from "../hooks.js";
+function startsWith(key, prefix) {
+  return prefix.every((part, i) => key[i] === part);
+}
+function subscribeDocumentReads(qc, onRows) {
+  const lists = arbiQueryKeys.allDocuments();
+  const one = arbiQueryKeys.document("").slice(0, -1);
+  return qc.getQueryCache().subscribe((event) => {
+    if (event.type !== "updated" || event.action.type !== "success") return;
+    const key = event.query.queryKey;
+    const data = event.query.state.data;
+    if (key.length !== lists.length + 1) return;
+    if (startsWith(key, lists) && Array.isArray(data)) onRows(data);
+    else if (startsWith(key, one) && data && typeof data === "object" && !Array.isArray(data))
+      onRows([data]);
+  });
+}
+export {
+  subscribeDocumentReads
+};
+//# sourceMappingURL=processing-settle.js.map

package/dist/documents/processing-settle.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/documents/processing-settle.ts"],
+  "sourcesContent": ["/**\n * Every read of documents that lands in the caches (a workspace's list, one document: a viewer\n * re-reading it while it processes, a refresh after an event), as rows, so live processing can be\n * settled from whichever read comes first (`settledByRows`): a document whose final event was lost\n * stops showing as in progress as soon as any read of it says it finished after that.\n */\n\nimport type { QueryClient, QueryKey } from '@tanstack/react-query'\nimport { arbiQueryKeys } from '../hooks'\nimport type { WorkspaceDocument } from './documents-cache'\n\nfunction startsWith(key: QueryKey, prefix: QueryKey): boolean {\n  return prefix.every((part, i) => key[i] === part)\n}\n\n/** Call `onRows` with the documents each successful read or write of a documents cache holds. */\nexport function subscribeDocumentReads(\n  qc: QueryClient,\n  onRows: (rows: WorkspaceDocument[]) => void\n): () => void {\n  const lists = arbiQueryKeys.allDocuments()\n  const one = arbiQueryKeys.document('').slice(0, -1)\n  return qc.getQueryCache().subscribe((event) => {\n    if (event.type !== 'updated' || event.action.type !== 'success') return\n    const key = event.query.queryKey\n    const data: unknown = event.query.state.data\n    if (key.length !== lists.length + 1) return\n    if (startsWith(key, lists) && Array.isArray(data)) onRows(data as WorkspaceDocument[])\n    else if (startsWith(key, one) && data && typeof data === 'object' && !Array.isArray(data))\n      onRows([data as WorkspaceDocument])\n  })\n}\n"],
+  "mappings": "AAQA,SAAS,qBAAqB;AAG9B,SAAS,WAAW,KAAe,QAA2B;AAC5D,SAAO,OAAO,MAAM,CAAC,MAAM,MAAM,IAAI,CAAC,MAAM,IAAI;AAClD;AAGO,SAAS,uBACd,IACA,QACY;AACZ,QAAM,QAAQ,cAAc,aAAa;AACzC,QAAM,MAAM,cAAc,SAAS,EAAE,EAAE,MAAM,GAAG,EAAE;AAClD,SAAO,GAAG,cAAc,EAAE,UAAU,CAAC,UAAU;AAC7C,QAAI,MAAM,SAAS,aAAa,MAAM,OAAO,SAAS,UAAW;AACjE,UAAM,MAAM,MAAM,MAAM;AACxB,UAAM,OAAgB,MAAM,MAAM,MAAM;AACxC,QAAI,IAAI,WAAW,MAAM,SAAS,EAAG;AACrC,QAAI,WAAW,KAAK,KAAK,KAAK,MAAM,QAAQ,IAAI,EAAG,QAAO,IAA2B;AAAA,aAC5E,WAAW,KAAK,GAAG,KAAK,QAAQ,OAAO,SAAS,YAAY,CAAC,MAAM,QAAQ,IAAI;AACtF,aAAO,CAAC,IAAyB,CAAC;AAAA,EACtC,CAAC;AACH;",
+  "names": []
+}

package/dist/documents/related-documents.js

@@ -0,0 +1,133 @@
+import { useMemo, useRef } from "react";
+import { SIMILARITY_THRESHOLD, useSimilarDocuments } from "./documents-data.js";
+function getRelatedTotal(related) {
+  return (related.parent ? 1 : 0) + related.children.length + related.madeFrom.length + related.copies.length + related.duplicates.length + related.similar.length;
+}
+function getRelatedLabels(related) {
+  const parts = [];
+  if (related.parent) parts.push("1 parent");
+  if (related.children.length > 0) {
+    const n = related.children.length;
+    parts.push(`${n} ${n === 1 ? "attachment" : "attachments"}`);
+  }
+  if (related.madeFrom.length > 0) parts.push(`made from ${related.madeFrom.length}`);
+  if (related.copies.length > 0) {
+    const n = related.copies.length;
+    parts.push(`${n} ${n === 1 ? "copy" : "copies"}`);
+  }
+  if (related.duplicates.length > 0) {
+    const n = related.duplicates.length;
+    parts.push(`${n} ${n === 1 ? "duplicate" : "duplicates"}`);
+  }
+  if (related.similar.length > 0) {
+    const n = related.similar.length;
+    parts.push(`${n} similar`);
+  }
+  return parts;
+}
+function useRelatedDocuments(documents) {
+  const { data: similarData } = useSimilarDocuments();
+  const structuralKey = useMemo(() => {
+    const parts = [];
+    for (const doc of documents) {
+      parts.push(doc.external_id);
+      parts.push(doc.parent_ext_id || "");
+      parts.push(doc.content_hash || "");
+      parts.push(String(doc.current_version ?? 1));
+      for (const source of doc.derived_from ?? [])
+        parts.push(source.doc_ext_id, source.role, String(source.version ?? ""));
+    }
+    return parts.join("|");
+  }, [documents]);
+  const prevKeyRef = useRef(structuralKey);
+  const prevMapRef = useRef(/* @__PURE__ */ new Map());
+  const prevDocsRef = useRef(documents);
+  const prevSimilarRef = useRef(similarData);
+  return useMemo(() => {
+    if (prevKeyRef.current === structuralKey && prevSimilarRef.current === similarData && prevMapRef.current.size > 0 && prevDocsRef.current === documents) {
+      return prevMapRef.current;
+    }
+    prevKeyRef.current = structuralKey;
+    prevDocsRef.current = documents;
+    prevSimilarRef.current = similarData;
+    const map = /* @__PURE__ */ new Map();
+    const getOrCreate = (docId) => {
+      let entry = map.get(docId);
+      if (!entry) {
+        entry = { children: [], madeFrom: [], copies: [], roles: {}, duplicates: [], similar: [] };
+        map.set(docId, entry);
+      }
+      return entry;
+    };
+    const docById = /* @__PURE__ */ new Map();
+    for (const doc of documents) {
+      docById.set(doc.external_id, doc);
+    }
+    const byHash = /* @__PURE__ */ new Map();
+    for (const doc of documents) {
+      if (doc.content_hash) {
+        const list = byHash.get(doc.content_hash) || [];
+        list.push(doc);
+        byHash.set(doc.content_hash, list);
+      }
+    }
+    for (const doc of documents) {
+      if (doc.parent_ext_id) {
+        const parent = docById.get(doc.parent_ext_id);
+        if (parent) {
+          getOrCreate(doc.external_id).parent = parent;
+          getOrCreate(parent.external_id).children.push(doc);
+        }
+      }
+    }
+    for (const doc of documents) {
+      for (const source of doc.derived_from ?? []) {
+        const from = docById.get(source.doc_ext_id);
+        if (!from) continue;
+        const made = getOrCreate(doc.external_id);
+        made.madeFrom.push(from);
+        made.roles[from.external_id] = source.role;
+        if (source.version && source.version !== (from.current_version ?? 1)) {
+          made.versions = { ...made.versions, [from.external_id]: source.version };
+        }
+        const original = getOrCreate(from.external_id);
+        original.copies.push(doc);
+        original.roles[doc.external_id] = source.role;
+      }
+    }
+    for (const [, docs] of byHash) {
+      if (docs.length > 1) {
+        for (const doc of docs) {
+          getOrCreate(doc.external_id).duplicates = docs.filter(
+            (d) => d.external_id !== doc.external_id
+          );
+        }
+      }
+    }
+    if (similarData?.pairs) {
+      for (const pair of similarData.pairs) {
+        if (pair.similarity < SIMILARITY_THRESHOLD || pair.similarity >= 1) continue;
+        const docA = docById.get(pair.doc_a.external_id);
+        const docB = docById.get(pair.doc_b.external_id);
+        if (docA && docB) {
+          getOrCreate(docA.external_id).similar.push({
+            doc: docB,
+            similarity: pair.similarity
+          });
+          getOrCreate(docB.external_id).similar.push({
+            doc: docA,
+            similarity: pair.similarity
+          });
+        }
+      }
+    }
+    prevMapRef.current = map;
+    return map;
+  }, [documents, similarData, structuralKey]);
+}
+export {
+  getRelatedLabels,
+  getRelatedTotal,
+  useRelatedDocuments
+};
+//# sourceMappingURL=related-documents.js.map