@semiont/react-ui 0.4.20 → 0.4.21

package/src/components/modals/__tests__/ProposeEntitiesModal.test.tsx

@@ -1,129 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import React from 'react';
-import { screen, fireEvent } from '@testing-library/react';
-import { renderWithProviders } from '../../../test-utils';
-import '@testing-library/jest-dom';
-import { ProposeEntitiesModal } from '../ProposeEntitiesModal';
-
-// Mock HeadlessUI to avoid jsdom OOM issues
-vi.mock('@headlessui/react', () => ({
-  Dialog: ({ children, onClose, ...props }: any) => <div role="dialog" {...props}>{typeof children === 'function' ? children({ open: true }) : children}</div>,
-  DialogPanel: ({ children, ...props }: any) => <div {...props}>{children}</div>,
-  DialogTitle: ({ children, ...props }: any) => <h2 {...props}>{children}</h2>,
-  DialogDescription: ({ children, ...props }: any) => <p {...props}>{children}</p>,
-  Transition: ({ show, children }: any) => show ? <>{children}</> : null,
-  TransitionChild: ({ children }: any) => <>{children}</>,
-}));
-
-// Stable entity types array to avoid infinite re-render loops
-const mockEntityTypes = ['Person', 'Organization', 'Location'];
-const stableQueryResult = { data: { entityTypes: mockEntityTypes } };
-
-vi.mock('../../../lib/api-hooks', () => ({
-  useEntityTypes: vi.fn(() => ({
-    list: {
-      useQuery: () => stableQueryResult,
-    },
-  })),
-}));
-
-describe('ProposeEntitiesModal', () => {
-  const defaultProps = {
-    isOpen: true,
-    onConfirm: vi.fn(),
-    onCancel: vi.fn(),
-  };
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    sessionStorage.clear();
-  });
-
-  it('renders modal title when open', () => {
-    renderWithProviders(<ProposeEntitiesModal {...defaultProps} />);
-    expect(screen.getByText('Detect Entity References')).toBeInTheDocument();
-  });
-
-  it('does not render when closed', () => {
-    renderWithProviders(
-      <ProposeEntitiesModal {...defaultProps} isOpen={false} />
-    );
-    expect(screen.queryByText('Detect Entity References')).not.toBeInTheDocument();
-  });
-
-  it('renders available entity type buttons', () => {
-    renderWithProviders(<ProposeEntitiesModal {...defaultProps} />);
-    expect(screen.getByText('Person')).toBeInTheDocument();
-    expect(screen.getByText('Organization')).toBeInTheDocument();
-    expect(screen.getByText('Location')).toBeInTheDocument();
-  });
-
-  it('toggles entity type selection on click', () => {
-    renderWithProviders(<ProposeEntitiesModal {...defaultProps} />);
-
-    fireEvent.click(screen.getByText('Person'));
-    expect(screen.getByText('1 type selected')).toBeInTheDocument();
-
-    fireEvent.click(screen.getByText('Organization'));
-    expect(screen.getByText('2 types selected')).toBeInTheDocument();
-
-    // Deselect
-    fireEvent.click(screen.getByText('Person'));
-    expect(screen.getByText('1 type selected')).toBeInTheDocument();
-  });
-
-  it('disables confirm button when no types selected', () => {
-    renderWithProviders(<ProposeEntitiesModal {...defaultProps} />);
-    const buttons = screen.getAllByRole('button');
-    const confirmButton = buttons.find(b => b.textContent?.includes('Detect Entity'));
-    expect(confirmButton).toBeDisabled();
-  });
-
-  it('enables confirm button when types are selected', () => {
-    renderWithProviders(<ProposeEntitiesModal {...defaultProps} />);
-    fireEvent.click(screen.getByText('Person'));
-
-    const buttons = screen.getAllByRole('button');
-    const confirmButton = buttons.find(b => b.textContent?.includes('Detect Entity'));
-    expect(confirmButton).not.toBeDisabled();
-  });
-
-  it('calls onConfirm with selected types', () => {
-    const onConfirm = vi.fn();
-    renderWithProviders(
-      <ProposeEntitiesModal {...defaultProps} onConfirm={onConfirm} />
-    );
-
-    fireEvent.click(screen.getByText('Person'));
-    fireEvent.click(screen.getByText('Location'));
-
-    const buttons = screen.getAllByRole('button');
-    const confirmButton = buttons.find(b => b.textContent?.includes('Detect Entity'));
-    fireEvent.click(confirmButton!);
-
-    expect(onConfirm).toHaveBeenCalledWith(['Person', 'Location']);
-  });
-
-  it('calls onCancel when cancel button is clicked', () => {
-    const onCancel = vi.fn();
-    renderWithProviders(
-      <ProposeEntitiesModal {...defaultProps} onCancel={onCancel} />
-    );
-    fireEvent.click(screen.getByText('Cancel'));
-    expect(onCancel).toHaveBeenCalled();
-  });
-
-  it('saves preferences to sessionStorage on confirm', () => {
-    renderWithProviders(<ProposeEntitiesModal {...defaultProps} />);
-
-    fireEvent.click(screen.getByText('Person'));
-
-    const buttons = screen.getAllByRole('button');
-    const confirmButton = buttons.find(b => b.textContent?.includes('Detect Entity'));
-    fireEvent.click(confirmButton!);
-
-    expect(sessionStorage.getItem('userPreferredEntityTypes')).toBe(
-      JSON.stringify(['Person'])
-    );
-  });
-});

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

