@arbidocs/react 0.5.110 → 0.5.112

package/dist/artifacts/useArtifactSession.js

@@ -0,0 +1,173 @@
+import { useCallback, useMemo, useState } from "react";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { useArbi } from "../useArbi.js";
+import { arbiQueryKeys, useDocumentVersionList } from "../hooks.js";
+import { refreshDocuments, useDocuments } from "../documents/documents-data.js";
+import { useArtifactText } from "./useArtifactText.js";
+import {
+  documentVersions,
+  findVersion,
+  isDocumentId,
+  parseVersionRef,
+  toArtifactVersions,
+  versionLabel
+} from "./versions.js";
+import {
+  useArtifactEditSession
+} from "./useArtifactEditSession.js";
+function useArtifactVersions(workspaceId, docId) {
+  const plainId = docId ? parseVersionRef(docId).docId : null;
+  const { data: documents } = useDocuments(workspaceId);
+  const listed = useMemo(
+    () => (documents ?? []).find((d) => d.external_id === plainId),
+    [documents, plainId]
+  );
+  const { data: history } = useDocumentVersionList(plainId, {
+    enabled: !!plainId && documents !== void 0 && !listed
+  });
+  return useMemo(
+    () => listed ? documentVersions(listed) : toArtifactVersions(plainId, history),
+    [listed, history, plainId]
+  );
+}
+function useSaveArtifactVersion() {
+  const arbi = useArbi();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async ({ title, content, versionOf, configId, wpType }) => {
+      const fileName = /\.md$/i.test(title) ? title : `${title}.md`;
+      const result = await arbi.documents.uploadFile(
+        new Blob([content], { type: "text/markdown" }),
+        fileName,
+        {
+          wpType: wpType ?? "artifact",
+          versionOf: versionOf ? parseVersionRef(versionOf).docId : void 0,
+          configExtId: configId ?? void 0
+        }
+      );
+      const docId = result.doc_ext_ids?.[0];
+      if (docId) await refreshDocuments(queryClient, arbi, [docId]);
+      await queryClient.invalidateQueries({ queryKey: arbiQueryKeys.allDocumentVersions() });
+      if (docId)
+        await queryClient.invalidateQueries({ queryKey: arbiQueryKeys.parsedDocument(docId) });
+      return { docId, version: result.version ?? void 0 };
+    }
+  });
+}
+function useArtifactSession(options) {
+  const {
+    workspaceId,
+    docId: hostDocId,
+    draftContent,
+    title,
+    configId,
+    compareId,
+    onCompareChange,
+    onSaved,
+    ...passthrough
+  } = options;
+  const [saved, setSaved] = useState(null);
+  const adopted = saved && saved.forId === hostDocId ? saved : null;
+  const docId = adopted?.id ?? hostDocId;
+  const isLocal = !isDocumentId(docId);
+  const [ownCompareId, setOwnCompareId] = useState(null);
+  const activeCompareId = compareId === void 0 ? ownCompareId : compareId;
+  const changeCompare = useCallback(
+    (id) => {
+      setOwnCompareId(id);
+      onCompareChange?.(id);
+    },
+    [onCompareChange]
+  );
+  const { text, isLoading, status, retry } = useArtifactText(docId);
+  const versions = useArtifactVersions(workspaceId, isLocal ? null : docId);
+  const { text: compareText, isLoading: compareLoading } = useArtifactText(activeCompareId, {
+    enabled: !!activeCompareId
+  });
+  const saveVersion = useSaveArtifactVersion();
+  const current = findVersion(versions, docId);
+  const save = useCallback(
+    async (content) => {
+      const result = await saveVersion.mutateAsync({
+        title: title ?? current?.name ?? "Untitled",
+        content,
+        versionOf: isLocal ? null : docId,
+        configId
+      });
+      const latest = versions.reduce((n, v) => Math.max(n, v.number), 0);
+      return { ...result, version: result.version ?? (isLocal ? 1 : latest + 1) };
+    },
+    [saveVersion, title, current?.name, isLocal, docId, configId, versions]
+  );
+  const handleSaved = useCallback(
+    (result, content) => {
+      if (!isDocumentId(hostDocId) && result.docId)
+        setSaved({ forId: hostDocId, id: result.docId, text: content });
+      onSaved?.(result, content);
+    },
+    [hostDocId, onSaved]
+  );
+  const session = useArtifactEditSession({
+    ...passthrough,
+    docId,
+    // A local draft has only its own text; a just-saved one shows what was saved until the parsed
+    // text of the new document arrives.
+    baseline: text ?? (isLocal ? draftContent : adopted?.text),
+    savedFromId: current?.savedFromId,
+    compareId: activeCompareId,
+    onCompareChange: changeCompare,
+    compareText,
+    compareLoading,
+    save,
+    onSaved: handleSaved
+  });
+  const { redline } = session;
+  return useMemo(
+    () => ({
+      ...session,
+      docId,
+      isLocal,
+      isLoading,
+      status,
+      versions,
+      labelOf: (id) => versionLabel(versions, id),
+      view: {
+        content: session.baseline,
+        isEditing: session.isEditing,
+        hasChanges: session.hasChanges,
+        isSaving: session.isSaving,
+        canCompare: session.canCompare,
+        comparing: !!session.compareId,
+        compareId: session.compareId,
+        showTrackChanges: session.showTrackChanges,
+        versions,
+        currentVersionId: current?.id ?? docId ?? "",
+        onStartEdit: session.startEdit,
+        onCancel: session.cancel,
+        onSave: () => void session.save(),
+        onCompare: () => session.compare(),
+        onStopCompare: session.stopCompare,
+        onToggleTrackChanges: () => session.setShowTrackChanges(!session.showTrackChanges),
+        // A local draft has its text already: it is ready.
+        status: isLocal ? "ready" : status,
+        onRetry: retry
+      },
+      editorProps: {
+        markdown: session.content,
+        onChange: session.change,
+        onNormalized: session.normalized
+      },
+      redlineProps: {
+        state: redline.state,
+        onRevert: (regionId) => void session.revertRegion(regionId)
+      }
+    }),
+    [session, redline, isLoading, status, retry, isLocal, versions, docId]
+  );
+}
+export {
+  useArtifactSession,
+  useArtifactVersions,
+  useSaveArtifactVersion
+};
+//# sourceMappingURL=useArtifactSession.js.map

