@semiont/react-ui 0.5.5 → 0.5.7

package/src/features/resource-discovery/state/__tests__/discover-state-unit.test.ts

@@ -1,6 +1,6 @@
 import { describe, it, expect, vi } from 'vitest';
 import { BehaviorSubject, firstValueFrom } from 'rxjs';
-import { filter } from 'rxjs/operators';
+import { filter, skip, take, toArray } from 'rxjs/operators';
 import type { SemiontClient } from '@semiont/sdk';
 import type { ShellStateUnit } from '../../../../state/shell-state-unit';
 import { createDiscoverStateUnit } from '../discover-state-unit';
@@ -9,23 +9,43 @@ function mockBrowse(): ShellStateUnit {
   return { dispose: vi.fn() } as unknown as ShellStateUnit;
 }
 
+interface BrowseFilters {
+  limit?: number;
+  archived?: boolean;
+  search?: string;
+  entityType?: string;
+}
+
 function mockClient(overrides: {
   resources$?: BehaviorSubject<unknown[] | undefined>;
   entityTypes$?: BehaviorSubject<string[] | undefined>;
-} = {}): SemiontClient {
-  const resources$ = overrides.resources$ ?? new BehaviorSubject<unknown[] | undefined>([{ '@id': 'r1' }]);
-  const entityTypes$ = overrides.entityTypes$ ?? new BehaviorSubject<string[] | undefined>(['Person']);
-  return {
+  resourcesFn?: (filters: BrowseFilters) => BehaviorSubject<unknown[] | undefined>;
+} = {}): { client: SemiontClient; resourceCalls: BrowseFilters[] } {
+  const resourceCalls: BrowseFilters[] = [];
+  const defaultResources$ =
+    overrides.resources$ ?? new BehaviorSubject<unknown[] | undefined>([{ '@id': 'r1' }]);
+  const entityTypes$ =
+    overrides.entityTypes$ ?? new BehaviorSubject<string[] | undefined>(['Person']);
+
+  const resourcesFn = overrides.resourcesFn ?? (() => defaultResources$);
+
+  const client = {
     browse: {
-      resources: () => resources$.asObservable(),
+      resources: (filters: BrowseFilters = {}) => {
+        resourceCalls.push(filters);
+        return resourcesFn(filters).asObservable();
+      },
       entityTypes: () => entityTypes$.asObservable(),
     },
   } as unknown as SemiontClient;
+
+  return { client, resourceCalls };
 }
 
 describe('createDiscoverStateUnit', () => {
   it('exposes recent resources from browse namespace', async () => {
-    const stateUnit = createDiscoverStateUnit(mockClient(), mockBrowse());
+    const { client } = mockClient();
+    const stateUnit = createDiscoverStateUnit(client, mockBrowse());
 
     const recent = await firstValueFrom(stateUnit.recentResources$);
     expect(recent).toEqual([{ '@id': 'r1' }]);
@@ -34,7 +54,8 @@ describe('createDiscoverStateUnit', () => {
   });
 
   it('exposes entity types from browse namespace', async () => {
-    const stateUnit = createDiscoverStateUnit(mockClient(), mockBrowse());
+    const { client } = mockClient();
+    const stateUnit = createDiscoverStateUnit(client, mockBrowse());
 
     const types = await firstValueFrom(stateUnit.entityTypes$);
     expect(types).toEqual(['Person']);
@@ -42,9 +63,21 @@ describe('createDiscoverStateUnit', () => {
     stateUnit.dispose();
   });
 
+  it('falls back to [] when entityTypes() emits undefined', async () => {
+    const entityTypes$ = new BehaviorSubject<string[] | undefined>(undefined);
+    const { client } = mockClient({ entityTypes$ });
+    const stateUnit = createDiscoverStateUnit(client, mockBrowse());
+
+    const types = await firstValueFrom(stateUnit.entityTypes$);
+    expect(types).toEqual([]);
+
+    stateUnit.dispose();
+  });
+
   it('reports loading when resources are undefined', async () => {
     const resources$ = new BehaviorSubject<unknown[] | undefined>(undefined);
-    const stateUnit = createDiscoverStateUnit(mockClient({ resources$ }), mockBrowse());
+    const { client } = mockClient({ resources$ });
+    const stateUnit = createDiscoverStateUnit(client, mockBrowse());
 
     const loading = await firstValueFrom(stateUnit.isLoadingRecent$);
     expect(loading).toBe(true);
@@ -57,7 +90,8 @@ describe('createDiscoverStateUnit', () => {
   });
 
   it('exposes a search pipeline', () => {
-    const stateUnit = createDiscoverStateUnit(mockClient(), mockBrowse());
+    const { client } = mockClient();
+    const stateUnit = createDiscoverStateUnit(client, mockBrowse());
 
     expect(stateUnit.search).toBeDefined();
     expect(typeof stateUnit.search.setQuery).toBe('function');
@@ -68,9 +102,168 @@ describe('createDiscoverStateUnit', () => {
 
   it('disposes browse and search on dispose', () => {
     const browse = mockBrowse();
-    const stateUnit = createDiscoverStateUnit(mockClient(), browse);
+    const { client } = mockClient();
+    const stateUnit = createDiscoverStateUnit(client, browse);
     stateUnit.dispose();
 
     expect(browse.dispose).toHaveBeenCalled();
   });
+
+  it('initial selectedEntityType$ is empty and recent fetch carries no entityType', async () => {
+    const { client, resourceCalls } = mockClient();
+    const stateUnit = createDiscoverStateUnit(client, mockBrowse());
+
+    await firstValueFrom(stateUnit.recentResources$);
+
+    expect(resourceCalls).toHaveLength(1);
+    expect(resourceCalls[0]).toEqual({ limit: 10, archived: false });
+    expect(await firstValueFrom(stateUnit.selectedEntityType$)).toBe('');
+
+    stateUnit.dispose();
+  });
+
+  it('setSelectedEntityType drives a refetch with the entityType filter', async () => {
+    const { client, resourceCalls } = mockClient();
+    const stateUnit = createDiscoverStateUnit(client, mockBrowse());
+
+    // Prime the first subscription so the switchMap is live.
+    const sub = stateUnit.recentResources$.subscribe();
+
+    stateUnit.setSelectedEntityType('Person');
+
+    expect(await firstValueFrom(stateUnit.selectedEntityType$)).toBe('Person');
+    // Two calls expected: initial '' then 'Person'.
+    expect(resourceCalls.length).toBeGreaterThanOrEqual(2);
+    expect(resourceCalls.at(-1)).toEqual({ limit: 10, archived: false, entityType: 'Person' });
+
+    sub.unsubscribe();
+    stateUnit.dispose();
+  });
+
+  it('search with an empty query yields no results without hitting the wire', async () => {
+    vi.useFakeTimers();
+    try {
+      const { client, resourceCalls } = mockClient();
+      const stateUnit = createDiscoverStateUnit(client, mockBrowse());
+
+      const collected: Array<{ results: unknown[]; isSearching: boolean }> = [];
+      const sub = stateUnit.search.state$.subscribe((s) => collected.push(s));
+
+      await vi.advanceTimersByTimeAsync(300);
+
+      expect(collected.at(-1)).toEqual({ results: [], isSearching: false });
+      const searchCalls = resourceCalls.filter((c) => c.search !== undefined);
+      expect(searchCalls).toHaveLength(0);
+
+      sub.unsubscribe();
+      stateUnit.dispose();
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  it('search with a non-empty query and selected entityType pushes both into the filter', async () => {
+    vi.useFakeTimers();
+    try {
+      const results$ = new BehaviorSubject<unknown[] | undefined>([{ '@id': 'hit' }]);
+      const { client, resourceCalls } = mockClient({
+        resourcesFn: (filters) => (filters.search ? results$ : new BehaviorSubject<unknown[] | undefined>([])),
+      });
+      const stateUnit = createDiscoverStateUnit(client, mockBrowse());
+
+      const sub = stateUnit.search.state$.subscribe();
+      stateUnit.setSelectedEntityType('Person');
+      stateUnit.search.setQuery('lincoln');
+
+      await vi.advanceTimersByTimeAsync(300);
+
+      const searchCalls = resourceCalls.filter((c) => c.search !== undefined);
+      expect(searchCalls.length).toBeGreaterThanOrEqual(1);
+      expect(searchCalls.at(-1)).toEqual({
+        search: 'lincoln',
+        limit: 20,
+        entityType: 'Person',
+      });
+
+      sub.unsubscribe();
+      stateUnit.dispose();
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  it('search results flow through state$ once the debounced query fetches', async () => {
+    vi.useFakeTimers();
+    try {
+      const results$ = new BehaviorSubject<unknown[] | undefined>([{ '@id': 'hit' }]);
+      const { client } = mockClient({
+        resourcesFn: () => results$,
+      });
+      const stateUnit = createDiscoverStateUnit(client, mockBrowse());
+
+      const collected: Array<{ results: unknown[]; isSearching: boolean }> = [];
+      const sub = stateUnit.search.state$.subscribe((s) => collected.push(s));
+
+      stateUnit.search.setQuery('lincoln');
+      await vi.advanceTimersByTimeAsync(300);
+
+      expect(collected.at(-1)).toEqual({ results: [{ '@id': 'hit' }], isSearching: false });
+
+      sub.unsubscribe();
+      stateUnit.dispose();
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  it('search reports isSearching while the fetch is in flight', async () => {
+    vi.useFakeTimers();
+    try {
+      const inflight$ = new BehaviorSubject<unknown[] | undefined>(undefined);
+      const { client } = mockClient({
+        resourcesFn: () => inflight$,
+      });
+      const stateUnit = createDiscoverStateUnit(client, mockBrowse());
+
+      const collected: Array<{ results: unknown[]; isSearching: boolean }> = [];
+      const sub = stateUnit.search.state$.subscribe((s) => collected.push(s));
+
+      stateUnit.search.setQuery('lincoln');
+      await vi.advanceTimersByTimeAsync(300);
+
+      expect(collected.at(-1)).toEqual({ results: [], isSearching: true });
+
+      sub.unsubscribe();
+      stateUnit.dispose();
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  it('search query observable echoes the latest setQuery value', async () => {
+    const { client } = mockClient();
+    const stateUnit = createDiscoverStateUnit(client, mockBrowse());
+
+    const queries = stateUnit.search.query$.pipe(skip(1), take(1), toArray()).toPromise();
+    stateUnit.search.setQuery('alpha');
+
+    expect(await queries).toEqual(['alpha']);
+
+    stateUnit.dispose();
+  });
+
+  it('omits entityType from the filter when the empty sentinel is selected', async () => {
+    const { client, resourceCalls } = mockClient();
+    const stateUnit = createDiscoverStateUnit(client, mockBrowse());
+
+    const sub = stateUnit.recentResources$.subscribe();
+    stateUnit.setSelectedEntityType('Person');
+    stateUnit.setSelectedEntityType('');
+
+    const last = resourceCalls.at(-1)!;
+    expect(last.entityType).toBeUndefined();
+
+    sub.unsubscribe();
+    stateUnit.dispose();
+  });
 });

package/src/features/resource-discovery/state/discover-state-unit.ts

@@ -1,20 +1,28 @@
-import { map, type Observable } from 'rxjs';
+import { BehaviorSubject, Subject, combineLatest, of, type Observable } from 'rxjs';
+import { debounceTime, distinctUntilChanged, map, startWith, switchMap, shareReplay } from 'rxjs/operators';
 import type { ResourceDescriptor } from '@semiont/core';
-import type { StateUnit } from '@semiont/sdk';
+import type { SemiontClient, StateUnit } from '@semiont/sdk';
 import { createDisposer } from '@semiont/sdk';
 import type { ShellStateUnit } from '../../../state/shell-state-unit';
-import { createSearchPipeline, type SearchPipeline } from '@semiont/sdk';
-import type { SemiontClient } from '@semiont/sdk';
 
 const RECENT_LIMIT = 10;
 const SEARCH_LIMIT = 20;
+const DEBOUNCE_MS = 250;
+
+export interface DiscoverSearchPipeline {
+  query$: Observable<string>;
+  state$: Observable<{ results: ResourceDescriptor[]; isSearching: boolean }>;
+  setQuery(value: string): void;
+}
 
 export interface DiscoverStateUnit extends StateUnit {
   browse: ShellStateUnit;
-  search: SearchPipeline<ResourceDescriptor>;
+  search: DiscoverSearchPipeline;
   recentResources$: Observable<ResourceDescriptor[]>;
   entityTypes$: Observable<string[]>;
   isLoadingRecent$: Observable<boolean>;
+  selectedEntityType$: Observable<string>;
+  setSelectedEntityType(value: string): void;
 }
 
 export function createDiscoverStateUnit(
@@ -22,14 +30,27 @@ export function createDiscoverStateUnit(
   browse: ShellStateUnit,
 ): DiscoverStateUnit {
   const disposer = createDisposer();
-
-  const search = createSearchPipeline<ResourceDescriptor>((q) =>
-    client.browse.resources({ search: q, limit: SEARCH_LIMIT }),
-  );
-  disposer.add(search);
   disposer.add(browse);
 
-  const recent$ = client.browse.resources({ limit: RECENT_LIMIT, archived: false });
+  // Selected entity-type chip on the Discover page. Drives both the
+  // `recent` list and the search results — filtering happens on the
+  // backend, not via post-fetch array filtering.
+  const selectedEntityType$ = new BehaviorSubject<string>('');
+  disposer.add(() => selectedEntityType$.complete());
+
+  const queryInput$ = new Subject<string>();
+  disposer.add(() => queryInput$.complete());
+
+  const recent$ = selectedEntityType$.pipe(
+    switchMap((et) =>
+      client.browse.resources({
+        limit: RECENT_LIMIT,
+        archived: false,
+        ...(et ? { entityType: et } : {}),
+      }),
+    ),
+    shareReplay({ bufferSize: 1, refCount: true }),
+  );
 
   const recentResources$: Observable<ResourceDescriptor[]> = recent$.pipe(
     map((r) => r ?? []),
@@ -43,12 +64,50 @@ export function createDiscoverStateUnit(
     map((e) => e ?? []),
   );
 
+  const debouncedQuery$ = queryInput$.pipe(
+    startWith(''),
+    debounceTime(DEBOUNCE_MS),
+    distinctUntilChanged(),
+  );
+
+  const state$: Observable<{ results: ResourceDescriptor[]; isSearching: boolean }> =
+    combineLatest([debouncedQuery$, selectedEntityType$]).pipe(
+      switchMap(([q, et]) => {
+        const trimmed = q.trim();
+        if (!trimmed) {
+          return of({ results: [] as ResourceDescriptor[], isSearching: false });
+        }
+        return client.browse
+          .resources({
+            search: trimmed,
+            limit: SEARCH_LIMIT,
+            ...(et ? { entityType: et } : {}),
+          })
+          .pipe(
+            map((results) => ({
+              results: results ?? [],
+              isSearching: results === undefined,
+            })),
+            startWith({ results: [] as ResourceDescriptor[], isSearching: true }),
+          );
+      }),
+      shareReplay({ bufferSize: 1, refCount: true }),
+    );
+
+  const search: DiscoverSearchPipeline = {
+    query$: queryInput$.pipe(startWith('')),
+    state$,
+    setQuery: (value) => queryInput$.next(value),
+  };
+
   return {
     browse,
     search,
     recentResources$,
     entityTypes$,
     isLoadingRecent$,
+    selectedEntityType$: selectedEntityType$.asObservable(),
+    setSelectedEntityType: (value) => selectedEntityType$.next(value),
     dispose: () => disposer.dispose(),
   };
 }

package/src/features/resource-viewer/__tests__/ResourceViewerPage.test.tsx

@@ -13,6 +13,7 @@ import type { ResourceViewerPageProps } from '../components/ResourceViewerPage';
 import { ToastProvider } from '../../../components/Toast';
 import { ThemeProvider } from '../../../contexts/ThemeContext';
 import { createTestSemiontWrapper } from '../../../test-utils';
+import type { ResourceId } from '@semiont/core';
 
 // jsdom doesn't implement window.matchMedia — mock it for useTheme
 Object.defineProperty(window, 'matchMedia', {
@@ -131,7 +132,7 @@ vi.mock('@/components/toolbar/ToolbarPanels', () => ({
 const createMockProps = (overrides?: Partial<ResourceViewerPageProps>): ResourceViewerPageProps => ({
   resource: {
     '@context': 'https://www.w3.org/ns/anno.jsonld',
-    '@id': 'test-123',
+    '@id': 'test-123' as ResourceId,
     '@type': 'schema:DigitalDocument',
     name: 'Test Resource',
     description: 'A test resource for unit testing',
@@ -147,7 +148,6 @@ const createMockProps = (overrides?: Partial<ResourceViewerPageProps>): Resource
   },
   rUri: 'test-123' as any,
   locale: 'en',
-  cacheManager: {},
   Link: ({ children }: any) => <a>{children}</a>,
   routes: {},
   refetchDocument: vi.fn().mockResolvedValue(undefined),

package/src/features/resource-viewer/components/ResourceViewerPage.tsx

@@ -9,8 +9,7 @@ import React, { useState, useEffect, useCallback } from 'react';
 import type { components, ResourceDescriptor, ResourceId, GatheredContext, EventMap } from '@semiont/core';
 import type { ConnectionState } from '@semiont/core';
 import { annotationId } from '@semiont/core';
-import { getLanguage, getPrimaryRepresentation, getPrimaryMediaType } from '@semiont/core';
-import { getMimeCategory } from '@semiont/core';
+import { getLanguage, getPrimaryRepresentation, getPrimaryMediaType, capabilitiesOf } from '@semiont/core';
 import { ANNOTATORS } from '@semiont/react-ui';
 import { ErrorBoundary } from '@semiont/react-ui';
 import { AnnotationHistory } from '@semiont/react-ui';
@@ -141,9 +140,12 @@ export function ResourceViewerPage({
   const { hoverDelayMs } = useHoverDelay();
   const { triggerSparkleAnimation, clearNewAnnotationId } = useResourceAnnotations();
 
-  // Determine MIME category to choose content path
+  // Render mode chooses the content path: 'text' decodes inline; 'image'
+  // and 'pdf' go through the media-token (binary) path. 'none'/registry-miss
+  // fall to the text path harmlessly — the viewer shows metadata + download.
   const resourceMediaType = getPrimaryMediaType(resource) || 'text/plain';
-  const isBinary = getMimeCategory(resourceMediaType) === 'image';
+  const renderMode = capabilitiesOf(resourceMediaType)?.render;
+  const isBinary = renderMode === 'image' || renderMode === 'pdf';
 
   // Text path: fetch and decode representation (disabled for binary — mediaToken path handles those)
   const { content: textContent, loading: textLoading } = useResourceContent(rUri, resource, !isBinary);
@@ -265,8 +267,9 @@ export function ResourceViewerPage({
 
   // Domain events flow through the bus gateway (ActorStateUnit → local EventBus).
   // BrowseNamespace cache invalidation handles annotation/resource updates.
-  // The resource-viewer-page-state-unit calls client.subscribeToResource(resourceId)
-  // which bridges scoped domain events into the local EventBus.
+  // Resource-scoped freshness follows observation (#847): subscribing to the
+  // resource's `browse.*` live queries acquires its scope (which bridges scoped
+  // domain events into the local EventBus) and releases it on teardown.
 
   const handleResourceArchive = useCallback(async () => {
     if (!semiont) return;
@@ -576,7 +579,7 @@ export function ResourceViewerPage({
 
             {/* JSON-LD Panel */}
             {activePanel === 'jsonld' && (
-              <JsonLdPanel resource={resource} />
+              <JsonLdPanel resourceId={rUri} />
             )}
           </ToolbarPanels>
 

package/src/features/resource-viewer/state/__tests__/resource-viewer-page-state-unit.test.ts

@@ -56,7 +56,6 @@ function clientWithNamespaces(overrides: {
     match: { search: vi.fn(() => new Observable(() => {})) },
     yield: { fromAnnotation: vi.fn(() => new Observable(() => {})) },
     bind: { body: vi.fn().mockResolvedValue(undefined) },
-    subscribeToResource: vi.fn().mockReturnValue(() => {}),
   });
 }
 
@@ -151,6 +150,43 @@ describe('createResourceViewerPageStateUnit', () => {
     stateUnit.dispose();
   });
 
+  // isBinaryType keys off textExtractionOf(...) !== 'decode', not render mode:
+  // storage-tier binary (ZIP, gif/webp) must be fetched as bytes, never
+  // decoded as text — the client-side twin of the Phase 3a serving-side fix.
+  it('fetches storage-tier binary (ZIP) as bytes, never the text-decode path', async () => {
+    const mediaToken = vi.fn().mockResolvedValue({ token: 'tok-zip' });
+    const resourceRepresentation = vi.fn();
+    tc = clientWithNamespaces({ mediaToken, resourceRepresentation });
+    const stateUnit = createResourceViewerPageStateUnit(
+      tc.client, RID, 'en', mockBrowse(),
+      { mediaType: 'application/zip' },
+    );
+
+    const token = await firstValueFrom(stateUnit.mediaToken$.pipe(filter((t) => t !== null)));
+    expect(token).toBe('tok-zip');
+    expect(resourceRepresentation).not.toHaveBeenCalled();
+
+    stateUnit.dispose();
+  });
+
+  it('decodes a registry-miss text/* subtype via the text path (RFC 2046)', async () => {
+    const mediaToken = vi.fn();
+    const resourceRepresentation = vi.fn().mockResolvedValue({
+      data: new TextEncoder().encode('hi').buffer,
+      contentType: 'text/x-custom',
+    });
+    tc = clientWithNamespaces({ mediaToken, resourceRepresentation });
+    const stateUnit = createResourceViewerPageStateUnit(
+      tc.client, RID, 'en', mockBrowse(),
+      { mediaType: 'text/x-custom' },
+    );
+
+    expect(resourceRepresentation).toHaveBeenCalled();
+    expect(mediaToken).not.toHaveBeenCalled();
+
+    stateUnit.dispose();
+  });
+
   it('wizard initializes closed', async () => {
     tc = clientWithNamespaces();
     const stateUnit = createResourceViewerPageStateUnit(tc.client, RID, 'en', mockBrowse());

package/src/features/resource-viewer/state/resource-viewer-page-state-unit.ts

@@ -9,7 +9,7 @@ import { createGatherStateUnit, type GatherStateUnit } from '@semiont/sdk';
 import { createMatchStateUnit } from '@semiont/sdk';
 import { createYieldStateUnit, type YieldStateUnit } from '@semiont/sdk';
 import type { SemiontClient } from '@semiont/sdk';
-import { decodeWithCharset } from '@semiont/core';
+import { decodeWithCharset, textExtractionOf } from '@semiont/core';
 import { isHighlight, isComment, isAssessment, isReference, isTag } from '@semiont/core';
 import type { ReferencedByEntry } from '@semiont/sdk';
 
@@ -113,13 +113,17 @@ export function createResourceViewerPageStateUnit(
   const mediaToken$ = new BehaviorSubject<string | null>(null);
 
   const mediaType = options?.mediaType || 'text/plain';
-  const isBinaryType = mediaType.startsWith('image/') || mediaType === 'application/pdf';
+  // "Fetch raw bytes or decode as text?" — binary iff the registry says this
+  // type does not decode to text. Storage-tier images (gif/webp) are
+  // render:'none' but still binary, and a ZIP must avoid the text path; a
+  // mechanical render-mode check would mis-route both into mojibake.
+  const isBinaryType = textExtractionOf(mediaType) !== 'decode';
 
   if (!isBinaryType && mediaType) {
     contentLoading$.next(true);
-    client.browse.resourceRepresentation(resourceId, { accept: mediaType })
-      .then(({ data }) => {
-        content$.next(decodeWithCharset(data, mediaType));
+    client.browse.resourceRepresentation(resourceId)
+      .then(({ data, contentType }) => {
+        content$.next(decodeWithCharset(data, contentType));
         contentLoading$.next(false);
       })
       .catch(() => { contentLoading$.next(false); });
@@ -133,8 +137,11 @@ export function createResourceViewerPageStateUnit(
 
   const wizard$ = new BehaviorSubject<WizardState>(WIZARD_CLOSED);
 
-  const unsubscribeResource = client.subscribeToResource(resourceId);
-  disposer.add(unsubscribeResource);
+  // Resource-scoped freshness follows observation (#847): subscribing to the
+  // `browse.*(resourceId)` live queries exposed by this state unit
+  // (annotations$, events$, referencedBy$) acquires the resource scope for as
+  // long as they're observed and releases it on teardown — so no manual
+  // `subscribeToResource` call is needed.
 
   const bindInitiateSub = client.bus.get('bind:initiate').subscribe((event) => {
     wizard$.next({

package/src/integrations/__tests__/css-modules-helper.test.tsx

@@ -1,5 +1,4 @@
 import { describe, it, expect } from 'vitest';
-import React from 'react';
 import { render } from '@testing-library/react';
 import {
   createSemiontClassName,
@@ -96,7 +95,7 @@ describe('css-modules-helper', () => {
 
   describe('mergeDataAttributes', () => {
     it('merges data attributes into props', () => {
-      const props = { id: 'btn', className: 'foo' };
+      const props: Record<string, string> = { id: 'btn', className: 'foo' };
       const dataAttrs = { 'data-variant': 'primary', 'data-size': 'md' };
       const merged = mergeDataAttributes(props, dataAttrs);
 
@@ -107,7 +106,7 @@ describe('css-modules-helper', () => {
     });
 
     it('skips undefined data attributes', () => {
-      const props = { id: 'btn' };
+      const props: Record<string, string> = { id: 'btn' };
       const dataAttrs = { 'data-variant': 'primary', 'data-size': undefined };
       const merged = mergeDataAttributes(props, dataAttrs);
 

package/src/integrations/__tests__/styled-components-theme.test.ts

@@ -122,14 +122,12 @@ describe('styled-components-theme', () => {
 
     it('calls styled.button.attrs', () => {
       let attrsArg: any;
-      let templateArg: any;
 
       const mockStyled = {
         button: {
           attrs: (arg: any) => {
             attrsArg = arg;
-            return (strings: TemplateStringsArray, ...exprs: any[]) => {
-              templateArg = { strings, exprs };
+            return (_strings: TemplateStringsArray) => {
               return 'MockComponent';
             };
           },

package/src/styles/features/exchange.css

@@ -362,36 +362,6 @@
   color: var(--semiont-color-gray-400);
 }
 
-/* Hash chain badge */
-.semiont-exchange__hash-badge {
-  display: inline-flex;
-  align-items: center;
-  padding: 0.25rem 0.75rem;
-  border-radius: 9999px;
-  font-size: 0.75rem;
-  font-weight: 500;
-}
-
-.semiont-exchange__hash-badge--valid {
-  background-color: var(--semiont-color-green-100);
-  color: var(--semiont-color-green-800);
-}
-
-[data-theme="dark"] .semiont-exchange__hash-badge--valid {
-  background-color: rgba(34, 197, 94, 0.15);
-  color: var(--semiont-color-green-300);
-}
-
-.semiont-exchange__hash-badge--invalid {
-  background-color: var(--semiont-color-red-100);
-  color: var(--semiont-color-red-800);
-}
-
-[data-theme="dark"] .semiont-exchange__hash-badge--invalid {
-  background-color: rgba(239, 68, 68, 0.15);
-  color: var(--semiont-color-red-300);
-}
-
 /* Error message */
 .semiont-exchange__error-message {
   font-size: 0.875rem;

package/src/styles/index.css

@@ -91,6 +91,7 @@
 @import '../components/annotation/references.css';
 @import '../components/Toast.css';
 @import '../components/StatusDisplay.css';
+@import '../components/ProtectedErrorBoundary.css';
 @import '../components/loading-states/loading.css';
 @import '../components/error-states/errors.css';
 @import '../features/auth/auth.css';

package/translations/ar.json

@@ -71,6 +71,7 @@
     "annotationRemoved": "تمت إزالة التعليق التوضيحي",
     "annotationBodyUpdated": "تم تحديث التعليق التوضيحي",
     "jobEvent": "حدث مهمة",
+    "embeddingComputed": "تم حساب التضمين",
     "justNow": "الآن",
     "minutesAgo": "منذ {{count}}د",
     "hoursAgo": "منذ {{count}}س",
@@ -356,8 +357,5 @@
     "semanticScoringHelp": "استخدام الذكاء الاصطناعي لتقييم النتائج حسب الصلة الدلالية",
     "searching": "جاري البحث...",
     "search": "بحث"
-  },
-  "History": {
-    "embeddingComputed": "تم حساب التضمين"
   }
 }