@@ -1,323 +0,0 @@
-/**
- * Regression test: pendingAnnotation cleared after mark:submit succeeds
- *
- * Bug: handleAnnotationCreate in useMarkFlow called the API and emitted
- * mark:created, but never called setPendingAnnotation(null). The pending
- * creation form (e.g. "Create Reference", "Save" assessment) remained visible
- * after the user clicked the confirm button.
- *
- * Fix: setPendingAnnotation(null) added in handleAnnotationCreate on success,
- * before emitting mark:created.
- *
- * This test covers all four motivations that have a pending form:
- * - linking  (ReferencesPanel: "Create Reference" button)
- * - assessing (AssessmentPanel: "Save" button)
- * - commenting (CommentsPanel: "Save" button)
- * - tagging   (TaggingPanel: category selection)
- */
-
-import React from 'react';
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { render, screen, waitFor } from '@testing-library/react';
-import { act } from 'react';
-import { useMarkFlow } from '../../../hooks/useMarkFlow';
-import { EventBusProvider, useEventBus } from '../../../contexts/EventBusContext';
-import { ApiClientProvider } from '../../../contexts/ApiClientContext';
-import { AuthTokenProvider } from '../../../contexts/AuthTokenContext';
-import { SemiontApiClient } from '@semiont/api-client';
-import { resourceId } from '@semiont/core';
-import type { Emitter } from 'mitt';
-import type { EventMap } from '@semiont/core';
-
-// Mock Toast module to prevent "useToast must be used within a ToastProvider" errors
-vi.mock('../../../components/Toast', () => ({
-  useToast: () => ({
-    showSuccess: vi.fn(),
-    showError: vi.fn(),
-    showInfo: vi.fn(),
-    showWarning: vi.fn(),
-  }),
-}));
-import type { Motivation, Selector } from '@semiont/core';
-
-const TEST_URI = resourceId('test-resource');
-
-const MOCK_ANNOTATION = {
-  id: 'new-1',
-  type: 'Annotation',
-  motivation: 'linking' as Motivation,
-  target: { source: TEST_URI },
-  body: [],
-};
-
-const TEXT_SELECTOR: Selector = {
-  type: 'TextQuoteSelector',
-  exact: 'some selected text',
-};
-
-const SVG_SELECTOR: Selector = {
-  type: 'SvgSelector',
-  value: '<rect x="10" y="20" width="100" height="50"/>',
-};
-
-// ─── Helper ───────────────────────────────────────────────────────────────────
-
-function renderDetectionFlow(testUri: string) {
-  let eventBusInstance: Emitter<EventMap>;
-
-  function EventBusCapture() {
-    eventBusInstance = useEventBus();
-    return null;
-  }
-
-  function DetectionFlowHarness() {
-    const { pendingAnnotation } = useMarkFlow(testUri as any);
-    return (
-      <div>
-        <div data-testid="pending-motivation">
-          {pendingAnnotation ? pendingAnnotation.motivation : 'none'}
-        </div>
-      </div>
-    );
-  }
-
-  render(
-    <EventBusProvider>
-      <AuthTokenProvider token={null}>
-        <ApiClientProvider baseUrl="http://localhost:4000">
-          <EventBusCapture />
-          <DetectionFlowHarness />
-        </ApiClientProvider>
-      </AuthTokenProvider>
-    </EventBusProvider>
-  );
-
-  return {
-    getEventBus: () => eventBusInstance,
-    emit: <K extends keyof EventMap>(event: K, payload: EventMap[K]) => {
-      eventBusInstance.get(event).next(payload);
-    },
-  };
-}
-
-// ─── Tests ────────────────────────────────────────────────────────────────────
-
-describe('Annotation creation clears pendingAnnotation', () => {
-  let markAnnotationSpy: ReturnType<typeof vi.spyOn>;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    markAnnotationSpy = vi
-      .spyOn(SemiontApiClient.prototype, 'markAnnotation')
-      .mockResolvedValue({ annotationId: MOCK_ANNOTATION.id } as any);
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  it('clears pendingAnnotation after creating a reference (linking)', async () => {
-    const { emit } = renderDetectionFlow(TEST_URI);
-
-    // Set a pending annotation
-    act(() => {
-      emit('mark:requested', { selector: TEXT_SELECTOR, motivation: 'linking' });
-    });
-
-    await waitFor(() => {
-      expect(screen.getByTestId('pending-motivation')).toHaveTextContent('linking');
-    });
-
-    // Emit mark:submit(what ReferencesPanel does when user clicks "Create Reference")
-    await act(async () => {
-      emit('mark:submit', {
-        motivation: 'linking',
-        selector: TEXT_SELECTOR,
-        body: [{ type: 'TextualBody', value: 'Person', purpose: 'tagging' }],
-      });
-    });
-
-    // pendingAnnotation must be cleared
-    await waitFor(() => {
-      expect(screen.getByTestId('pending-motivation')).toHaveTextContent('none');
-    });
-
-    expect(markAnnotationSpy).toHaveBeenCalledTimes(1);
-  });
-
-  it('clears pendingAnnotation after creating an assessment (assessing)', async () => {
-    const { emit } = renderDetectionFlow(TEST_URI);
-
-    act(() => {
-      emit('mark:requested', { selector: SVG_SELECTOR, motivation: 'assessing' });
-    });
-
-    await waitFor(() => {
-      expect(screen.getByTestId('pending-motivation')).toHaveTextContent('assessing');
-    });
-
-    await act(async () => {
-      emit('mark:submit', {
-        motivation: 'assessing',
-        selector: SVG_SELECTOR,
-        body: [{ type: 'TextualBody', value: 'Looks good', purpose: 'assessing' }],
-      });
-    });
-
-    await waitFor(() => {
-      expect(screen.getByTestId('pending-motivation')).toHaveTextContent('none');
-    });
-  });
-
-  it('clears pendingAnnotation after creating an assessment with empty body (optional text)', async () => {
-    const { emit } = renderDetectionFlow(TEST_URI);
-
-    act(() => {
-      emit('mark:requested', { selector: SVG_SELECTOR, motivation: 'assessing' });
-    });
-
-    await waitFor(() => {
-      expect(screen.getByTestId('pending-motivation')).toHaveTextContent('assessing');
-    });
-
-    // Empty body is valid for assessments
-    await act(async () => {
-      emit('mark:submit', {
-        motivation: 'assessing',
-        selector: SVG_SELECTOR,
-        body: [],
-      });
-    });
-
-    await waitFor(() => {
-      expect(screen.getByTestId('pending-motivation')).toHaveTextContent('none');
-    });
-  });
-
-  it('clears pendingAnnotation after creating a comment (commenting)', async () => {
-    const { emit } = renderDetectionFlow(TEST_URI);
-
-    act(() => {
-      emit('mark:requested', { selector: TEXT_SELECTOR, motivation: 'commenting' });
-    });
-
-    await waitFor(() => {
-      expect(screen.getByTestId('pending-motivation')).toHaveTextContent('commenting');
-    });
-
-    await act(async () => {
-      emit('mark:submit', {
-        motivation: 'commenting',
-        selector: TEXT_SELECTOR,
-        body: [{ type: 'TextualBody', value: 'Great point', purpose: 'commenting' }],
-      });
-    });
-
-    await waitFor(() => {
-      expect(screen.getByTestId('pending-motivation')).toHaveTextContent('none');
-    });
-  });
-
-  it('clears pendingAnnotation after creating a tag (tagging)', async () => {
-    const { emit } = renderDetectionFlow(TEST_URI);
-
-    act(() => {
-      emit('mark:requested', { selector: SVG_SELECTOR, motivation: 'tagging' });
-    });
-
-    await waitFor(() => {
-      expect(screen.getByTestId('pending-motivation')).toHaveTextContent('tagging');
-    });
-
-    await act(async () => {
-      emit('mark:submit', {
-        motivation: 'tagging',
-        selector: SVG_SELECTOR,
-        body: [{ type: 'TextualBody', value: 'concept:trust', purpose: 'tagging' }],
-      });
-    });
-
-    await waitFor(() => {
-      expect(screen.getByTestId('pending-motivation')).toHaveTextContent('none');
-    });
-  });
-
-  it('emits mark:created after successful creation', async () => {
-    const { emit, getEventBus } = renderDetectionFlow(TEST_URI);
-
-    const createdListener = vi.fn();
-    // Set listener after first render so eventBus is captured
-    await waitFor(() => expect(getEventBus()).toBeDefined());
-    const subscription = getEventBus().get('mark:create-ok').subscribe(createdListener);
-
-    act(() => {
-      emit('mark:requested', { selector: TEXT_SELECTOR, motivation: 'linking' });
-    });
-
-    await act(async () => {
-      emit('mark:submit', {
-        motivation: 'linking',
-        selector: TEXT_SELECTOR,
-        body: [],
-      });
-    });
-
-    await waitFor(() => {
-      expect(createdListener).toHaveBeenCalledTimes(1);
-      expect(createdListener).toHaveBeenCalledWith({ annotationId: 'new-1' });
-    });
-
-    subscription.unsubscribe();
-  });
-
-  it('does NOT clear pendingAnnotation if API call fails', async () => {
-    markAnnotationSpy.mockRejectedValueOnce(new Error('Network error'));
-
-    const { emit } = renderDetectionFlow(TEST_URI);
-
-    act(() => {
-      emit('mark:requested', { selector: TEXT_SELECTOR, motivation: 'linking' });
-    });
-
-    await waitFor(() => {
-      expect(screen.getByTestId('pending-motivation')).toHaveTextContent('linking');
-    });
-
-    await act(async () => {
-      emit('mark:submit', {
-        motivation: 'linking',
-        selector: TEXT_SELECTOR,
-        body: [],
-      });
-    });
-
-    // Give async rejection time to settle
-    await waitFor(() => {
-      // pending should remain — user can retry or cancel
-      expect(screen.getByTestId('pending-motivation')).toHaveTextContent('linking');
-    });
-  });
-
-  it('clears pendingAnnotation on cancel (mark:cancel-pending)', async () => {
-    const { emit } = renderDetectionFlow(TEST_URI);
-
-    act(() => {
-      emit('mark:requested', { selector: TEXT_SELECTOR, motivation: 'assessing' });
-    });
-
-    await waitFor(() => {
-      expect(screen.getByTestId('pending-motivation')).toHaveTextContent('assessing');
-    });
-
-    act(() => {
-      emit('mark:cancel-pending', undefined);
-    });
-
-    await waitFor(() => {
-      expect(screen.getByTestId('pending-motivation')).toHaveTextContent('none');
-    });
-
-    // API should NOT have been called on cancel
-    expect(markAnnotationSpy).not.toHaveBeenCalled();
-  });
-});

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