package/dist/artifacts/useArtifactSession.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/artifacts/useArtifactSession.ts"],
+  "sourcesContent": ["import { useCallback, useMemo, useState } from 'react'\nimport { useMutation, useQueryClient } from '@tanstack/react-query'\nimport { useArbi } from '../useArbi'\nimport { arbiQueryKeys, useDocumentVersionList } from '../hooks'\nimport { refreshDocuments, useDocuments } from '../documents/documents-data'\nimport { useArtifactText, type ArtifactTextStatus } from './useArtifactText'\nimport {\n  documentVersions,\n  findVersion,\n  isDocumentId,\n  parseVersionRef,\n  toArtifactVersions,\n  versionLabel,\n  type ArtifactVersion,\n} from './versions'\nimport {\n  useArtifactEditSession,\n  type ArtifactEditSession,\n  type ArtifactEditSessionOptions,\n  type ArtifactSaveResult,\n} from './useArtifactEditSession'\n\n/**\n * The versions of an artifact, oldest first. `docId` is a document id or a version reference\n * (`doc-\u2026@v2`). Every listed document carries its versions; a document that is not in the\n * workspace list asks for its version list.\n */\nexport function useArtifactVersions(\n  workspaceId: string | undefined,\n  docId: string | null | undefined\n): ArtifactVersion[] {\n  const plainId = docId ? parseVersionRef(docId).docId : null\n  const { data: documents } = useDocuments(workspaceId)\n  const listed = useMemo(\n    () => (documents ?? []).find((d) => d.external_id === plainId),\n    [documents, plainId]\n  )\n  // Asked only once the list has loaded and the document is not in it.\n  const { data: history } = useDocumentVersionList(plainId, {\n    enabled: !!plainId && documents !== undefined && !listed,\n  })\n  return useMemo(\n    () => (listed ? documentVersions(listed) : toArtifactVersions(plainId, history)),\n    [listed, history, plainId]\n  )\n}\n\nexport interface SaveArtifactVersionInput {\n  /** File name of the new version (`.md` is added when missing). */\n  title: string\n  content: string\n  /** Save as the next version of this document (it keeps its id); omit for a new document. */\n  versionOf?: string | null\n  /** The processing config (auto-title, parsing) to run the upload with. */\n  configId?: string | null\n  /** `artifact` (default) for AI-style drafts; `source` for a document the user typed. */\n  wpType?: 'artifact' | 'source'\n}\n\n/**\n * Save markdown as a NEW immutable version (the next version of `versionOf`'s document, which keeps\n * its id) and refresh the workspace document list, version lists and the document's text.\n */\nexport function useSaveArtifactVersion() {\n  const arbi = useArbi()\n  const queryClient = useQueryClient()\n  return useMutation<ArtifactSaveResult, Error, SaveArtifactVersionInput>({\n    mutationFn: async ({ title, content, versionOf, configId, wpType }) => {\n      // The backend classifies uploads by extension: a title without one is silently dropped.\n      const fileName = /\\.md$/i.test(title) ? title : `${title}.md`\n      const result = await arbi.documents.uploadFile(\n        new Blob([content], { type: 'text/markdown' }),\n        fileName,\n        {\n          wpType: wpType ?? 'artifact',\n          versionOf: versionOf ? parseVersionRef(versionOf).docId : undefined,\n          configExtId: configId ?? undefined,\n        }\n      )\n      const docId = result.doc_ext_ids?.[0]\n      // The document's row moves to the new version (its version lists re-read with it).\n      if (docId) await refreshDocuments(queryClient, arbi, [docId])\n      await queryClient.invalidateQueries({ queryKey: arbiQueryKeys.allDocumentVersions() })\n      // The document's current text is the new version's now.\n      if (docId)\n        await queryClient.invalidateQueries({ queryKey: arbiQueryKeys.parsedDocument(docId) })\n      return { docId, version: result.version ?? undefined }\n    },\n  })\n}\n\nexport interface ArtifactSessionOptions extends Pick<\n  ArtifactEditSessionOptions,\n  | 'onSaved'\n  | 'onSaveError'\n  | 'onCompareChange'\n  | 'compareId'\n  | 'compareOpensEditor'\n  | 'redlineEngine'\n  | 'onDirtyChange'\n> {\n  workspaceId: string | undefined\n  /**\n   * The open document (its current version), a version reference `doc-\u2026@v{n}`, or the placeholder\n   * id of an unsaved local draft (anything that is not a backend document id, i.e. does not start\n   * with `doc`).\n   */\n  docId: string | null | undefined\n  /**\n   * The text of a local draft (nothing is fetched for it). The FIRST save uploads it as a real\n   * document with no parent and the session switches to the new id; later saves chain from it.\n   */\n  draftContent?: string\n  /** Name for saved versions. Defaults to the open version's file name, else \"Untitled\". */\n  title?: string\n  /** Processing config for saved versions. */\n  configId?: string | null\n}\n\n/** Everything `ArtifactEditor` (`@arbidocs/blocks/artifacts`) takes from a session, flat. */\nexport interface ArtifactSessionView {\n  content: string\n  isEditing: boolean\n  hasChanges: boolean\n  isSaving: boolean\n  canCompare: boolean\n  comparing: boolean\n  compareId: string | null\n  showTrackChanges: boolean\n  versions: ArtifactVersion[]\n  currentVersionId: string\n  onStartEdit: () => void\n  onCancel: () => void\n  onSave: () => void\n  onCompare: () => void\n  onStopCompare: () => void\n  onToggleTrackChanges: () => void\n  /**\n   * Whether the text is ready. `ArtifactEditor` renders \"Preparing editor...\" while it is\n   * `loading` or `parsing` (a fresh upload is parsed for a few seconds) and an error with Retry.\n   */\n  status: ArtifactTextStatus\n  /** Ask for the text again after an `error`. */\n  onRetry: () => void\n}\n\nexport interface ArtifactSession extends ArtifactEditSession {\n  /** The open document: the new real id once a local draft has been saved. */\n  docId: string | null | undefined\n  /** The open version is an unsaved local draft (no backend document yet). */\n  isLocal: boolean\n  isLoading: boolean\n  /** See `ArtifactTextStatus`. */\n  status: ArtifactTextStatus\n  versions: ArtifactVersion[]\n  /** \"v2\" for any version (reference) of the document. */\n  labelOf: (id: string | null | undefined) => string | null\n  /** Props for `<ArtifactEditor>`. */\n  view: ArtifactSessionView\n  /** Props for `<ArtifactMarkdownEditor>` (`@arbidocs/blocks/artifacts/editor`). */\n  editorProps: {\n    markdown: string\n    onChange: (markdown: string) => void\n    onNormalized: (markdown: string) => void\n  }\n  /** Props for `<ArtifactRedlineView>`. */\n  redlineProps: {\n    state: ArtifactEditSession['redline']['state']\n    onRevert: (regionId: string) => void\n  }\n}\n\n/**\n * Edit an artifact through the SDK: load it, edit it, save it as a new version, list its versions\n * and compare any two with track changes. Needs an `<ArbiHost>` with an `arbi` and a selected workspace.\n *\n * ```tsx\n * const session = useArtifactSession({ workspaceId, docId, onSaved: ({ docId }) => docId && open(docId) })\n * <ArtifactEditor {...session.view} onOpenVersion={open}\n *   editor={<ArtifactMarkdownEditor {...session.editorProps} />}\n *   redline={<ArtifactRedlineView {...session.redlineProps} />} />\n * ```\n */\nexport function useArtifactSession(options: ArtifactSessionOptions): ArtifactSession {\n  const {\n    workspaceId,\n    docId: hostDocId,\n    draftContent,\n    title,\n    configId,\n    compareId,\n    onCompareChange,\n    onSaved,\n    ...passthrough\n  } = options\n  // A saved local draft becomes this real document; another host docId resets it.\n  const [saved, setSaved] = useState<{\n    forId: string | null | undefined\n    id: string\n    text: string\n  } | null>(null)\n  const adopted = saved && saved.forId === hostDocId ? saved : null\n  const docId = adopted?.id ?? hostDocId\n  const isLocal = !isDocumentId(docId)\n\n  // Owned here (not in the edit session) because the compare target's text must be loaded first.\n  const [ownCompareId, setOwnCompareId] = useState<string | null>(null)\n  const activeCompareId = compareId === undefined ? ownCompareId : compareId\n  const changeCompare = useCallback(\n    (id: string | null) => {\n      setOwnCompareId(id)\n      onCompareChange?.(id)\n    },\n    [onCompareChange]\n  )\n\n  const { text, isLoading, status, retry } = useArtifactText(docId)\n  const versions = useArtifactVersions(workspaceId, isLocal ? null : docId)\n  const { text: compareText, isLoading: compareLoading } = useArtifactText(activeCompareId, {\n    enabled: !!activeCompareId,\n  })\n  const saveVersion = useSaveArtifactVersion()\n  const current = findVersion(versions, docId)\n\n  const save = useCallback(\n    async (content: string) => {\n      const result = await saveVersion.mutateAsync({\n        title: title ?? current?.name ?? 'Untitled',\n        content,\n        versionOf: isLocal ? null : docId,\n        configId,\n      })\n      const latest = versions.reduce((n, v) => Math.max(n, v.number), 0)\n      return { ...result, version: result.version ?? (isLocal ? 1 : latest + 1) }\n    },\n    [saveVersion, title, current?.name, isLocal, docId, configId, versions]\n  )\n\n  const handleSaved = useCallback(\n    (result: ArtifactSaveResult, content: string) => {\n      // A host that keeps passing the local draft's placeholder id: follow every save to the real\n      // document it created (the first save creates version 1, later ones chain from it).\n      if (!isDocumentId(hostDocId) && result.docId)\n        setSaved({ forId: hostDocId, id: result.docId, text: content })\n      onSaved?.(result, content)\n    },\n    [hostDocId, onSaved]\n  )\n\n  const session = useArtifactEditSession({\n    ...passthrough,\n    docId,\n    // A local draft has only its own text; a just-saved one shows what was saved until the parsed\n    // text of the new document arrives.\n    baseline: text ?? (isLocal ? draftContent : adopted?.text),\n    savedFromId: current?.savedFromId,\n    compareId: activeCompareId,\n    onCompareChange: changeCompare,\n    compareText,\n    compareLoading,\n    save,\n    onSaved: handleSaved,\n  })\n\n  const { redline } = session\n  return useMemo<ArtifactSession>(\n    () => ({\n      ...session,\n      docId,\n      isLocal,\n      isLoading,\n      status,\n      versions,\n      labelOf: (id) => versionLabel(versions, id),\n      view: {\n        content: session.baseline,\n        isEditing: session.isEditing,\n        hasChanges: session.hasChanges,\n        isSaving: session.isSaving,\n        canCompare: session.canCompare,\n        comparing: !!session.compareId,\n        compareId: session.compareId,\n        showTrackChanges: session.showTrackChanges,\n        versions,\n        currentVersionId: current?.id ?? docId ?? '',\n        onStartEdit: session.startEdit,\n        onCancel: session.cancel,\n        onSave: () => void session.save(),\n        onCompare: () => session.compare(),\n        onStopCompare: session.stopCompare,\n        onToggleTrackChanges: () => session.setShowTrackChanges(!session.showTrackChanges),\n        // A local draft has its text already: it is ready.\n        status: isLocal ? 'ready' : status,\n        onRetry: retry,\n      },\n      editorProps: {\n        markdown: session.content,\n        onChange: session.change,\n        onNormalized: session.normalized,\n      },\n      redlineProps: {\n        state: redline.state,\n        onRevert: (regionId) => void session.revertRegion(regionId),\n      },\n    }),\n    [session, redline, isLoading, status, retry, isLocal, versions, docId]\n  )\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/artifacts/useArtifactSource.js

@@ -0,0 +1,16 @@
+import { useQuery } from "@tanstack/react-query";
+import { useArbi } from "../useArbi.js";
+import { arbiQueryKeys } from "../query-keys.js";
+function useArtifactSource(documentId, enabled = true) {
+  const arbi = useArbi();
+  return useQuery({
+    queryKey: arbiQueryKeys.artifactSource(documentId ?? ""),
+    queryFn: async () => (await arbi.documents.download(documentId)).text(),
+    enabled: enabled && !!documentId && arbi.isLoggedIn,
+    staleTime: 5 * 60 * 1e3
+  });
+}
+export {
+  useArtifactSource
+};
+//# sourceMappingURL=useArtifactSource.js.map

package/dist/artifacts/useArtifactSource.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/artifacts/useArtifactSource.ts"],
+  "sourcesContent": ["import { useQuery } from '@tanstack/react-query'\nimport { useArbi } from '../useArbi'\nimport { arbiQueryKeys } from '../query-keys'\n\n/**\n * The stored source of a live artifact (the `.html` / `.jsx` file itself; the parsed text strips\n * it). `undefined` until it has loaded.\n */\nexport function useArtifactSource(documentId: string | null | undefined, enabled = true) {\n  const arbi = useArbi()\n  return useQuery({\n    queryKey: arbiQueryKeys.artifactSource(documentId ?? ''),\n    queryFn: async () => (await arbi.documents.download(documentId as string)).text(),\n    enabled: enabled && !!documentId && arbi.isLoggedIn,\n    staleTime: 5 * 60 * 1000,\n  })\n}\n"],
+  "mappings": "AAAA,SAAS,gBAAgB;AACzB,SAAS,eAAe;AACxB,SAAS,qBAAqB;AAMvB,SAAS,kBAAkB,YAAuC,UAAU,MAAM;AACvF,QAAM,OAAO,QAAQ;AACrB,SAAO,SAAS;AAAA,IACd,UAAU,cAAc,eAAe,cAAc,EAAE;AAAA,IACvD,SAAS,aAAa,MAAM,KAAK,UAAU,SAAS,UAAoB,GAAG,KAAK;AAAA,IAChF,SAAS,WAAW,CAAC,CAAC,cAAc,KAAK;AAAA,IACzC,WAAW,IAAI,KAAK;AAAA,EACtB,CAAC;AACH;",
+  "names": []
+}

