@semiont/react-ui 0.5.23 → 0.5.25

package/src/components/pdf-annotation/__tests__/PdfAnnotationCanvas.test.tsx

@@ -13,9 +13,35 @@ import userEvent from '@testing-library/user-event';
 import { PdfAnnotationCanvas } from '../PdfAnnotationCanvas';
 import { resourceId, annotationId, parseFragmentSelector } from '@semiont/core';
 import { pdfToCanvasCoordinates } from '../../../lib/pdf-coordinates';
+import { loadPdfDocument, renderPdfPageToDataUrl } from '../../../lib/browser-pdfjs';
 
 import type { Annotation } from '@semiont/core';
 
+// The page's text layer, as pdf.js reports it. Geometry is PDF points,
+// bottom-left origin: "Hello world" sits on one line at y=700, "elsewhere" a
+// hundred points below it.
+// vi.hoisted: vi.mock's factory is lifted above these declarations.
+const { MOCK_TEXT_ITEMS } = vi.hoisted(() => ({
+  MOCK_TEXT_ITEMS: [
+    { str: 'Hello', transform: [1, 0, 0, 1, 72, 700], width: 30, height: 12, hasEOL: false },
+    { str: 'world', transform: [1, 0, 0, 1, 106, 700], width: 32, height: 12, hasEOL: true },
+    { str: 'elsewhere', transform: [1, 0, 0, 1, 72, 600], width: 54, height: 12, hasEOL: true },
+  ],
+}));
+
+const mockPage = (textItems: unknown[]) => ({
+  getViewport: vi.fn().mockReturnValue({
+    width: 612,
+    height: 792,
+    scale: 1.0,
+    rotation: 0
+  }),
+  render: vi.fn().mockReturnValue({
+    promise: Promise.resolve()
+  }),
+  getTextContent: vi.fn().mockResolvedValue({ items: textItems })
+});
+
 // Mock browser-pdfjs module
 vi.mock('../../../lib/browser-pdfjs', () => ({
   loadPdfDocument: vi.fn().mockResolvedValue({
@@ -29,7 +55,8 @@ vi.mock('../../../lib/browser-pdfjs', () => ({
       }),
       render: vi.fn().mockReturnValue({
         promise: Promise.resolve()
-      })
+      }),
+      getTextContent: vi.fn().mockResolvedValue({ items: MOCK_TEXT_ITEMS })
     })
   }),
   renderPdfPageToDataUrl: vi.fn().mockResolvedValue({
@@ -313,6 +340,225 @@ describe('PdfAnnotationCanvas', () => {
     });
   });
 