@@ -1,245 +0,0 @@
-/**
- * Layer 3: Feature Integration Test - Annotation Deletion Flow Architecture
- *
- * Tests the COMPLETE annotation deletion flow with real component composition:
- * - EventBusProvider (REAL)
- * - ApiClientProvider (REAL, with MOCKED client)
- * - useMarkFlow (REAL) — single registration point for useBindFlow
- * - useEventSubscriptions (REAL)
- *
- * This test focuses on ARCHITECTURE and EVENT WIRING:
- * - Verifies deletion API called exactly ONCE (catches duplicate subscriptions)
- * - Tests event propagation through the event bus
- * - Validates success/failure event emissions
- * - Ensures auth token is passed correctly
- *
- * CRITICAL: This test prevents regressions where:
- * - Multiple deletion paths exist (event-driven vs direct)
- * - useBindFlow called in more than one hook (causes duplicate subscriptions)
- * - Auth token missing from API calls (401 errors)
- *
- * ARCHITECTURE: useBindFlow is called ONLY in useMarkFlow.
- * useMarkFlow handles all detection state (manual annotation selection
- * and AI-driven SSE detection) plus all API operations via useBindFlow.
- */
-
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { render, waitFor } from '@testing-library/react';
-import { act } from 'react';
-import { useMarkFlow } from '../../../hooks/useMarkFlow';
-import { useStoreTokenSync } from '../../../hooks/useStoreTokenSync';
-import { EventBusProvider, useEventBus } from '../../../contexts/EventBusContext';
-
-// Mock Toast module to prevent "useToast must be used within a ToastProvider" errors
-vi.mock('../../../components/Toast', () => ({
-  useToast: () => ({
-    showSuccess: vi.fn(),
-    showError: vi.fn(),
-    showInfo: vi.fn(),
-    showWarning: vi.fn(),
-  }),
-}));
-import { ApiClientProvider } from '../../../contexts/ApiClientContext';
-import { AuthTokenProvider } from '../../../contexts/AuthTokenContext';
-import { SemiontApiClient } from '@semiont/api-client';
-import { resourceId, accessToken, annotationId as toAnnotationId } from '@semiont/core';
-
-describe('Annotation Deletion - Feature Integration', () => {
-  let deleteAnnotationSpy: ReturnType<typeof vi.fn>;
-  const testId = resourceId('test-resource');
-  const testToken = 'test-token-123';
-  const testBaseUrl = 'http://localhost:4000';
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-
-    // Mock the deleteAnnotation method on SemiontApiClient prototype
-    deleteAnnotationSpy = vi.fn().mockResolvedValue({ success: true });
-    vi.spyOn(SemiontApiClient.prototype, 'deleteAnnotation').mockImplementation(deleteAnnotationSpy);
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  /**
-   * Helper to render the annotation flow with real providers
-   */
-  function renderAnnotationFlow() {
-    let eventBusInstance: ReturnType<typeof useEventBus> | null = null;
-
-    function TestComponent() {
-      eventBusInstance = useEventBus();
-      useStoreTokenSync(); // Syncs auth token to namespace getToken
-      useMarkFlow(testId);
-      return null;
-    }
-
-    render(
-      <AuthTokenProvider token={testToken}>
-        <EventBusProvider>
-          <ApiClientProvider baseUrl={testBaseUrl}>
-            <TestComponent />
-          </ApiClientProvider>
-        </EventBusProvider>
-      </AuthTokenProvider>
-    );
-
-    return {
-      emitDelete: (annotationId: string) => {
-        act(() => {
-          eventBusInstance!.get('mark:delete').next({ annotationId: toAnnotationId(annotationId) });
-        });
-      },
-      eventBus: eventBusInstance!,
-    };
-  }
-
-  it('should call deleteAnnotation API exactly ONCE when mark:deleteevent is emitted', async () => {
-    const { emitDelete } = renderAnnotationFlow();
-    const annotationId = 'annotation-123';
-
-    // Trigger deletion via event bus (how UI triggers it)
-    emitDelete(annotationId);
-
-    // CRITICAL ASSERTION: API called exactly once (not twice!)
-    // This would FAIL if there were competing deletion paths
-    await waitFor(() => {
-      expect(deleteAnnotationSpy).toHaveBeenCalledTimes(1);
-    });
-
-    // Verify correct parameters (resourceId, annotationId, opts)
-    expect(deleteAnnotationSpy).toHaveBeenCalledWith(
-      'test-resource',
-      expect.stringContaining(annotationId),
-      expect.objectContaining({
-        auth: accessToken(testToken),
-      })
-    );
-  });
-
-  it('should pass auth token to API call (prevents 401 errors)', async () => {
-    const { emitDelete } = renderAnnotationFlow();
-
-    emitDelete('annotation-456');
-
-    await waitFor(() => {
-      expect(deleteAnnotationSpy).toHaveBeenCalled();
-    });
-
-    // CRITICAL: Auth token must be present (3rd arg is opts)
-    const callArgs = deleteAnnotationSpy.mock.calls[0];
-    expect(callArgs[2]).toHaveProperty('auth');
-    expect(callArgs[2].auth).toBe(accessToken(testToken));
-  });
-
-  it('should emit mark:deleted event on successful deletion', async () => {
-    const { emitDelete, eventBus } = renderAnnotationFlow();
-    const deletedListener = vi.fn();
-
-    // Subscribe to success event
-    eventBus.get('mark:delete-ok').subscribe(deletedListener);
-
-    emitDelete('annotation-789');
-
-    // Wait for API call to complete
-    await waitFor(() => {
-      expect(deleteAnnotationSpy).toHaveBeenCalled();
-    });
-
-    // Verify success event was emitted
-    await waitFor(() => {
-      expect(deletedListener).toHaveBeenCalledWith({
-        annotationId: 'annotation-789',
-      });
-    });
-  });
-
-  it('should emit mark:delete-failed event on API error', async () => {
-    // Make API call fail
-    deleteAnnotationSpy.mockRejectedValue(new Error('Network error'));
-
-    const { emitDelete, eventBus } = renderAnnotationFlow();
-    const failedListener = vi.fn();
-
-    // Subscribe to failure event
-    eventBus.get('mark:delete-failed').subscribe(failedListener);
-
-    emitDelete('annotation-error');
-
-    // Wait for API call to be attempted
-    await waitFor(() => {
-      expect(deleteAnnotationSpy).toHaveBeenCalled();
-    });
-
-    // Verify failure event was emitted
-    await waitFor(() => {
-      expect(failedListener).toHaveBeenCalledWith({
-        message: expect.any(String),
-      });
-    });
-  });
-
-  it('should handle multiple deletions in sequence without duplicate API calls', async () => {
-    const { emitDelete } = renderAnnotationFlow();
-
-    // Delete first annotation
-    emitDelete('annotation-1');
-
-    await waitFor(() => {
-      expect(deleteAnnotationSpy).toHaveBeenCalledTimes(1);
-    });
-
-    // Delete second annotation
-    emitDelete('annotation-2');
-
-    await waitFor(() => {
-      expect(deleteAnnotationSpy).toHaveBeenCalledTimes(2);
-    });
-
-    // Verify each call had correct annotation ID (2nd arg)
-    expect(deleteAnnotationSpy.mock.calls[0][1]).toContain('annotation-1');
-    expect(deleteAnnotationSpy.mock.calls[1][1]).toContain('annotation-2');
-  });
-
-  it('ARCHITECTURE: useBindFlow is called in useMarkFlow (single registration point)', async () => {
-    /**
-     * This test validates that there's only ONE event-driven deletion path:
-     * - useMarkFlow calls useBindFlow (the single registration point)
-     * - useBindFlow subscribes to annotation:delete
-     *
-     * If this test fails with 2 API calls, it means useBindFlow was added
-     * to a second hook, causing duplicate subscriptions (ARCHITECTURE VIOLATION).
-     */
-
-    const { emitDelete } = renderAnnotationFlow();
-
-    emitDelete('architecture-test');
-
-    // Single API call = single subscription = correct architecture
-    await waitFor(() => {
-      expect(deleteAnnotationSpy).toHaveBeenCalledTimes(1);
-    });
-  });
-
-  it('REGRESSION: No direct deleteAnnotation function in ResourceAnnotationsContext', () => {
-    /**
-     * This test prevents regression to the old pattern where
-     * ResourceAnnotationsContext had a deleteAnnotation function
-     * that bypassed the event bus.
-     *
-     * The correct pattern is event-driven only:
-     * - UI emits mark:deleteevent
-     * - useBindFlow handles it
-     * - No direct function calls
-     */
-
-    // This would fail to compile if deleteAnnotation was added back to context
-    // Type-level enforcement via TypeScript
-    const { emitDelete } = renderAnnotationFlow();
-    emitDelete('regression-test');
-
-    // Deletion still works via events
-    expect(deleteAnnotationSpy).toHaveBeenCalled();
-  });
-});