package/dist/artifacts/useArtifactText.js

@@ -0,0 +1,78 @@
+import { useCallback, useMemo } from "react";
+import { useQuery } from "@tanstack/react-query";
+import { useArbi } from "../useArbi.js";
+import { arbiQueryKeys } from "../hooks.js";
+import { flattenChunks, isDocumentId, parseVersionRef } from "./versions.js";
+const DEFAULT_ARTIFACT_TEXT_RETRY = {
+  attempts: 12,
+  baseDelayMs: 1e3,
+  maxDelayMs: 5e3
+};
+class NotParsedYetError extends Error {
+  constructor() {
+    super("The document has no parsed text yet");
+  }
+}
+const isRefusal = (error) => {
+  const status = error;
+  const code = status?.status ?? status?.response?.status;
+  return code === 401 || code === 403;
+};
+function useArtifactText(docId, options) {
+  const arbi = useArbi();
+  const { attempts, baseDelayMs, maxDelayMs } = {
+    ...DEFAULT_ARTIFACT_TEXT_RETRY,
+    ...options?.retry
+  };
+  const enabled = (options?.enabled ?? true) && isDocumentId(docId) && arbi.hasWorkspace;
+  const query = useQuery({
+    // Under the shared `parsedDoc` key, so a document's invalidation reaches it too.
+    queryKey: [...arbiQueryKeys.parsedDoc(docId ?? "", "marker"), "artifact-text"],
+    queryFn: async () => {
+      const { docId: plainId, version } = parseVersionRef(docId);
+      const parsed = await arbi.documents.getParsedContent(
+        plainId,
+        "marker",
+        version ?? void 0
+      );
+      if (!parsed.chunks?.some((c) => c.content?.trim())) throw new NotParsedYetError();
+      return flattenChunks(parsed.chunks, { unescape: true });
+    },
+    enabled,
+    retry: (failureCount, error) => !isRefusal(error) && failureCount < attempts,
+    retryDelay: (failureCount) => Math.min(baseDelayMs * 1.6 ** failureCount, maxDelayMs)
+  });
+  const { refetch } = query;
+  const retry = useCallback(() => void refetch(), [refetch]);
+  return useMemo(() => {
+    const error = query.error;
+    const neverParsed = error instanceof NotParsedYetError;
+    let status = "loading";
+    if (!enabled) status = "loading";
+    else if (query.isSuccess || query.isError && neverParsed) status = "ready";
+    else if (query.isError) status = "error";
+    else if (query.failureCount > 0) status = "parsing";
+    const text = !enabled ? void 0 : query.isSuccess ? query.data : status === "ready" || status === "error" ? null : void 0;
+    return {
+      text,
+      isLoading: enabled && (status === "loading" || status === "parsing"),
+      status,
+      error: status === "ready" ? null : error ?? query.failureReason ?? null,
+      retry
+    };
+  }, [
+    enabled,
+    query.isSuccess,
+    query.isError,
+    query.data,
+    query.error,
+    query.failureCount,
+    query.failureReason,
+    retry
+  ]);
+}
+export {
+  DEFAULT_ARTIFACT_TEXT_RETRY,
+  useArtifactText
+};
+//# sourceMappingURL=useArtifactText.js.map

