@semiont/react-ui 0.4.20 → 0.4.22

package/src/components/resource/__tests__/AnnotationHistory.test.tsx

@@ -4,7 +4,8 @@ import { screen } from '@testing-library/react';
 import '@testing-library/jest-dom';
 import { AnnotationHistory } from '../AnnotationHistory';
 import { renderWithProviders } from '../../../test-utils';
-import type { StoredEvent, ResourceId } from '@semiont/core';
+import type { ResourceId } from '@semiont/core';
+import { BehaviorSubject } from 'rxjs';
 
 // Mock @semiont/core - must use importOriginal to preserve EventBus etc.
 vi.mock('@semiont/core', async (importOriginal) => {
@@ -27,16 +28,26 @@ vi.mock('../../../contexts/TranslationContext', () => ({
   TranslationProvider: ({ children }: { children: React.ReactNode }) => children,
 }));
 
-// Mock useResources from api-hooks
-const mockEventsUseQuery = vi.fn();
-const mockAnnotationsUseQuery = vi.fn();
-
-vi.mock('../../../lib/api-hooks', () => ({
-  useResources: () => ({
-    events: { useQuery: mockEventsUseQuery },
-    annotations: { useQuery: mockAnnotationsUseQuery },
-  }),
-}));
+const eventsSubject = new BehaviorSubject<any[] | undefined>(undefined);
+const annotationsSubject = new BehaviorSubject<any[] | undefined>(undefined);
+
+const stableMockClient = {
+  browse: {
+    events: () => eventsSubject.asObservable(),
+    annotations: () => annotationsSubject.asObservable(),
+  },
+};
+const stableMockSession = { client: stableMockClient };
+const stableActiveSession$ = new BehaviorSubject<any>(stableMockSession);
+const stableMockBrowser = { activeSession$: stableActiveSession$ };
+
+vi.mock('../../../session/SemiontProvider', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('../../../session/SemiontProvider')>();
+  return {
+    ...actual,
+    useSemiont: () => stableMockBrowser,
+  };
+});
 
 // Mock HistoryEvent to avoid deep rendering and mocking all its dependencies
 const MockHistoryEvent = vi.fn(({ event }: any) => (
@@ -81,11 +92,12 @@ describe('AnnotationHistory', () => {
   beforeEach(() => {
     vi.clearAllMocks();
     mockGetAnnotationUri.mockReturnValue(null);
-    mockAnnotationsUseQuery.mockReturnValue({ data: { annotations: [] } });
+    eventsSubject.next(undefined);
+    annotationsSubject.next([]);
   });
 
   it('renders loading state', () => {
-    mockEventsUseQuery.mockReturnValue({ data: undefined, isLoading: true, isError: false });
+    eventsSubject.next(undefined);
 
     renderWithProviders(
       <AnnotationHistory
@@ -99,22 +111,8 @@ describe('AnnotationHistory', () => {
     expect(screen.getByText('Loading...')).toBeInTheDocument();
   });
 
-  it('renders null on error', () => {
-    mockEventsUseQuery.mockReturnValue({ data: undefined, isLoading: false, isError: true });
-
-    const { container } = renderWithProviders(
-      <AnnotationHistory
-        rUri={testRId}
-        Link={MockLink}
-        routes={mockRoutes}
-      />
-    );
-
-    expect(container.innerHTML).toBe('');
-  });
-
   it('renders null when no events', () => {
-    mockEventsUseQuery.mockReturnValue({ data: { events: [] }, isLoading: false, isError: false });
+    eventsSubject.next([]);
 
     const { container } = renderWithProviders(
       <AnnotationHistory
@@ -129,11 +127,11 @@ describe('AnnotationHistory', () => {
 
   it('renders events sorted by sequence number', () => {
     const events = [
-      makeStoredEvent('evt-3', 'mark:added', 3),
-      makeStoredEvent('evt-1', 'yield:created', 1),
-      makeStoredEvent('evt-2', 'mark:added', 2),
+      makeStoredEvent('e3', 'mark:added', 3),
+      makeStoredEvent('e1', 'mark:added', 1),
+      makeStoredEvent('e2', 'mark:added', 2),
     ];
-    mockEventsUseQuery.mockReturnValue({ data: { events }, isLoading: false, isError: false });
+    eventsSubject.next(events);
 
     renderWithProviders(
       <AnnotationHistory
@@ -143,195 +141,59 @@ describe('AnnotationHistory', () => {
       />
     );
 
-    expect(screen.getByText('History')).toBeInTheDocument();
-    // All three events rendered
-    expect(screen.getByTestId('history-event-evt-1')).toBeInTheDocument();
-    expect(screen.getByTestId('history-event-evt-2')).toBeInTheDocument();
-    expect(screen.getByTestId('history-event-evt-3')).toBeInTheDocument();
-
-    // Verify HistoryEvent was called with events in sequence order
-    const calls = MockHistoryEvent.mock.calls;
-    expect(calls[0][0].event.id).toBe('evt-1');  // .event is the React prop name
-    expect(calls[1][0].event.id).toBe('evt-2');
-    expect(calls[2][0].event.id).toBe('evt-3');
+    const renderedEvents = screen.getAllByTestId(/^history-event-/);
+    expect(renderedEvents).toHaveLength(3);
+    expect(renderedEvents[0]).toHaveAttribute('data-testid', 'history-event-e1');
+    expect(renderedEvents[1]).toHaveAttribute('data-testid', 'history-event-e2');
+    expect(renderedEvents[2]).toHaveAttribute('data-testid', 'history-event-e3');
   });
 
   it('filters out job events', () => {
     const events = [
-      makeStoredEvent('evt-1', 'yield:created', 1),
-      makeStoredEvent('evt-2', 'job:started', 2),
-      makeStoredEvent('evt-3', 'job:progress', 3),
-      makeStoredEvent('evt-4', 'job:completed', 4),
-      makeStoredEvent('evt-5', 'mark:added', 5),
-    ];
-    mockEventsUseQuery.mockReturnValue({ data: { events }, isLoading: false, isError: false });
-
-    renderWithProviders(
-      <AnnotationHistory
-        rUri={testRId}
-        Link={MockLink}
-        routes={mockRoutes}
-      />
-    );
-
-    // Only non-job events should render
-    expect(screen.getByTestId('history-event-evt-1')).toBeInTheDocument();
-    expect(screen.getByTestId('history-event-evt-5')).toBeInTheDocument();
-    expect(screen.queryByTestId('history-event-evt-2')).not.toBeInTheDocument();
-    expect(screen.queryByTestId('history-event-evt-3')).not.toBeInTheDocument();
-    expect(screen.queryByTestId('history-event-evt-4')).not.toBeInTheDocument();
-  });
-
-  it('passes isRelated=true when hoveredAnnotationId matches event', () => {
-    const annotationUri = 'http://localhost/annotations/ann-1';
-    mockGetAnnotationUri.mockReturnValue(annotationUri);
-
-    const events = [
-      makeStoredEvent('evt-1', 'mark:added', 1),
+      makeStoredEvent('e1', 'mark:added', 1),
+      makeStoredEvent('e2', 'job:started', 2),
+      makeStoredEvent('e3', 'job:progress', 3),
+      makeStoredEvent('e4', 'job:completed', 4),
+      makeStoredEvent('e5', 'mark:body-updated', 5),
     ];
-    mockEventsUseQuery.mockReturnValue({ data: { events }, isLoading: false, isError: false });
+    eventsSubject.next(events);
 
     renderWithProviders(
       <AnnotationHistory
         rUri={testRId}
-        hoveredAnnotationId={annotationUri}
         Link={MockLink}
         routes={mockRoutes}
       />
     );
 
-    const call = MockHistoryEvent.mock.calls[0][0];
-    expect(call.isRelated).toBe(true);
+    const renderedEvents = screen.getAllByTestId(/^history-event-/);
+    expect(renderedEvents).toHaveLength(2);
+    expect(renderedEvents[0]).toHaveAttribute('data-testid', 'history-event-e1');
+    expect(renderedEvents[1]).toHaveAttribute('data-testid', 'history-event-e5');
   });
 
-  it('passes isRelated=false when hoveredAnnotationId does not match', () => {
-    mockGetAnnotationUri.mockReturnValue('http://localhost/annotations/ann-other');
-
-    const events = [
-      makeStoredEvent('evt-1', 'mark:added', 1),
-    ];
-    mockEventsUseQuery.mockReturnValue({ data: { events }, isLoading: false, isError: false });
+  it('passes isRelated when hovered annotation matches event', () => {
+    const events = [makeStoredEvent('e1', 'mark:added', 1)];
+    eventsSubject.next(events);
+    mockGetAnnotationUri.mockReturnValue('ann-1');
 
     renderWithProviders(
       <AnnotationHistory
         rUri={testRId}
-        hoveredAnnotationId="http://localhost/annotations/ann-1"
+        hoveredAnnotationId="ann-1"
         Link={MockLink}
         routes={mockRoutes}
       />
     );
 
-    const call = MockHistoryEvent.mock.calls[0][0];
-    expect(call.isRelated).toBe(false);
-  });
-
-  it('passes isRelated=false when no hoveredAnnotationId', () => {
-    const events = [
-      makeStoredEvent('evt-1', 'mark:added', 1),
-    ];
-    mockEventsUseQuery.mockReturnValue({ data: { events }, isLoading: false, isError: false });
-
-    renderWithProviders(
-      <AnnotationHistory
-        rUri={testRId}
-        Link={MockLink}
-        routes={mockRoutes}
-      />
+    expect(MockHistoryEvent).toHaveBeenCalledWith(
+      expect.objectContaining({ isRelated: true })
     );
-
-    const call = MockHistoryEvent.mock.calls[0][0];
-    expect(call.isRelated).toBe(false);
-  });
-
-  it('passes onEventClick and onEventHover to HistoryEvent', () => {
-    const onEventClick = vi.fn();
-    const onEventHover = vi.fn();
-
-    const events = [
-      makeStoredEvent('evt-1', 'yield:created', 1),
-    ];
-    mockEventsUseQuery.mockReturnValue({ data: { events }, isLoading: false, isError: false });
-
-    renderWithProviders(
-      <AnnotationHistory
-        rUri={testRId}
-        onEventClick={onEventClick}
-        onEventHover={onEventHover}
-        Link={MockLink}
-        routes={mockRoutes}
-      />
-    );
-
-    const call = MockHistoryEvent.mock.calls[0][0];
-    expect(call.onEventClick).toBe(onEventClick);
-    expect(call.onEventHover).toBe(onEventHover);
-  });
-
-  it('does not pass onEventClick/onEventHover when not provided', () => {
-    const events = [
-      makeStoredEvent('evt-1', 'yield:created', 1),
-    ];
-    mockEventsUseQuery.mockReturnValue({ data: { events }, isLoading: false, isError: false });
-
-    renderWithProviders(
-      <AnnotationHistory
-        rUri={testRId}
-        Link={MockLink}
-        routes={mockRoutes}
-      />
-    );
-
-    const call = MockHistoryEvent.mock.calls[0][0];
-    expect(call.onEventClick).toBeUndefined();
-    expect(call.onEventHover).toBeUndefined();
-  });
-
-  it('passes annotations from useQuery to HistoryEvent', () => {
-    const mockAnnotations = [{ id: 'ann-1', body: [] }];
-    mockAnnotationsUseQuery.mockReturnValue({ data: { annotations: mockAnnotations } });
-
-    const events = [
-      makeStoredEvent('evt-1', 'yield:created', 1),
-    ];
-    mockEventsUseQuery.mockReturnValue({ data: { events }, isLoading: false, isError: false });
-
-    renderWithProviders(
-      <AnnotationHistory
-        rUri={testRId}
-        Link={MockLink}
-        routes={mockRoutes}
-      />
-    );
-
-    const call = MockHistoryEvent.mock.calls[0][0];
-    expect(call.annotations).toEqual(mockAnnotations);
-  });
-
-  it('defaults annotations to empty array when no data', () => {
-    mockAnnotationsUseQuery.mockReturnValue({ data: undefined });
-
-    const events = [
-      makeStoredEvent('evt-1', 'yield:created', 1),
-    ];
-    mockEventsUseQuery.mockReturnValue({ data: { events }, isLoading: false, isError: false });
-
-    renderWithProviders(
-      <AnnotationHistory
-        rUri={testRId}
-        Link={MockLink}
-        routes={mockRoutes}
-      />
-    );
-
-    const call = MockHistoryEvent.mock.calls[0][0];
-    expect(call.annotations).toEqual([]);
   });
 
   it('renders history panel structure with title and list', () => {
-    const events = [
-      makeStoredEvent('evt-1', 'yield:created', 1),
-    ];
-    mockEventsUseQuery.mockReturnValue({ data: { events }, isLoading: false, isError: false });
+    const events = [makeStoredEvent('e1', 'mark:added', 1)];
+    eventsSubject.next(events);
 
     const { container } = renderWithProviders(
       <AnnotationHistory

package/src/components/resource/__tests__/BrowseView.test.tsx

@@ -2,10 +2,10 @@ import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
 import React from 'react';
 import { render, screen, fireEvent, waitFor } from '@testing-library/react';
 import { BrowseView } from '../BrowseView';
-import type { components } from '@semiont/core';
-import { EventBusProvider, useEventBus } from '../../../contexts/EventBusContext';
+import type { components, EventBus } from '@semiont/core';
+import { createTestSemiontWrapper } from '../../../test-utils';
 
-type Annotation = components['schemas']['Annotation'];
+import type { Annotation } from '@semiont/core';
 
 // Mock ResourceAnnotationsContext - keep this simple
 let mockNewAnnotationIds = new Set<string>();
@@ -15,9 +15,9 @@ vi.mock('../../../contexts/ResourceAnnotationsContext', () => ({
   })),
 }));
 
-// Mock @semiont/api-client utilities
-vi.mock('@semiont/api-client', async () => {
-  const actual = await vi.importActual('@semiont/api-client');
+// Mock @semiont/core utilities (these helpers and `resourceId` all live in core).
+vi.mock('@semiont/core', async () => {
+  const actual = await vi.importActual('@semiont/core');
   return {
     ...actual,
     getMimeCategory: vi.fn((mimeType: string) => {
@@ -97,68 +97,43 @@ interface TrackedEvent {
 function createEventTracker() {
   const events: TrackedEvent[] = [];
   const subscriptions: Set<string> = new Set();
-
-  function EventTrackingWrapper({ children }: { children: React.ReactNode }) {
-    const eventBus = useEventBus();
-
-    React.useEffect(() => {
-      const handlers: Array<{ unsubscribe: () => void }> = [];
-
-      // Track all annotation-related events
-      const trackEvent = (eventName: string) => (payload: any) => {
-        events.push({ event: eventName, payload });
-      };
-
+  return {
+    events,
+    subscriptions,
+    clear: () => {
+      events.length = 0;
+      subscriptions.clear();
+    },
+    _attach(eventBus: EventBus) {
       const annotationEvents = [
         'beckon:hover',
         'browse:click',
         'beckon:focus',
       ] as const;
-
-      annotationEvents.forEach(eventName => {
+      annotationEvents.forEach((eventName) => {
         subscriptions.add(eventName);
-        const handler = trackEvent(eventName);
-        const subscription = eventBus.get(eventName).subscribe(handler);
-        handlers.push(subscription);
+        eventBus.get(eventName).subscribe((payload: any) => {
+          events.push({ event: eventName, payload });
+        });
       });
-
-      return () => {
-        handlers.forEach(sub => sub.unsubscribe());
-      };
-    }, [eventBus]);
-
-    return <>{children}</>;
-  }
-
-  return {
-    EventTrackingWrapper,
-    events,
-    subscriptions,
-    clear: () => {
-      events.length = 0;
-      subscriptions.clear();
     },
   };
 }
 
-// Helper to render with providers - simple composition, no spy wrappers
 const renderWithProviders = (
   component: React.ReactElement,
   options: { newAnnotationIds?: Set<string> } = {}
 ) => {
-  // Update the mock if new annotation IDs are provided
   if (options.newAnnotationIds) {
     mockNewAnnotationIds = options.newAnnotationIds;
   }
-
-  return render(
-    <EventBusProvider>
-      {component}
-    </EventBusProvider>
+  const { SemiontWrapper } = createTestSemiontWrapper();
+  const Wrapper = ({ children }: { children: React.ReactNode }) => (
+    <SemiontWrapper>{children}</SemiontWrapper>
   );
+  return render(component, { wrapper: Wrapper });
 };
 
-// Helper to render with event tracking
 const renderWithEventTracking = (
   component: React.ReactElement,
   tracker: ReturnType<typeof createEventTracker>,
@@ -167,14 +142,12 @@ const renderWithEventTracking = (
   if (options.newAnnotationIds) {
     mockNewAnnotationIds = options.newAnnotationIds;
   }
-
-  return render(
-    <EventBusProvider>
-      <tracker.EventTrackingWrapper>
-        {component}
-      </tracker.EventTrackingWrapper>
-    </EventBusProvider>
+  const { SemiontWrapper, eventBus } = createTestSemiontWrapper();
+  tracker._attach(eventBus);
+  const Wrapper = ({ children }: { children: React.ReactNode }) => (
+    <SemiontWrapper>{children}</SemiontWrapper>
   );
+  return render(component, { wrapper: Wrapper });
 };
 
 // Test data fixtures
@@ -193,7 +166,6 @@ const createMockAnnotation = (motivation: string, id: string): Annotation => ({
       end: 10,
     },
   },
-  body: [],
 });
 
 describe('BrowseView Component', () => {
@@ -515,35 +487,8 @@ describe('BrowseView Component', () => {
 
   describe('Performance - Event Listener Efficiency', () => {
     it('should handle many annotations efficiently through event delegation', async () => {
-      // Create a composition-based event tracker that subscribes like a real consumer
       const eventTracker: Array<{ event: string; annotationId: string | null }> = [];
 
-      function EventTrackingWrapper({ children }: { children: React.ReactNode }) {
-        const eventBus = useEventBus();
-
-        React.useEffect(() => {
-          // Subscribe to events like a real component would
-          const handleHover = (payload: any) => {
-            eventTracker.push({ event: 'beckon:hover', annotationId: payload?.annotationId ?? null });
-          };
-
-          const handleClick = (payload: any) => {
-            eventTracker.push({ event: 'browse:click', annotationId: payload?.annotationId ?? null });
-          };
-
-          const subscription1 = eventBus.get('beckon:hover').subscribe(handleHover);
-          const subscription2 = eventBus.get('browse:click').subscribe(handleClick);
-
-          return () => {
-            subscription1.unsubscribe();
-            subscription2.unsubscribe();
-          };
-        }, [eventBus]);
-
-        return <>{children}</>;
-      }
-
-      // Create many annotations
       const manyAnnotations = {
         highlights: Array.from({ length: 50 }, (_, i) =>
           createMockAnnotation('highlighting', `highlight-${i}`)
@@ -556,12 +501,18 @@ describe('BrowseView Component', () => {
         tags: [],
       };
 
+      const { SemiontWrapper, eventBus } = createTestSemiontWrapper();
+      eventBus.get('beckon:hover').subscribe((payload: any) => {
+        eventTracker.push({ event: 'beckon:hover', annotationId: payload?.annotationId ?? null });
+      });
+      eventBus.get('browse:click').subscribe((payload: any) => {
+        eventTracker.push({ event: 'browse:click', annotationId: payload?.annotationId ?? null });
+      });
+
       const { container } = render(
-        <EventBusProvider>
-          <EventTrackingWrapper>
-            <BrowseView {...defaultProps} annotations={manyAnnotations} />
-          </EventTrackingWrapper>
-        </EventBusProvider>
+        <SemiontWrapper>
+          <BrowseView {...defaultProps} annotations={manyAnnotations} />
+        </SemiontWrapper>
       );
 
       const browseContainer = container.querySelector('.semiont-browse-view__content');

package/src/components/resource/__tests__/ResourceViewer.mode-switch.test.tsx

@@ -12,14 +12,11 @@
 
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { render, screen, fireEvent, waitFor } from '@testing-library/react';
-import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import { BehaviorSubject } from 'rxjs';
 import { ResourceViewer } from '../ResourceViewer';
-import { EventBusProvider } from '../../../contexts/EventBusContext';
-import { CacheProvider } from '../../../contexts/CacheContext';
+import { createTestSemiontWrapper } from '../../../test-utils';
 import { TranslationProvider } from '../../../contexts/TranslationContext';
 import { ResourceAnnotationsProvider } from '../../../contexts/ResourceAnnotationsContext';
-import { ApiClientProvider } from '../../../contexts/ApiClientContext';
-import { AuthTokenProvider } from '../../../contexts/AuthTokenContext';
 import type { components } from '@semiont/core';
 
 type SemiontResource = components['schemas']['ResourceDescriptor'];
@@ -29,6 +26,39 @@ vi.mock('../../../hooks/useObservableBrowse', () => ({
   useObservableExternalNavigation: () => vi.fn(),
 }));
 
+// ResourceViewer (and ResourceAnnotationsContext) now resolve the client via
+// useSemiont(). Mock useSemiont to emit a minimal session carrying a stub
+// client with the methods the subject component touches. The session also
+// exposes `on` and `emit` stubs so useEventSubscription(s) don't explode.
+const stubClient = {
+  browse: { invalidateAnnotationList: vi.fn() },
+  markAnnotation: vi.fn(),
+  on: vi.fn(() => () => {}),
+  emit: vi.fn(),
+  stream: vi.fn(() => ({ subscribe: () => ({ unsubscribe: () => {} }) })),
+};
+const stubSession = {
+  client: stubClient,
+  subscribe: vi.fn(() => () => {}),
+};
+const stubActiveSession$ = new BehaviorSubject<any>(stubSession);
+const stubBrowser = {
+  activeSession$: stubActiveSession$,
+  emit: vi.fn(),
+  on: vi.fn(() => () => {}),
+  stream: vi.fn(() => ({ subscribe: () => ({ unsubscribe: () => {} }) })),
+};
+
+vi.mock('../../../session/SemiontProvider', async () => {
+  const actual = await vi.importActual<typeof import('../../../session/SemiontProvider')>(
+    '../../../session/SemiontProvider'
+  );
+  return {
+    ...actual,
+    useSemiont: () => stubBrowser,
+  };
+});
+
 const mockResource: SemiontResource & { content: string } = {
   '@context': 'https://www.w3.org/ns/activitystreams',
   '@id': 'test-123',
@@ -53,19 +83,6 @@ const mockAnnotations = {
   tags: [],
 };
 
-const mockCacheManager = {
-  invalidateAnnotations: vi.fn(),
-  invalidate: vi.fn(),
-  invalidateEvents: vi.fn(),
-};
-
-const queryClient = new QueryClient({
-  defaultOptions: {
-    queries: { retry: false },
-    mutations: { retry: false },
-  },
-});
-
 const mockTranslationManager = {
   t: (namespace: string, key: string, params?: Record<string, any>) => {
     return `${namespace}.${key}`;
@@ -73,21 +90,14 @@ const mockTranslationManager = {
 };
 
 function TestWrapper({ children }: { children: React.ReactNode }) {
+  const { SemiontWrapper } = createTestSemiontWrapper();
   return (
     <TranslationProvider translationManager={mockTranslationManager}>
-      <EventBusProvider>
-        <AuthTokenProvider token="test-token">
-          <ApiClientProvider baseUrl="http://localhost:4000">
-            <QueryClientProvider client={queryClient}>
-              <ResourceAnnotationsProvider>
-                <CacheProvider cacheManager={mockCacheManager}>
-                  {children}
-                </CacheProvider>
-              </ResourceAnnotationsProvider>
-            </QueryClientProvider>
-          </ApiClientProvider>
-        </AuthTokenProvider>
-      </EventBusProvider>
+      <SemiontWrapper>
+        <ResourceAnnotationsProvider>
+          {children}
+        </ResourceAnnotationsProvider>
+      </SemiontWrapper>
     </TranslationProvider>
   );
 }

package/src/components/resource/__tests__/event-formatting.test.ts

@@ -9,10 +9,14 @@ import {
 } from '../event-formatting';
 
 // Mock api-client functions
-vi.mock('@semiont/api-client', () => ({
+vi.mock('@semiont/core', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('@semiont/core')>();
+  return {
+    ...actual,
   getExactText: vi.fn((selector: any) => selector?.exact ?? null),
   getTargetSelector: vi.fn((target: any) => target?.selector ?? null),
-}));
+  };
+});
 
 const t = vi.fn((key: string, params?: Record<string, string | number>) => {
   if (params) return `${key}(${JSON.stringify(params)})`;

package/src/components/resource/event-formatting.ts

@@ -6,11 +6,10 @@
  */
 
 import type { StoredEventLike, PersistedEventType } from '@semiont/core';
-import type { components } from '@semiont/core';
-import { getExactText, getTargetSelector } from '@semiont/api-client';
+import { getExactText, getTargetSelector } from '@semiont/core';
 import { ANNOTATORS } from '../../lib/annotation-registry';
 
-type Annotation = components['schemas']['Annotation'];
+import type { Annotation } from '@semiont/core';
 type TranslateFn = (key: string, params?: Record<string, string | number>) => string;
 
 // =============================================================================