+  /**
+   * Drives the drag → mark.request path far enough to inspect the selector.
+   * `drag` is in canvas pixels; at scale 1 with a 612×792 page these are also
+   * display coordinates, since jsdom's getBoundingClientRect returns zeros.
+   */
+  async function drawRectangle(
+    drag: { fromX: number; fromY: number; toX: number; toY: number },
+  ) {
+    const request = vi.fn();
+    const session = {
+      client: { mark: { request }, beckon: { hover: vi.fn() } },
+    } as unknown as import('@semiont/sdk').SemiontSession;
+
+    render(
+      <PdfAnnotationCanvas resourceUri="res-1"
+        pdfUrl={mockPdfUrl}
+        drawingMode="rectangle"
+        selectedMotivation="highlighting"
+        session={session}
+      />
+    );
+
+    await waitFor(() => {
+      const img = document.querySelector('.semiont-pdf-annotation-canvas__image');
+      expect(img).toBeInTheDocument();
+    });
+
+    const img = document.querySelector('.semiont-pdf-annotation-canvas__image') as HTMLImageElement;
+    Object.defineProperty(img, 'clientWidth', { value: 612, configurable: true });
+    Object.defineProperty(img, 'clientHeight', { value: 792, configurable: true });
+    fireEvent.load(img);
+
+    const container = document.querySelector('.semiont-pdf-annotation-canvas__container')!;
+    fireEvent.mouseDown(container, { clientX: drag.fromX, clientY: drag.fromY });
+    fireEvent.mouseMove(container, { clientX: drag.toX, clientY: drag.toY });
+    fireEvent.mouseUp(container, { clientX: drag.toX, clientY: drag.toY });
+
+    return request;
+  }
+
+  // The manual-annotation capture gap (.plans/PDF-MANUAL-ANNOTATION-TEXT.md):
+  // a hand-drawn rectangle stored geometry and nothing else, so every panel
+  // that quotes an annotation showed it blank.
+  test('a drawn rectangle carries the text it was drawn around', async () => {
+    // The "Hello world" line in canvas space: PDF y=700..712 flips to
+    // canvas y=80..92 on a 792pt page. Drag a box a little larger than it.
+    const line = pdfToCanvasCoordinates(
+      { page: 1, x: 72, y: 700, width: 60, height: 12 }, 792, 1.0,
+    );
+    const request = await drawRectangle({
+      fromX: line.x - 2,
+      fromY: line.y - 2,
+      toX: line.x + line.width + 8,
+      toY: line.y + line.height + 4,
+    });
+
+    await waitFor(() => expect(request).toHaveBeenCalledTimes(1));
+
+    const [source, selector, motivation] = request.mock.calls[0];
+    expect(source).toBe(resourceId('res-1'));
+    expect(motivation).toBe('highlighting');
+    expect(selector).toEqual([
+      {
+        type: 'FragmentSelector',
+        conformsTo: 'http://tools.ietf.org/rfc/rfc3778',
+        value: expect.stringContaining('page=1&viewrect='),
+      },
+      { type: 'TextQuoteSelector', exact: 'Hello world' },
+    ]);
+  });
+
+  test('a rectangle over blank space carries geometry only', async () => {
+    // Between the two lines of text — nothing under the box. An empty-string
+    // quote would assert the box was drawn around nothing, so emit no quote.
+    const request = await drawRectangle({ fromX: 40, fromY: 120, toX: 200, toY: 150 });
+
+    await waitFor(() => expect(request).toHaveBeenCalledTimes(1));
+
+    const selector = request.mock.calls[0][1];
+    expect(selector).toHaveLength(1);
+    expect(selector[0].type).toBe('FragmentSelector');
+  });
+
+  // Phase 2 of .plans/PDF-MANUAL-ANNOTATION-TEXT.md. A scanned page has no text
+  // in the browser, but the server derived one at ingest and serves it through
+  // `browse.resourceAnchoredText`. Same `AnchoredText` shape either way, so
+  // `textUnder` and the drag handler do not branch — only the source does.
+  test('a scanned page quotes from the map the server derived', async () => {
+    vi.mocked(loadPdfDocument).mockResolvedValueOnce({
+      numPages: 3,
+      getPage: vi.fn().mockResolvedValue(mockPage([])),
+    } as unknown as Awaited<ReturnType<typeof loadPdfDocument>>);
+
+    const request = vi.fn();
+    const session = {
+      client: {
+        mark: { request },
+        beckon: { hover: vi.fn() },
+        browse: {
+          resourceAnchoredText: vi.fn().mockResolvedValue({
+            text: 'Hello world again',
+            items: [
+              { start: 0, end: 5, page: 1, x: 72, y: 700, width: 30, height: 12 },
+              { start: 6, end: 11, page: 1, x: 106, y: 700, width: 32, height: 12 },
+            ],
+          }),
+        },
+      },
+    } as unknown as import('@semiont/sdk').SemiontSession;
+
+    render(
+      <PdfAnnotationCanvas resourceUri="res-1"
+        pdfUrl={mockPdfUrl}
+        drawingMode="rectangle"
+        selectedMotivation="highlighting"
+        session={session}
+      />
+    );
+
+    await waitFor(() => {
+      expect(document.querySelector('.semiont-pdf-annotation-canvas__image')).toBeInTheDocument();
+    });
+    const img = document.querySelector('.semiont-pdf-annotation-canvas__image') as HTMLImageElement;
+    Object.defineProperty(img, 'clientWidth', { value: 612, configurable: true });
+    Object.defineProperty(img, 'clientHeight', { value: 792, configurable: true });
+    fireEvent.load(img);
+
+    const line = pdfToCanvasCoordinates({ page: 1, x: 72, y: 700, width: 66, height: 12 }, 792, 1.0);
+    const container = document.querySelector('.semiont-pdf-annotation-canvas__container')!;
+    fireEvent.mouseDown(container, { clientX: line.x - 2, clientY: line.y - 2 });
+    fireEvent.mouseMove(container, { clientX: line.x + line.width + 8, clientY: line.y + line.height + 4 });
+    fireEvent.mouseUp(container, { clientX: line.x + line.width + 8, clientY: line.y + line.height + 4 });
+
+    await waitFor(() => expect(request).toHaveBeenCalledTimes(1));
+    expect(request.mock.calls[0][1]).toEqual([
+      expect.objectContaining({ type: 'FragmentSelector' }),
+      { type: 'TextQuoteSelector', exact: 'Hello world' },
+    ]);
+  });
+
+  // PERSIST-ANCHORS P4. The server map is WHOLE-RESOURCE — one artifact
+  // covering every page — so fetching it from inside the per-page load
+  // effect refetched and re-decoded the entire document's geometry on every
+  // page turn. On a 400-page scan that is the difference between one decode
+  // and one per interaction.
+  test('the whole-resource map is fetched once per document, not once per page-turn', async () => {
+    vi.mocked(loadPdfDocument).mockResolvedValueOnce({
+      numPages: 3,
+      getPage: vi.fn().mockResolvedValue(mockPage([])),
+    } as unknown as Awaited<ReturnType<typeof loadPdfDocument>>);
+
+    const resourceAnchoredText = vi.fn().mockResolvedValue({
+      text: 'Hello world again',
+      items: [
+        { start: 0, end: 5, page: 1, x: 72, y: 700, width: 30, height: 12 },
+        { start: 6, end: 11, page: 2, x: 106, y: 700, width: 32, height: 12 },
+      ],
+    });
+    const session = {
+      client: { beckon: { hover: vi.fn() }, browse: { resourceAnchoredText } },
+    } as unknown as import('@semiont/sdk').SemiontSession;
+
+    render(
+      <PdfAnnotationCanvas resourceUri="res-1"
+        pdfUrl={mockPdfUrl}
+        drawingMode={null}
+        session={session}
+      />
+    );
+
+    const user = userEvent.setup();
+    await waitFor(() => {
+      expect(screen.getByText(/page 1 of 3/i)).toBeInTheDocument();
+    });
+
+    await user.click(screen.getByRole('button', { name: /next/i }));
+    await waitFor(() => {
+      expect(screen.getByText(/page 2 of 3/i)).toBeInTheDocument();
+    });
+    await user.click(screen.getByRole('button', { name: /next/i }));
+    await waitFor(() => {
+      expect(screen.getByText(/page 3 of 3/i)).toBeInTheDocument();
+    });
+
+    // The render half runs once per page load and starts alongside the
+    // anchoring half (Promise.all), so three render calls prove all three
+    // page-load effects ran to the point of resolving their map.
+    await waitFor(() => {
+      expect(vi.mocked(renderPdfPageToDataUrl)).toHaveBeenCalledTimes(3);
+    });
+
+    expect(resourceAnchoredText).toHaveBeenCalledTimes(1);
+  });
+
+  test('a scanned page with no server map carries geometry only', async () => {
+    // Class B: pdf.js returns no runs, so the browser cannot do the job and
+    // the annotation stays geometry-only pending async enrichment (Phase 2).
+    vi.mocked(loadPdfDocument).mockResolvedValueOnce({
+      numPages: 3,
+      getPage: vi.fn().mockResolvedValue(mockPage([])),
+    } as unknown as Awaited<ReturnType<typeof loadPdfDocument>>);
+
+    const line = pdfToCanvasCoordinates(
+      { page: 1, x: 72, y: 700, width: 60, height: 12 }, 792, 1.0,
+    );
+    const request = await drawRectangle({
+      fromX: line.x - 2,
+      fromY: line.y - 2,
+      toX: line.x + line.width + 8,
+      toY: line.y + line.height + 4,
+    });
+
+    await waitFor(() => expect(request).toHaveBeenCalledTimes(1));
+
+    const selector = request.mock.calls[0][1];
+    expect(selector).toHaveLength(1);
+    expect(selector[0].type).toBe('FragmentSelector');
+  });
+
   test('accepts a drawing gesture without throwing when drawing mode is active', async () => {
     render(
       <PdfAnnotationCanvas resourceUri="res-1"

package/src/components/resource/AnnotateView.tsx

@@ -5,9 +5,11 @@ import { capabilitiesOf, resourceId as toResourceId } from '@semiont/core';
 import { ANNOTATORS } from '../../lib/annotation-registry';
 import { buildTextSelectors, fallbackTextPosition } from '../../lib/text-selection-handler';
 import { defaultAnnotateRenderers, type AnnotateMediaRenderers } from './annotate-renderers';
+import { DownloadFileLink } from './DownloadFileLink';
 import type { EditorView } from '@codemirror/view';
 import type { SemiontSession } from '@semiont/sdk';
 import { useSessionEventSubscriptions } from '../../hooks/useSessionEventSubscriptions';
+import { scrollAnnotationIntoView } from '../../lib/scroll-utils';
 
 // Type augmentation for custom DOM properties
 interface EnrichedHTMLElement extends HTMLElement {
@@ -51,6 +53,7 @@ interface Props {
  *
  * @emits mark:requested - User requested to create annotation. Payload: { selector: Selector | Selector[], motivation: SelectionMotivation }
  * @subscribes beckon:hover - Annotation hovered. Payload: { annotationId: string | null }
+ * @subscribes beckon:focus - Scroll to and highlight annotation. Payload: { annotationId: string }
  */
 export function AnnotateView({
   content,
@@ -104,10 +107,20 @@ export function AnnotateView({
     onUIStateChangeRef.current?.({ hoveredAnnotationId: annotationId });
   }, []);
 
+  // "Scroll to and highlight this annotation" — the same contract BrowseView
+  // serves, so the behaviour no longer depends on which view mode is active.
+  // The `scrollToAnnotationId` prop path (uiState → renderer) stays as the
+  // host-facing capability it is; this is the in-app producer's route.
+  const handleAnnotationFocus = useCallback(({ annotationId }: { annotationId?: string | null }) => {
+    if (!containerRef.current) return;
+    scrollAnnotationIntoView(annotationId ?? null, containerRef.current, { pulse: true });
+  }, []);
+
   // Annotation hover (session-scoped). Toolbar preference changes flow through
   // props/callbacks, not the bus (TOOLBAR-PREFS-AS-PROPS).
   useSessionEventSubscriptions(session, {
     'beckon:hover': handleAnnotationHover,
+    'beckon:focus': handleAnnotationFocus,
   });
 
   // Handle text annotation with sparkle or immediate creation
@@ -210,13 +223,7 @@ export function AnnotateView({
           <p className="semiont-annotate-view__empty-message">
             Annotation not supported for {mimeType}
           </p>
-          <a
-            href={`/api/resources/${resourceUri}`}
-            download
-            className="semiont-button semiont-button--primary"
-          >
-            Download File
-          </a>
+          <DownloadFileLink resourceUri={resourceUri} session={session} />
         </div>
       </div>
     );

package/src/components/resource/BrowseView.tsx

@@ -21,6 +21,7 @@ import {
 import type { SemiontSession } from '@semiont/sdk';
 import { useSessionEventSubscriptions } from '../../hooks/useSessionEventSubscriptions';
 import { defaultBrowseRenderers, type BrowseMediaRenderers } from './browse-renderers';
+import { DownloadFileLink } from './DownloadFileLink';
 
 interface Props {
   content: string;
@@ -295,13 +296,7 @@ export const BrowseView = memo(function BrowseView({
           <p className="semiont-browse-view__empty-message">
             Preview not available for {mimeType}
           </p>
-          <a
-            href={`/api/resources/${resourceUri}`}
-            download
-            className="semiont-button semiont-button--primary"
-          >
-            Download File
-          </a>
+          <DownloadFileLink resourceUri={resourceUri} session={session} />
         </div>
       </div>
     );

package/src/components/resource/DownloadFileLink.tsx

@@ -0,0 +1,49 @@
+'use client';
+
+import { resourceId as toResourceId } from '@semiont/core';
+import type { SemiontSession } from '@semiont/sdk';
+import { useMediaToken } from '../../hooks/useMediaToken';
+import { mediaUrl } from '../../lib/media-url';
+
+interface Props {
+  /** The '@id' of the resource whose bytes to offer. */
+  resourceUri: string;
+  /** Session for that resource — its client mints the media token and supplies the backend origin. */
+  session: SemiontSession | null;
+}
+
+/**
+ * The "Download File" affordance on the unsupported-media fallback, shared by
+ * the browse and annotate views.
+ *
+ * Its own component rather than inline markup for two reasons. The token is a
+ * hook, and this fallback is a branch — mounting the component only in that
+ * branch keeps every text/image/PDF view from minting a media token it will
+ * never use. And the URL rule (absolute + `?token=`) lives in `mediaUrl`,
+ * where both views and the viewer page read the same one.
+ *
+ * Before the token lands the anchor renders as a disabled button: a tokenless
+ * URL is a guaranteed 401, and a link that silently fails is worse than one
+ * visibly not ready yet. A client with no `auth` namespace (a host on a bare
+ * transport) stays in that state permanently, which is the honest answer —
+ * it cannot mint tokens at all.
+ */
+export function DownloadFileLink({ resourceUri, session }: Props) {
+  const client = session?.client ?? null;
+  const { token } = useMediaToken(client, toResourceId(resourceUri));
+  const href = mediaUrl(client, toResourceId(resourceUri), token);
+
+  if (!href) {
+    return (
+      <button type="button" disabled className="semiont-button semiont-button--primary semiont-button--disabled">
+        Download File
+      </button>
+    );
+  }
+
+  return (
+    <a href={href} download className="semiont-button semiont-button--primary">
+      Download File
+    </a>
+  );
+}

package/src/components/resource/__tests__/AnnotateView.focus.test.tsx

@@ -0,0 +1,58 @@
+/**
+ * ASSIST-SURFACE-WARTS Lane D — in-content scroll on `beckon:focus`.
+ *
+ * `beckon:focus` is the established "scroll to and highlight this annotation"
+ * contract; BrowseView has subscribed to it all along. AnnotateView did not,
+ * so the same event scrolled the content in browse mode and did nothing in
+ * annotate mode. With the history panel now producing the event, that asymmetry
+ * becomes user-visible: the same click works or doesn't depending on the mode.
+ */
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { render } from '@testing-library/react';
+import '@testing-library/jest-dom';
+import type { AnnotationUIState } from '../../../types/annotation-props';
+import { createTestSemiontWrapper } from '../../../test-utils';
+
+const scrollSpy = vi.hoisted(() => vi.fn());
+vi.mock('../../../lib/scroll-utils', () => ({
+  scrollAnnotationIntoView: scrollSpy,
+}));
+vi.mock('../../CodeMirrorRenderer', () => ({
+  CodeMirrorRenderer: () => <div data-annotation-id="ann-7">cm-mock</div>,
+}));
+
+import { AnnotateView } from '../AnnotateView';
+
+const emptyAnnotations = { highlights: [], references: [], assessments: [], comments: [], tags: [] };
+const uiState: AnnotationUIState = {
+  selectedMotivation: 'linking',
+  selectedClick: 'detail',
+  selectedShape: 'rectangle',
+  hoveredAnnotationId: null,
+  scrollToAnnotationId: null,
+};
+
+describe('AnnotateView — beckon:focus scrolls the content', () => {
+  beforeEach(() => { scrollSpy.mockClear(); });
+
+  it('scrolls to the annotation when the session emits beckon:focus', () => {
+    const { session, client } = createTestSemiontWrapper();
+
+    render(
+      <AnnotateView
+        content="hello world"
+        mimeType="text/plain"
+        resourceUri="res-1"
+        annotations={emptyAnnotations}
+        uiState={uiState}
+        session={session}
+        annotateMode
+      />,
+    );
+
+    client.bus.get('beckon:focus').next({ annotationId: 'ann-7' });
+
+    expect(scrollSpy).toHaveBeenCalledTimes(1);
+    expect(scrollSpy.mock.calls[0]?.[0]).toBe('ann-7');
+  });
+});

package/src/components/resource/__tests__/download-link.test.tsx

@@ -0,0 +1,129 @@
+/**
+ * The "Download File" affordance on the unsupported-media fallback, in BOTH
+ * resource views.
+ *
+ * `GET /api/resources/:id` is the browser-facing alias of the pipe, and it
+ * exists only as an auth affordance for `<img>`, PDF.js and download links: a
+ * plain `<a download href>` sends neither an Authorization header nor a cookie,
+ * so the alias takes bearer + `?token=` only. Both views shipped a bare
+ * `/api/resources/${id}` — tokenless, so a 401, AND relative, so under
+ * bring-your-own-session embedding it resolves against the HOST app's origin
+ * rather than the backend's.
+ *
+ * Started RED (both hrefs were `/api/resources/res-1`).
+ */
+import { describe, it, expect, vi } from 'vitest';
+import { render, screen, waitFor } from '@testing-library/react';
+import '@testing-library/jest-dom';
+import type { SemiontSession } from '@semiont/sdk';
+import type { AnnotationUIState } from '../../../types/annotation-props';
+import { AnnotateView } from '../AnnotateView';
+import { BrowseView } from '../BrowseView';
+
+vi.mock('../../annotation/AnnotateToolbar', () => ({ AnnotateToolbar: () => null }));
+vi.mock('../../CodeMirrorRenderer', () => ({ CodeMirrorRenderer: () => null }));
+vi.mock('../../image-annotation/SvgDrawingCanvas', () => ({ SvgDrawingCanvas: () => null }));
+vi.mock('react-markdown', () => ({ default: ({ children }: { children: string }) => <div>{children}</div> }));
+vi.mock('remark-gfm', () => ({ default: () => ({}) }));
+
+const BACKEND = 'http://backend.test:4000';
+const UNSUPPORTED = 'application/octet-stream';
+
+const emptyAnnotations = { highlights: [], references: [], assessments: [], comments: [], tags: [] };
+const uiState: AnnotationUIState = {
+  selectedMotivation: null,
+  selectedClick: 'detail',
+  selectedShape: 'rectangle',
+  hoveredAnnotationId: null,
+  scrollToAnnotationId: null,
+};
+
+/** A session whose client mints `token` — the batteries-included case. */
+function sessionMinting(token: string): SemiontSession {
+  return fakeSession({ auth: { mediaToken: vi.fn(async () => ({ token })) } });
+}
+
+/** A session whose token request never settles — the in-flight case. */
+function sessionPending(): SemiontSession {
+  return fakeSession({ auth: { mediaToken: vi.fn(() => new Promise<never>(() => {})) } });
+}
+
+/**
+ * A transport-only client: `SemiontClient.auth` is `AuthNamespace | undefined`,
+ * and a host wiring a bare transport (no `IBackendOperations`) has no `auth`.
+ */
+function sessionWithoutAuth(): SemiontSession {
+  return fakeSession({});
+}
+
+function fakeSession(clientExtras: Record<string, unknown>): SemiontSession {
+  return {
+    client: {
+      baseUrl: BACKEND,
+      mark: { request: vi.fn() },
+      browse: { click: vi.fn() },
+      beckon: { hover: vi.fn() },
+      ...clientExtras,
+    },
+    subscribe: () => () => {},
+  } as unknown as SemiontSession;
+}
+
+const annotateProps = (session: SemiontSession) => ({
+  content: '',
+  mimeType: UNSUPPORTED,
+  resourceUri: 'res-1',
+  annotations: emptyAnnotations,
+  uiState,
+  annotateMode: false,
+  session,
+});
+
+const browseProps = (session: SemiontSession) => ({
+  content: '',
+  mimeType: UNSUPPORTED,
+  resourceUri: 'res-1',
+  annotations: emptyAnnotations,
+  annotateMode: false,
+  session,
+});
+
+const VIEWS = [
+  { name: 'AnnotateView', render: (s: SemiontSession) => render(<AnnotateView {...annotateProps(s)} />) },
+  { name: 'BrowseView', render: (s: SemiontSession) => render(<BrowseView {...browseProps(s)} />) },
+] as const;
+
+describe.each(VIEWS)('$name — unsupported-media download link', ({ render: renderView }) => {
+  it('points at the backend origin and carries the media token', async () => {
+    renderView(sessionMinting('tok-abc'));
+
+    const link = await screen.findByRole('link', { name: 'Download File' });
+    expect(link).toHaveAttribute('href', `${BACKEND}/api/resources/res-1?token=tok-abc`);
+    expect(link).toHaveAttribute('download');
+  });
+
+  it('renders no href while the token is still in flight', async () => {
+    renderView(sessionPending());
+
+    // The affordance stays on screen — it is just not yet actionable. What it
+    // must NOT do is offer a URL already known to fail.
+    expect(await screen.findByText('Download File')).toBeInTheDocument();
+    expect(screen.queryByRole('link', { name: 'Download File' })).not.toBeInTheDocument();
+  });
+
+  it('renders no href when the client has no auth namespace', async () => {
+    renderView(sessionWithoutAuth());
+
+    expect(await screen.findByText('Download File')).toBeInTheDocument();
+    await waitFor(() => {
+      expect(screen.queryByRole('link', { name: 'Download File' })).not.toBeInTheDocument();
+    });
+  });
+
+  it('never builds a host-relative URL', async () => {
+    renderView(sessionMinting('tok-abc'));
+
+    const link = await screen.findByRole('link', { name: 'Download File' });
+    expect(link.getAttribute('href')).not.toMatch(/^\//);
+  });
+});

package/src/components/resource/panels/AssistSection.css

@@ -126,49 +126,6 @@
    Detection Log (Completed Results)
    ============================================ */
 
-.semiont-assist-widget__log {
-  background-color: var(--semiont-bg-primary);
-  border-radius: 0.5rem;
-  box-shadow: 0 1px 3px 0 rgba(0, 0, 0, 0.1), 0 1px 2px 0 rgba(0, 0, 0, 0.06);
-  padding: 1rem;
-  display: flex;
-  flex-direction: column;
-  gap: 0.75rem;
-}
-
-[data-theme="dark"] .semiont-assist-widget__log {
-  background-color: var(--semiont-color-gray-800);
-}
-
-.semiont-assist-widget__log-items {
-  display: flex;
-  flex-direction: column;
-  gap: 0.25rem;
-}
-
-.semiont-assist-widget__log-item {
-  font-size: 0.75rem;
-  color: var(--semiont-color-gray-600);
-  display: flex;
-  align-items: center;
-  gap: 0.5rem;
-}
-
-[data-theme="dark"] .semiont-assist-widget__log-item {
-  color: var(--semiont-color-gray-400);
-}
-
-.semiont-assist-widget__log-check {
-  color: var(--semiont-color-green-600);
-}
-
-[data-theme="dark"] .semiont-assist-widget__log-check {
-  color: var(--semiont-color-green-400);
-}
-
-.semiont-assist-widget__log-type {
-  font-weight: 500;
-}
 
 /* ============================================
    Detection Progress Display

package/src/components/resource/panels/AssistSection.tsx

@@ -43,6 +43,7 @@ export function AssistSection({
                      annotationType === 'assessment' ? 'AssessmentPanel' :
                      'CommentsPanel';
   const t = useTranslations(panelName);
+  const ta = useTranslations('AssistProgress');
   const [instructions, setInstructions] = useState('');
   type ToneValue = 'scholarly' | 'explanatory' | 'conversational' | 'technical' | 'analytical' | 'critical' | 'balanced' | 'constructive' | '';
   const [tone, setTone] = useState<ToneValue>('');
@@ -89,7 +90,15 @@ export function AssistSection({
       progress={progress}
       progressProps={{
         onDismiss: handleDismissProgress,
-        translations: { close: t('closeProgress') },
+        translations: {
+          cancel: t('cancel'),
+          inProgress: t('annotating'),
+          complete: t('complete'),
+          failed: t('failed'),
+          paramsTitle: ta('paramsTitle'),
+          processing: (label) => ta('processing', { label }),
+          close: ta('close'),
+        },
       }}
       form={
         <>
@@ -157,7 +166,7 @@ export function AssistSection({
                 <span>{t('densityLabel')}</span>
               </label>
               {useDensity && (
-                <span className="semiont-form-field__info">{density} per 2000 words</span>
+                <span className="semiont-form-field__info">{t('densityPerWords', { density })}</span>
               )}
             </div>