package/dist/artifacts/useArtifactText.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/artifacts/useArtifactText.ts"],
+  "sourcesContent": ["import { useCallback, useMemo } from 'react'\nimport { useQuery } from '@tanstack/react-query'\nimport { useArbi } from '../useArbi'\nimport { arbiQueryKeys } from '../hooks'\nimport { flattenChunks, isDocumentId, parseVersionRef } from './versions'\n\n/**\n * Where the text of a stored artifact is:\n *  - `loading`: the first request is in flight (or there is no document yet);\n *  - `parsing`: the backend has not finished parsing the upload (the endpoint answers 404, 422 or\n *    500, or an empty parse, for a few seconds after an upload) and the hook is retrying;\n *  - `ready`: the text is here (an empty document is `ready` with `text: null`);\n *  - `error`: the retries ran out, or the request was refused (401/403).\n */\nexport type ArtifactTextStatus = 'loading' | 'parsing' | 'ready' | 'error'\n\n/** How long `useArtifactText` keeps asking while a document is still being parsed. */\nexport interface ArtifactTextRetry {\n  /** Retries after the first request. Default 12. */\n  attempts?: number\n  /** Delay before the first retry; it grows by 1.6x each time. Default 1000 ms. */\n  baseDelayMs?: number\n  /** Cap for one delay. Default 5000 ms (12 retries are about 50 s in all). */\n  maxDelayMs?: number\n}\n\nexport const DEFAULT_ARTIFACT_TEXT_RETRY: Required<ArtifactTextRetry> = {\n  attempts: 12,\n  baseDelayMs: 1000,\n  maxDelayMs: 5000,\n}\n\n/** Thrown inside the query when the parse has no text yet, so that it is retried like a 500. */\nclass NotParsedYetError extends Error {\n  constructor() {\n    super('The document has no parsed text yet')\n  }\n}\n\nconst isRefusal = (error: unknown): boolean => {\n  const status = error as { status?: number; response?: { status?: number } } | null\n  const code = status?.status ?? status?.response?.status\n  return code === 401 || code === 403\n}\n\nexport interface ArtifactText {\n  /**\n   * The markdown, clean: `undefined` while `loading` or `parsing`, `null` when there is none (an\n   * empty document, or `error`).\n   */\n  text: string | null | undefined\n  /** `status` is `loading` or `parsing`. */\n  isLoading: boolean\n  status: ArtifactTextStatus\n  /** The last request error while `parsing` or after `error`. */\n  error: Error | null\n  /** Ask again now (after an `error`). */\n  retry: () => void\n}\n\n/**\n * The saved markdown of an artifact version (its parsed chunks, joined and unescaped).\n *\n * A freshly uploaded document is parsed asynchronously, and for roughly 3 to 20 seconds the parsed\n * content endpoint answers 404, 422 or 500 (or an empty parse). The hook therefore retries with a\n * growing delay (see `ArtifactTextRetry`) and reports `status: 'parsing'` meanwhile, so a host can\n * show \"Preparing editor...\" instead of opening an editor on an empty baseline. After the last\n * retry the status is `error`; `retry()` starts a new round.\n *\n * The text is run through `unescapeMarkdown`: an artifact is always stored from markdown, and the\n * backend's parse of a `.md` escapes its punctuation.\n */\nexport function useArtifactText(\n  docId: string | null | undefined,\n  options?: { enabled?: boolean; retry?: ArtifactTextRetry }\n): ArtifactText {\n  const arbi = useArbi()\n  const { attempts, baseDelayMs, maxDelayMs } = {\n    ...DEFAULT_ARTIFACT_TEXT_RETRY,\n    ...options?.retry,\n  }\n  // A local draft (placeholder id) has no backend document: asking for its text would be a 422.\n  const enabled = (options?.enabled ?? true) && isDocumentId(docId) && arbi.hasWorkspace\n  const query = useQuery({\n    // Under the shared `parsedDoc` key, so a document's invalidation reaches it too.\n    queryKey: [...arbiQueryKeys.parsedDoc(docId ?? '', 'marker'), 'artifact-text'] as const,\n    queryFn: async () => {\n      // A version reference (`doc-\u2026@v2`) reads that version; a plain id the current one.\n      const { docId: plainId, version } = parseVersionRef(docId)\n      const parsed = (await arbi.documents.getParsedContent(\n        plainId,\n        'marker',\n        version ?? undefined\n      )) as {\n        chunks?: { content?: string | null }[]\n      }\n      if (!parsed.chunks?.some((c) => c.content?.trim())) throw new NotParsedYetError()\n      return flattenChunks(parsed.chunks, { unescape: true })\n    },\n    enabled,\n    retry: (failureCount, error) => !isRefusal(error) && failureCount < attempts,\n    retryDelay: (failureCount) => Math.min(baseDelayMs * 1.6 ** failureCount, maxDelayMs),\n  })\n\n  const { refetch } = query\n  const retry = useCallback(() => void refetch(), [refetch])\n\n  return useMemo<ArtifactText>(() => {\n    const error = query.error\n    const neverParsed = error instanceof NotParsedYetError\n    let status: ArtifactTextStatus = 'loading'\n    if (!enabled) status = 'loading'\n    else if (query.isSuccess || (query.isError && neverParsed)) status = 'ready'\n    else if (query.isError) status = 'error'\n    else if (query.failureCount > 0) status = 'parsing'\n    const text = !enabled\n      ? undefined\n      : query.isSuccess\n        ? query.data\n        : status === 'ready' || status === 'error'\n          ? null\n          : undefined\n    return {\n      text,\n      isLoading: enabled && (status === 'loading' || status === 'parsing'),\n      status,\n      error: status === 'ready' ? null : (error ?? query.failureReason ?? null),\n      retry,\n    }\n  }, [\n    enabled,\n    query.isSuccess,\n    query.isError,\n    query.data,\n    query.error,\n    query.failureCount,\n    query.failureReason,\n    retry,\n  ])\n}\n"],
+  "mappings": "AAAA,SAAS,aAAa,eAAe;AACrC,SAAS,gBAAgB;AACzB,SAAS,eAAe;AACxB,SAAS,qBAAqB;AAC9B,SAAS,eAAe,cAAc,uBAAuB;AAsBtD,MAAM,8BAA2D;AAAA,EACtE,UAAU;AAAA,EACV,aAAa;AAAA,EACb,YAAY;AACd;AAGA,MAAM,0BAA0B,MAAM;AAAA,EACpC,cAAc;AACZ,UAAM,qCAAqC;AAAA,EAC7C;AACF;AAEA,MAAM,YAAY,CAAC,UAA4B;AAC7C,QAAM,SAAS;AACf,QAAM,OAAO,QAAQ,UAAU,QAAQ,UAAU;AACjD,SAAO,SAAS,OAAO,SAAS;AAClC;AA6BO,SAAS,gBACd,OACA,SACc;AACd,QAAM,OAAO,QAAQ;AACrB,QAAM,EAAE,UAAU,aAAa,WAAW,IAAI;AAAA,IAC5C,GAAG;AAAA,IACH,GAAG,SAAS;AAAA,EACd;AAEA,QAAM,WAAW,SAAS,WAAW,SAAS,aAAa,KAAK,KAAK,KAAK;AAC1E,QAAM,QAAQ,SAAS;AAAA;AAAA,IAErB,UAAU,CAAC,GAAG,cAAc,UAAU,SAAS,IAAI,QAAQ,GAAG,eAAe;AAAA,IAC7E,SAAS,YAAY;AAEnB,YAAM,EAAE,OAAO,SAAS,QAAQ,IAAI,gBAAgB,KAAK;AACzD,YAAM,SAAU,MAAM,KAAK,UAAU;AAAA,QACnC;AAAA,QACA;AAAA,QACA,WAAW;AAAA,MACb;AAGA,UAAI,CAAC,OAAO,QAAQ,KAAK,CAAC,MAAM,EAAE,SAAS,KAAK,CAAC,EAAG,OAAM,IAAI,kBAAkB;AAChF,aAAO,cAAc,OAAO,QAAQ,EAAE,UAAU,KAAK,CAAC;AAAA,IACxD;AAAA,IACA;AAAA,IACA,OAAO,CAAC,cAAc,UAAU,CAAC,UAAU,KAAK,KAAK,eAAe;AAAA,IACpE,YAAY,CAAC,iBAAiB,KAAK,IAAI,cAAc,OAAO,cAAc,UAAU;AAAA,EACtF,CAAC;AAED,QAAM,EAAE,QAAQ,IAAI;AACpB,QAAM,QAAQ,YAAY,MAAM,KAAK,QAAQ,GAAG,CAAC,OAAO,CAAC;AAEzD,SAAO,QAAsB,MAAM;AACjC,UAAM,QAAQ,MAAM;AACpB,UAAM,cAAc,iBAAiB;AACrC,QAAI,SAA6B;AACjC,QAAI,CAAC,QAAS,UAAS;AAAA,aACd,MAAM,aAAc,MAAM,WAAW,YAAc,UAAS;AAAA,aAC5D,MAAM,QAAS,UAAS;AAAA,aACxB,MAAM,eAAe,EAAG,UAAS;AAC1C,UAAM,OAAO,CAAC,UACV,SACA,MAAM,YACJ,MAAM,OACN,WAAW,WAAW,WAAW,UAC/B,OACA;AACR,WAAO;AAAA,MACL;AAAA,MACA,WAAW,YAAY,WAAW,aAAa,WAAW;AAAA,MAC1D;AAAA,MACA,OAAO,WAAW,UAAU,OAAQ,SAAS,MAAM,iBAAiB;AAAA,MACpE;AAAA,IACF;AAAA,EACF,GAAG;AAAA,IACD;AAAA,IACA,MAAM;AAAA,IACN,MAAM;AAAA,IACN,MAAM;AAAA,IACN,MAAM;AAAA,IACN,MAAM;AAAA,IACN,MAAM;AAAA,IACN;AAAA,EACF,CAAC;AACH;",
+  "names": []
+}

package/dist/artifacts/useRedline.js

@@ -0,0 +1,65 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { normalizeMarkdown } from "./normalize-markdown.js";
+import { mainThreadRedlineEngine } from "./redline-engine.js";
+function useRedline({
+  baseText,
+  compareText,
+  isLoading = false,
+  engine = mainThreadRedlineEngine
+}) {
+  const [state, setState] = useState({ kind: "idle" });
+  const requestIdRef = useRef(0);
+  useEffect(() => {
+    if (baseText === void 0 || compareText === void 0) {
+      setState({ kind: "idle" });
+      return;
+    }
+    if (isLoading) {
+      setState({ kind: "computing" });
+      return;
+    }
+    if (baseText === null || compareText === null) {
+      setState({ kind: "unavailable" });
+      return;
+    }
+    if (baseText === compareText || normalizeMarkdown(baseText) === normalizeMarkdown(compareText)) {
+      setState({ kind: "identical" });
+      return;
+    }
+    const id = ++requestIdRef.current;
+    let cancelled = false;
+    setState({ kind: "computing" });
+    Promise.resolve(engine.buildRedlineWithRegions(baseText, compareText)).then((result) => {
+      if (cancelled || id !== requestIdRef.current) return;
+      setState({ kind: "ready", markdown: result.markdown, regions: result.regions });
+    }).catch(() => {
+      if (cancelled || id !== requestIdRef.current) return;
+      setState({ kind: "unavailable" });
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [baseText, compareText, isLoading, engine]);
+  const latest = useRef({ baseText, compareText });
+  useEffect(() => {
+    latest.current = { baseText, compareText };
+  }, [baseText, compareText]);
+  const revertRegion = useCallback(
+    async (regionId) => {
+      const { baseText: base, compareText: compare } = latest.current;
+      if (!base || !compare) return null;
+      try {
+        const next = await engine.revertRegion(base, compare, regionId);
+        return next !== normalizeMarkdown(compare) ? next : null;
+      } catch {
+        return null;
+      }
+    },
+    [engine]
+  );
+  return useMemo(() => ({ state, revertRegion }), [state, revertRegion]);
+}
+export {
+  useRedline
+};
+//# sourceMappingURL=useRedline.js.map

package/dist/artifacts/useRedline.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/artifacts/useRedline.ts"],
+  "sourcesContent": ["import { useCallback, useEffect, useMemo, useRef, useState } from 'react'\nimport type { RedlineRegion } from './redline-diff'\nimport { normalizeMarkdown } from './normalize-markdown'\nimport { mainThreadRedlineEngine, type RedlineEngine } from './redline-engine'\n\n/** What a redline view can show. Mirrors the status parts of `@arbidocs/blocks/artifacts`. */\nexport type RedlineState =\n  | { kind: 'idle' }\n  | { kind: 'computing' }\n  | { kind: 'ready'; markdown: string; regions: RedlineRegion[] }\n  | { kind: 'identical' }\n  | { kind: 'unavailable' }\n\nexport interface UseRedlineOptions {\n  /** The older side. `null` means the text could not be loaded; `undefined` means not chosen. */\n  baseText: string | null | undefined\n  /** The newer side (a loaded version, or the live edit buffer). */\n  compareText: string | null | undefined\n  /** Either text is still being fetched. */\n  isLoading?: boolean\n  /** Defaults to the main thread; pass a worker-backed engine for big documents. */\n  engine?: RedlineEngine\n}\n\nexport interface UseRedlineResult {\n  state: RedlineState\n  /** Undo one change: resolves with the compare text rebuilt without it (null if nothing changed). */\n  revertRegion: (regionId: string) => Promise<string | null>\n}\n\n/**\n * Track-changes between two texts. Stale results are dropped when the inputs change mid-compute,\n * and a failed diff reports `unavailable` instead of throwing into the render.\n */\nexport function useRedline({\n  baseText,\n  compareText,\n  isLoading = false,\n  engine = mainThreadRedlineEngine,\n}: UseRedlineOptions): UseRedlineResult {\n  const [state, setState] = useState<RedlineState>({ kind: 'idle' })\n  const requestIdRef = useRef(0)\n\n  useEffect(() => {\n    if (baseText === undefined || compareText === undefined) {\n      setState({ kind: 'idle' })\n      return\n    }\n    if (isLoading) {\n      setState({ kind: 'computing' })\n      return\n    }\n    if (baseText === null || compareText === null) {\n      setState({ kind: 'unavailable' })\n      return\n    }\n    if (\n      baseText === compareText ||\n      normalizeMarkdown(baseText) === normalizeMarkdown(compareText)\n    ) {\n      setState({ kind: 'identical' })\n      return\n    }\n\n    const id = ++requestIdRef.current\n    let cancelled = false\n    setState({ kind: 'computing' })\n    // Every change carries a stable id, so a view can offer per-change undo.\n    Promise.resolve(engine.buildRedlineWithRegions(baseText, compareText))\n      .then((result) => {\n        if (cancelled || id !== requestIdRef.current) return\n        setState({ kind: 'ready', markdown: result.markdown, regions: result.regions })\n      })\n      .catch(() => {\n        if (cancelled || id !== requestIdRef.current) return\n        setState({ kind: 'unavailable' })\n      })\n    return () => {\n      cancelled = true\n    }\n  }, [baseText, compareText, isLoading, engine])\n\n  // The latest texts, so `revertRegion` stays referentially stable while the user types.\n  const latest = useRef({ baseText, compareText })\n  useEffect(() => {\n    latest.current = { baseText, compareText }\n  }, [baseText, compareText])\n\n  const revertRegion = useCallback(\n    async (regionId: string): Promise<string | null> => {\n      const { baseText: base, compareText: compare } = latest.current\n      if (!base || !compare) return null\n      try {\n        const next = await engine.revertRegion(base, compare, regionId)\n        return next !== normalizeMarkdown(compare) ? next : null\n      } catch {\n        return null\n      }\n    },\n    [engine]\n  )\n\n  return useMemo(() => ({ state, revertRegion }), [state, revertRegion])\n}\n"],
+  "mappings": "AAAA,SAAS,aAAa,WAAW,SAAS,QAAQ,gBAAgB;AAElE,SAAS,yBAAyB;AAClC,SAAS,+BAAmD;AA+BrD,SAAS,WAAW;AAAA,EACzB;AAAA,EACA;AAAA,EACA,YAAY;AAAA,EACZ,SAAS;AACX,GAAwC;AACtC,QAAM,CAAC,OAAO,QAAQ,IAAI,SAAuB,EAAE,MAAM,OAAO,CAAC;AACjE,QAAM,eAAe,OAAO,CAAC;AAE7B,YAAU,MAAM;AACd,QAAI,aAAa,UAAa,gBAAgB,QAAW;AACvD,eAAS,EAAE,MAAM,OAAO,CAAC;AACzB;AAAA,IACF;AACA,QAAI,WAAW;AACb,eAAS,EAAE,MAAM,YAAY,CAAC;AAC9B;AAAA,IACF;AACA,QAAI,aAAa,QAAQ,gBAAgB,MAAM;AAC7C,eAAS,EAAE,MAAM,cAAc,CAAC;AAChC;AAAA,IACF;AACA,QACE,aAAa,eACb,kBAAkB,QAAQ,MAAM,kBAAkB,WAAW,GAC7D;AACA,eAAS,EAAE,MAAM,YAAY,CAAC;AAC9B;AAAA,IACF;AAEA,UAAM,KAAK,EAAE,aAAa;AAC1B,QAAI,YAAY;AAChB,aAAS,EAAE,MAAM,YAAY,CAAC;AAE9B,YAAQ,QAAQ,OAAO,wBAAwB,UAAU,WAAW,CAAC,EAClE,KAAK,CAAC,WAAW;AAChB,UAAI,aAAa,OAAO,aAAa,QAAS;AAC9C,eAAS,EAAE,MAAM,SAAS,UAAU,OAAO,UAAU,SAAS,OAAO,QAAQ,CAAC;AAAA,IAChF,CAAC,EACA,MAAM,MAAM;AACX,UAAI,aAAa,OAAO,aAAa,QAAS;AAC9C,eAAS,EAAE,MAAM,cAAc,CAAC;AAAA,IAClC,CAAC;AACH,WAAO,MAAM;AACX,kBAAY;AAAA,IACd;AAAA,EACF,GAAG,CAAC,UAAU,aAAa,WAAW,MAAM,CAAC;AAG7C,QAAM,SAAS,OAAO,EAAE,UAAU,YAAY,CAAC;AAC/C,YAAU,MAAM;AACd,WAAO,UAAU,EAAE,UAAU,YAAY;AAAA,EAC3C,GAAG,CAAC,UAAU,WAAW,CAAC;AAE1B,QAAM,eAAe;AAAA,IACnB,OAAO,aAA6C;AAClD,YAAM,EAAE,UAAU,MAAM,aAAa,QAAQ,IAAI,OAAO;AACxD,UAAI,CAAC,QAAQ,CAAC,QAAS,QAAO;AAC9B,UAAI;AACF,cAAM,OAAO,MAAM,OAAO,aAAa,MAAM,SAAS,QAAQ;AAC9D,eAAO,SAAS,kBAAkB,OAAO,IAAI,OAAO;AAAA,MACtD,QAAQ;AACN,eAAO;AAAA,MACT;AAAA,IACF;AAAA,IACA,CAAC,MAAM;AAAA,EACT;AAEA,SAAO,QAAQ,OAAO,EAAE,OAAO,aAAa,IAAI,CAAC,OAAO,YAAY,CAAC;AACvE;",
+  "names": []
+}

package/dist/artifacts/useStreamedArtifact.js

@@ -0,0 +1,74 @@
+import { useCallback, useEffect, useRef, useState } from "react";
+import { cleanDraftWithReport } from "../ai/stored-markdown.js";
+import { useSaveArtifactVersion } from "./useArtifactSession.js";
+import { isDocumentId } from "./versions.js";
+import { useArtifactText } from "./useArtifactText.js";
+function useStreamedArtifact({
+  artifacts,
+  workspaceId,
+  settled,
+  clean,
+  onCleaned,
+  configId,
+  parseRetry
+}) {
+  const artifact = artifacts.find((a) => a.is_complete);
+  const { mutateAsync } = useSaveArtifactVersion();
+  const [saved, setSaved] = useState(null);
+  const [saveError, setSaveError] = useState(null);
+  const [attempt, setAttempt] = useState(0);
+  const [cleaned, setCleaned] = useState(null);
+  const started = useRef(null);
+  const content = artifact?.content ?? "";
+  const title = artifact?.title ?? "Draft";
+  const passThrough = !!artifact && isDocumentId(artifact.doc_ext_id);
+  const needsSave = settled && !!artifact && !passThrough && !!content.trim() && !!workspaceId;
+  useEffect(() => {
+    const key = `${attempt}:${content}`;
+    if (!needsSave || started.current === key) return;
+    started.current = key;
+    setSaveError(null);
+    let stored;
+    if (clean) stored = clean(content);
+    else {
+      const report = cleanDraftWithReport(content);
+      stored = report.text;
+      setCleaned(report);
+      onCleaned?.(report);
+      if (report.guarded) {
+        console.warn(
+          `[useStreamedArtifact] the draft cleanup would have lost content; stored the ${report.stage} text instead (kept ${Math.round(report.ratio * 100)}%, changed by: ${report.changedBy.join(", ") || "nothing"})`
+        );
+      }
+    }
+    mutateAsync({
+      title,
+      content: stored,
+      configId,
+      wpType: "artifact"
+    }).then((r) => {
+      if (r.docId) setSaved({ content, docId: r.docId });
+      else setSaveError(new Error("The draft was stored but the server returned no document id"));
+    }).catch((e) => setSaveError(e instanceof Error ? e : new Error(String(e))));
+  }, [needsSave, content, title, workspaceId, configId, attempt, mutateAsync]);
+  const docId = !artifact ? void 0 : passThrough ? artifact.doc_ext_id : saved?.content === content ? saved.docId : void 0;
+  const text = useArtifactText(docId, { enabled: settled, retry: parseRetry });
+  const { retry: retryText } = text;
+  const retry = useCallback(() => {
+    if (saveError) setAttempt((n) => n + 1);
+    else retryText();
+  }, [saveError, retryText]);
+  let phase;
+  if (!settled || !artifact) phase = "streaming";
+  else if (saveError) phase = "error";
+  else if (!docId) phase = needsSave ? "persisting" : "streaming";
+  else if (text.status === "ready" && text.text) phase = "ready";
+  else if (text.status === "error" || text.status === "ready") phase = "error";
+  else phase = "parsing";
+  const error = phase !== "error" ? null : saveError ?? text.error ?? new Error("The document has no text to edit");
+  return { phase, artifact, docId, error, cleaned, retry };
+}
+export {
+  useStreamedArtifact
+};
+//# sourceMappingURL=useStreamedArtifact.js.map

package/dist/artifacts/useStreamedArtifact.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/artifacts/useStreamedArtifact.ts"],
+  "sourcesContent": ["import { useCallback, useEffect, useRef, useState } from 'react'\nimport type { ArtifactEvent } from '../ai/engine'\nimport { cleanDraftWithReport, type DraftCleanReport } from '../ai/stored-markdown'\nimport { useSaveArtifactVersion } from './useArtifactSession'\nimport { isDocumentId } from './versions'\nimport { useArtifactText, type ArtifactTextRetry } from './useArtifactText'\n\n/**\n * Where a drafted artifact is in its STREAM -> PERSIST -> EDIT life:\n *  - `streaming`: the agent is still working (or has produced nothing final): show the live canvas;\n *  - `persisting`: the finished draft is being stored as version 1 of the artifact;\n *  - `parsing`: stored; the backend is still parsing it, so there is no editable text yet;\n *  - `ready`: the text is readable: mount the editor on `docId`;\n *  - `error`: storing failed or the parse never produced text (`retry()` starts over).\n */\nexport type StreamedArtifactPhase = 'streaming' | 'persisting' | 'parsing' | 'ready' | 'error'\n\nexport interface UseStreamedArtifactOptions {\n  /** The artifacts of the agent run (`useConnectedAiTask().artifacts`). */\n  artifacts: ArtifactEvent[]\n  workspaceId: string | undefined\n  /**\n   * The run has stopped: not busy and not failed. Nothing is stored before this, so a draft that\n   * is still streaming is never persisted half-written.\n   */\n  settled: boolean\n  /**\n   * Make the stored markdown from the streamed content. Default `cleanDraftWithReport`, which is\n   * guarded: it stores the raw streamed text (or links-only text) rather than a cleanup that would\n   * lose content (see `DraftCleanReport`).\n   */\n  clean?: (streamed: string) => string\n  /** Called once per stored draft with what the cleanup did (`stage` is not `cleaned` if guarded). */\n  onCleaned?: (report: DraftCleanReport) => void\n  /** Processing config for the stored version. */\n  configId?: string | null\n  /** How long to wait for the parse (see `useArtifactText`). */\n  parseRetry?: ArtifactTextRetry\n}\n\nexport interface StreamedArtifact {\n  phase: StreamedArtifactPhase\n  /** The finished streamed artifact (its `title` names the stored versions). */\n  artifact: ArtifactEvent | undefined\n  /** The backend document to edit, once there is one (while `parsing` and `ready`). */\n  docId: string | undefined\n  error: Error | null\n  /** What the cleanup did to the stored draft (`null` until it was stored, or with a custom `clean`). */\n  cleaned: DraftCleanReport | null\n  /** After an `error`: store again or ask for the parse again. */\n  retry: () => void\n}\n\n/**\n * The lifecycle of an agent-drafted artifact, so a host passes the stream and renders the phase.\n *\n * While the agent streams, the draft lives only on the canvas. Once the run is `settled` and the\n * draft is complete, a draft that is not yet a backend document is cleaned (`cleanDraftMarkdown`)\n * and stored ONCE as the artifact's first version (`wpType: 'artifact'`); a draft that already is a\n * backend document passes through. The hook then waits for the parse (`useArtifactText`, which\n * retries) and reports `ready` with the `docId` to open in an editor.\n *\n * Needs an `<ArbiHost>` with an `arbi` and a workspace. `@arbidocs/blocks/connect` has the whole thing as a\n * component (`StreamedArtifact`).\n */\nexport function useStreamedArtifact({\n  artifacts,\n  workspaceId,\n  settled,\n  clean,\n  onCleaned,\n  configId,\n  parseRetry,\n}: UseStreamedArtifactOptions): StreamedArtifact {\n  const artifact = artifacts.find((a) => a.is_complete)\n  const { mutateAsync } = useSaveArtifactVersion()\n  const [saved, setSaved] = useState<{ content: string; docId: string } | null>(null)\n  const [saveError, setSaveError] = useState<Error | null>(null)\n  const [attempt, setAttempt] = useState(0)\n  const [cleaned, setCleaned] = useState<DraftCleanReport | null>(null)\n  const started = useRef<string | null>(null)\n\n  const content = artifact?.content ?? ''\n  const title = artifact?.title ?? 'Draft'\n  const passThrough = !!artifact && isDocumentId(artifact.doc_ext_id)\n  const needsSave = settled && !!artifact && !passThrough && !!content.trim() && !!workspaceId\n\n  useEffect(() => {\n    const key = `${attempt}:${content}`\n    if (!needsSave || started.current === key) return\n    started.current = key\n    setSaveError(null)\n    let stored: string\n    if (clean) stored = clean(content)\n    else {\n      const report = cleanDraftWithReport(content)\n      stored = report.text\n      setCleaned(report)\n      onCleaned?.(report)\n      if (report.guarded) {\n        console.warn(\n          `[useStreamedArtifact] the draft cleanup would have lost content; stored the ${report.stage} text instead (kept ${Math.round(report.ratio * 100)}%, changed by: ${report.changedBy.join(', ') || 'nothing'})`\n        )\n      }\n    }\n    mutateAsync({\n      title,\n      content: stored,\n      configId,\n      wpType: 'artifact',\n    })\n      .then((r) => {\n        if (r.docId) setSaved({ content, docId: r.docId })\n        else setSaveError(new Error('The draft was stored but the server returned no document id'))\n      })\n      .catch((e: unknown) => setSaveError(e instanceof Error ? e : new Error(String(e))))\n    // `clean` and `onCleaned` are deliberately not dependencies: a new function identity must not\n    // store twice.\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [needsSave, content, title, workspaceId, configId, attempt, mutateAsync])\n\n  const docId = !artifact\n    ? undefined\n    : passThrough\n      ? artifact.doc_ext_id\n      : saved?.content === content\n        ? saved.docId\n        : undefined\n\n  const text = useArtifactText(docId, { enabled: settled, retry: parseRetry })\n  const { retry: retryText } = text\n\n  const retry = useCallback(() => {\n    if (saveError) setAttempt((n) => n + 1)\n    else retryText()\n  }, [saveError, retryText])\n\n  let phase: StreamedArtifactPhase\n  if (!settled || !artifact) phase = 'streaming'\n  else if (saveError) phase = 'error'\n  else if (!docId) phase = needsSave ? 'persisting' : 'streaming'\n  else if (text.status === 'ready' && text.text) phase = 'ready'\n  else if (text.status === 'error' || text.status === 'ready') phase = 'error'\n  else phase = 'parsing'\n\n  const error =\n    phase !== 'error'\n      ? null\n      : (saveError ?? text.error ?? new Error('The document has no text to edit'))\n  return { phase, artifact, docId, error, cleaned, retry }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/artifacts/versions.js

@@ -0,0 +1,68 @@
+import { repairParsedStructure, repairParsedTitle, unescapeMarkdown } from "../ai/stored-markdown.js";
+import { normalizeMarkdown } from "./normalize-markdown.js";
+const VERSION_REF = /^(doc-[A-Za-z0-9]+)@v([1-9][0-9]*)$/;
+function versionRef(docId, version) {
+  return `${docId}@v${version}`;
+}
+function parseVersionRef(ref) {
+  const match = VERSION_REF.exec(ref ?? "");
+  if (!match) return { docId: ref ?? "", version: null };
+  return { docId: match[1], version: Number(match[2]) };
+}
+function savedFromId(docId, entry) {
+  if (entry.made_from) return versionRef(docId, entry.made_from);
+  return entry.n > 1 ? versionRef(docId, entry.n - 1) : null;
+}
+function toArtifactVersions(docId, entries, currentVersion) {
+  if (!docId) return [];
+  const current = currentVersion ?? entries?.find((e) => e.is_current)?.n ?? null;
+  return [...entries ?? []].sort((a, b) => a.n - b.n).map((e) => ({
+    id: versionRef(docId, e.n),
+    docId,
+    name: e.file_name ?? "",
+    createdAt: e.created_at ?? "",
+    number: e.n,
+    reason: e.reason ?? "upload",
+    isCurrent: current != null ? e.n === current : !!e.is_current,
+    savedFromId: savedFromId(docId, e),
+    thread: e.conversation_ext_id ? { conversationId: e.conversation_ext_id, messageId: e.source_message_ext_id ?? null } : null
+  }));
+}
+function documentVersions(doc) {
+  if (!doc?.external_id) return [];
+  const entries = doc.versions?.length ? doc.versions : [{ n: doc.current_version ?? 1, file_name: doc.file_name, created_at: doc.created_at }];
+  return toArtifactVersions(doc.external_id, entries, doc.current_version ?? null);
+}
+function findVersion(versions, ref) {
+  if (!ref) return void 0;
+  const { docId, version } = parseVersionRef(ref);
+  return version == null ? versions.find((v) => v.docId === docId && v.isCurrent) : versions.find((v) => v.docId === docId && v.number === version);
+}
+function versionLabel(versions, ref) {
+  if (!ref || versions.length <= 1) return null;
+  const version = findVersion(versions, ref);
+  return version ? `v${version.number}` : null;
+}
+function flattenChunks(chunks, options) {
+  const text = (chunks ?? []).map((c) => (c.content ?? "").trim()).join("\n\n");
+  if (!options?.unescape) return text;
+  return normalizeMarkdown(
+    repairParsedStructure(repairParsedTitle(unescapeMarkdown(text)))
+  ).replace(/\n$/, "");
+}
+const DOC_ID = /^doc/;
+function isDocumentId(id) {
+  return !!id && DOC_ID.test(id);
+}
+export {
+  documentVersions,
+  findVersion,
+  flattenChunks,
+  isDocumentId,
+  parseVersionRef,
+  savedFromId,
+  toArtifactVersions,
+  versionLabel,
+  versionRef
+};
+//# sourceMappingURL=versions.js.map

package/dist/artifacts/versions.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/artifacts/versions.ts"],
+  "sourcesContent": ["/**\n * Versions of a document. A document keeps ONE id for its whole life; its versions live inside it\n * (`current_version` + `versions`, numbered 1..n). A version is named by a version reference\n * `doc-\u2026@v{n}`; a plain document id means its current version. The workspace list carries every\n * document's `versions`, and `GET /v1/document/{id}/versions` (`arbi.documents.versions`) the same\n * list on its own.\n */\n\nimport { repairParsedStructure, repairParsedTitle, unescapeMarkdown } from '../ai/stored-markdown'\nimport { normalizeMarkdown } from './normalize-markdown'\n\n/** One version entry as the API returns it (a subset of `DocVersion`). */\nexport interface DocVersionEntry {\n  n: number\n  file_name?: string | null\n  created_at?: string | null\n  reason?: string | null\n  /** The version an edit started from, when it was not the previous one. */\n  made_from?: number | null\n  is_current?: boolean | null\n  /** The assistant message whose turn made this version, and its thread (none: a person's). */\n  source_message_ext_id?: string | null\n  conversation_ext_id?: string | null\n}\n\n/** The fields of a workspace document the version list needs (a subset of the API type). */\nexport interface VersionedDoc {\n  external_id?: string | null\n  current_version?: number | null\n  versions?: readonly DocVersionEntry[] | null\n  file_name?: string | null\n  created_at?: string | null\n}\n\n/** One row of a version list. Matches `VersionEntry` of `@arbidocs/blocks/artifacts`. */\nexport interface ArtifactVersion {\n  /** The version reference `doc-\u2026@v{n}`: what opening or comparing this version names. */\n  id: string\n  /** The document (the same for every version). */\n  docId: string\n  /** File name as stored. */\n  name: string\n  /** ISO timestamp. */\n  createdAt: string\n  /** 1-based version number within the document. */\n  number: number\n  /** upload | edit | signed | sync */\n  reason: string\n  isCurrent: boolean\n  /** The version this one was saved from (an older one than the previous version when restored). */\n  savedFromId?: string | null\n  /** The thread (and its message) whose turn made this version; none for a person's. */\n  thread?: { conversationId: string; messageId: string | null } | null\n}\n\nconst VERSION_REF = /^(doc-[A-Za-z0-9]+)@v([1-9][0-9]*)$/\n\n/** `doc-\u2026@v{n}`: a reference to version `n` of a document. */\nexport function versionRef(docId: string, version: number): string {\n  return `${docId}@v${version}`\n}\n\n/**\n * Split a reference into the document and the version it names. A plain document id (or anything\n * else) names no version: the document's current one.\n */\nexport function parseVersionRef(ref: string | null | undefined): {\n  docId: string\n  version: number | null\n} {\n  const match = VERSION_REF.exec(ref ?? '')\n  if (!match) return { docId: ref ?? '', version: null }\n  return { docId: match[1], version: Number(match[2]) }\n}\n\n/** The version a version was saved from: `made_from`, else the one before it. */\nexport function savedFromId(docId: string, entry: DocVersionEntry): string | null {\n  if (entry.made_from) return versionRef(docId, entry.made_from)\n  return entry.n > 1 ? versionRef(docId, entry.n - 1) : null\n}\n\n/** A document's version entries (oldest first) as plain version rows. */\nexport function toArtifactVersions(\n  docId: string | null | undefined,\n  entries: readonly DocVersionEntry[] | null | undefined,\n  currentVersion?: number | null\n): ArtifactVersion[] {\n  if (!docId) return []\n  const current = currentVersion ?? entries?.find((e) => e.is_current)?.n ?? null\n  return [...(entries ?? [])]\n    .sort((a, b) => a.n - b.n)\n    .map((e) => ({\n      id: versionRef(docId, e.n),\n      docId,\n      name: e.file_name ?? '',\n      createdAt: e.created_at ?? '',\n      number: e.n,\n      reason: e.reason ?? 'upload',\n      isCurrent: current != null ? e.n === current : !!e.is_current,\n      savedFromId: savedFromId(docId, e),\n      thread: e.conversation_ext_id\n        ? { conversationId: e.conversation_ext_id, messageId: e.source_message_ext_id ?? null }\n        : null,\n    }))\n}\n\n/** The versions of a listed document, oldest first (`[]` when the document is not given). */\nexport function documentVersions(doc: VersionedDoc | null | undefined): ArtifactVersion[] {\n  if (!doc?.external_id) return []\n  const entries = doc.versions?.length\n    ? doc.versions\n    : [{ n: doc.current_version ?? 1, file_name: doc.file_name, created_at: doc.created_at }]\n  return toArtifactVersions(doc.external_id, entries, doc.current_version ?? null)\n}\n\n/** The row `ref` names: an exact version, or (a plain document id) the current version. */\nexport function findVersion(\n  versions: readonly ArtifactVersion[],\n  ref: string | null | undefined\n): ArtifactVersion | undefined {\n  if (!ref) return undefined\n  const { docId, version } = parseVersionRef(ref)\n  return version == null\n    ? versions.find((v) => v.docId === docId && v.isCurrent)\n    : versions.find((v) => v.docId === docId && v.number === version)\n}\n\n/**\n * \"v2\": the version number `ref` names. `null` when there is nothing to tell apart (the document\n * has a single version, or it is unknown), so unversioned documents stay unlabelled.\n */\nexport function versionLabel(\n  versions: readonly ArtifactVersion[],\n  ref: string | null | undefined\n): string | null {\n  if (!ref || versions.length <= 1) return null\n  const version = findVersion(versions, ref)\n  return version ? `v${version.number}` : null\n}\n\n/**\n * Join parsed chunks into one markdown text (blank line between chunks).\n *\n * `unescape: true` for an artifact stored from markdown: the backend's parse of a `.md` escapes\n * markdown punctuation, which `unescapeMarkdown` undoes (see its rule), and mangles its title\n * (`repairParsedTitle`, `repairParsedStructure`: doubled headings, `- ` stacked on list markers,\n * one-line tables), then normalised. Leave it off for the parse\n * of a PDF or Word file.\n */\nexport function flattenChunks(\n  chunks: readonly { content?: string | null }[] | null | undefined,\n  options?: { unescape?: boolean }\n): string {\n  const text = (chunks ?? []).map((c) => (c.content ?? '').trim()).join('\\n\\n')\n  if (!options?.unescape) return text\n  // Canonical spelling last, so the text an editor starts from is what a save would persist.\n  return normalizeMarkdown(\n    repairParsedStructure(repairParsedTitle(unescapeMarkdown(text)))\n  ).replace(/\\n$/, '')\n}\n\n/** The backend's pattern for a document id. Anything else (a streamed draft's placeholder) is local. */\nconst DOC_ID = /^doc/\n\n/** Is `id` a real, saved document id? Local drafts have placeholder ids and no backend document. */\nexport function isDocumentId(id: string | null | undefined): id is string {\n  return !!id && DOC_ID.test(id)\n}\n"],
+  "mappings": "AAQA,SAAS,uBAAuB,mBAAmB,wBAAwB;AAC3E,SAAS,yBAAyB;AA8ClC,MAAM,cAAc;AAGb,SAAS,WAAW,OAAe,SAAyB;AACjE,SAAO,GAAG,KAAK,KAAK,OAAO;AAC7B;AAMO,SAAS,gBAAgB,KAG9B;AACA,QAAM,QAAQ,YAAY,KAAK,OAAO,EAAE;AACxC,MAAI,CAAC,MAAO,QAAO,EAAE,OAAO,OAAO,IAAI,SAAS,KAAK;AACrD,SAAO,EAAE,OAAO,MAAM,CAAC,GAAG,SAAS,OAAO,MAAM,CAAC,CAAC,EAAE;AACtD;AAGO,SAAS,YAAY,OAAe,OAAuC;AAChF,MAAI,MAAM,UAAW,QAAO,WAAW,OAAO,MAAM,SAAS;AAC7D,SAAO,MAAM,IAAI,IAAI,WAAW,OAAO,MAAM,IAAI,CAAC,IAAI;AACxD;AAGO,SAAS,mBACd,OACA,SACA,gBACmB;AACnB,MAAI,CAAC,MAAO,QAAO,CAAC;AACpB,QAAM,UAAU,kBAAkB,SAAS,KAAK,CAAC,MAAM,EAAE,UAAU,GAAG,KAAK;AAC3E,SAAO,CAAC,GAAI,WAAW,CAAC,CAAE,EACvB,KAAK,CAAC,GAAG,MAAM,EAAE,IAAI,EAAE,CAAC,EACxB,IAAI,CAAC,OAAO;AAAA,IACX,IAAI,WAAW,OAAO,EAAE,CAAC;AAAA,IACzB;AAAA,IACA,MAAM,EAAE,aAAa;AAAA,IACrB,WAAW,EAAE,cAAc;AAAA,IAC3B,QAAQ,EAAE;AAAA,IACV,QAAQ,EAAE,UAAU;AAAA,IACpB,WAAW,WAAW,OAAO,EAAE,MAAM,UAAU,CAAC,CAAC,EAAE;AAAA,IACnD,aAAa,YAAY,OAAO,CAAC;AAAA,IACjC,QAAQ,EAAE,sBACN,EAAE,gBAAgB,EAAE,qBAAqB,WAAW,EAAE,yBAAyB,KAAK,IACpF;AAAA,EACN,EAAE;AACN;AAGO,SAAS,iBAAiB,KAAyD;AACxF,MAAI,CAAC,KAAK,YAAa,QAAO,CAAC;AAC/B,QAAM,UAAU,IAAI,UAAU,SAC1B,IAAI,WACJ,CAAC,EAAE,GAAG,IAAI,mBAAmB,GAAG,WAAW,IAAI,WAAW,YAAY,IAAI,WAAW,CAAC;AAC1F,SAAO,mBAAmB,IAAI,aAAa,SAAS,IAAI,mBAAmB,IAAI;AACjF;AAGO,SAAS,YACd,UACA,KAC6B;AAC7B,MAAI,CAAC,IAAK,QAAO;AACjB,QAAM,EAAE,OAAO,QAAQ,IAAI,gBAAgB,GAAG;AAC9C,SAAO,WAAW,OACd,SAAS,KAAK,CAAC,MAAM,EAAE,UAAU,SAAS,EAAE,SAAS,IACrD,SAAS,KAAK,CAAC,MAAM,EAAE,UAAU,SAAS,EAAE,WAAW,OAAO;AACpE;AAMO,SAAS,aACd,UACA,KACe;AACf,MAAI,CAAC,OAAO,SAAS,UAAU,EAAG,QAAO;AACzC,QAAM,UAAU,YAAY,UAAU,GAAG;AACzC,SAAO,UAAU,IAAI,QAAQ,MAAM,KAAK;AAC1C;AAWO,SAAS,cACd,QACA,SACQ;AACR,QAAM,QAAQ,UAAU,CAAC,GAAG,IAAI,CAAC,OAAO,EAAE,WAAW,IAAI,KAAK,CAAC,EAAE,KAAK,MAAM;AAC5E,MAAI,CAAC,SAAS,SAAU,QAAO;AAE/B,SAAO;AAAA,IACL,sBAAsB,kBAAkB,iBAAiB,IAAI,CAAC,CAAC;AAAA,EACjE,EAAE,QAAQ,OAAO,EAAE;AACrB;AAGA,MAAM,SAAS;AAGR,SAAS,aAAa,IAA6C;AACxE,SAAO,CAAC,CAAC,MAAM,OAAO,KAAK,EAAE;AAC/B;",
+  "names": []
+}