@semiont/react-ui 0.5.27 → 0.5.28

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

@@ -1,13 +1,17 @@
 'use client';
 
 import { useTranslations } from '../../../contexts/TranslationContext';
-import type { SemiontSession } from '@semiont/sdk';
+import { readyValue, type SemiontSession, type YieldOutcome } from '@semiont/sdk';
 import { formatLocaleDisplay } from '@semiont/core';
 import { resourceId as makeResourceId, type components } from '@semiont/core';
+import { useObservable } from '../../../hooks/useObservable';
 import { renderAgentLabel } from './agent-label';
+import { AssistShell } from './AssistShell';
+import { assistProgressTranslations } from '../../../lib/assist-progress-copy';
 import './ResourceInfoPanel.css';
 
 type Agent = components['schemas']['Agent'];
+type JobProgress = components['schemas']['JobProgress'];
 
 interface Props {
   /** Session carrying the client and event bus; null renders inert. */
@@ -30,6 +34,17 @@ interface Props {
    * to a verb). Omit to hide the Generate action.
    */
   onGenerate?: () => void;
+  /**
+   * Generation lifecycle, page-held (`yield.isGenerating$` / `yield.progress$`
+   * / `yield.outcome$`): this panel is generation's progress surface
+   * (GENERATE-FROM-RESOURCE D7) — the run reports where it was started.
+   */
+  isGenerating?: boolean;
+  generationProgress?: JobProgress | null;
+  /** The finished run's result; the ended frame links it by name (D8). */
+  generationOutcome?: YieldOutcome | null;
+  /** Clear the finished display — wires `yield.dismissProgress()`. */
+  onDismissProgress?: () => void;
 }
 
 /**
@@ -54,8 +69,13 @@ export function ResourceInfoPanel({
   wasDerivedFrom,
   generator,
   onGenerate,
+  isGenerating = false,
+  generationProgress = null,
+  generationOutcome = null,
+  onDismissProgress,
 }: Props) {
   const t = useTranslations('ResourceInfoPanel');
+  const ta = useTranslations('AssistProgress');
 
   // Single attribution surface. `wasAttributedTo` is the canonical list
   // of responsible parties; if a producer set only `generator` we
@@ -152,13 +172,7 @@ export function ResourceInfoPanel({
                 <span className="semiont-resource-info-panel__label">{t('derivedFrom')}</span>
                 <span className="semiont-resource-info-panel__value">
                   {(Array.isArray(wasDerivedFrom) ? wasDerivedFrom : [wasDerivedFrom]).map((id, i) => (
-                    <button
-                      key={id}
-                      className="semiont-resource-info-panel__link"
-                      onClick={() => session?.client.browse.openResource(makeResourceId(id))}
-                    >
-                      {i > 0 && ', '}{id}
-                    </button>
+                    <DerivedFromLink key={id} session={session} id={id} first={i === 0} />
                   ))}
                 </span>
               </div>
@@ -185,19 +199,47 @@ export function ResourceInfoPanel({
         </div>
       )}
 
-      {/* Generate Action — opens the resource-generate flow (UI-only) */}
+      {/* Generate — the run reports where it was started (GENERATE-FROM-RESOURCE
+          D7): the same AssistShell every assist uses, its form the Generate
+          control, the progress frame in its place while a generation runs. */}
       {onGenerate && (
-        <div className="semiont-resource-info-panel__action-section">
-          <button
-            onClick={onGenerate}
-            className="semiont-resource-button semiont-resource-button--secondary"
-          >
-            ✨ {t('generate')}
-          </button>
-          <p className="semiont-resource-info-panel__description">
-            {t('generateDescription')}
-          </p>
-        </div>
+        <AssistShell
+          assistType="generation"
+          title={t('generate')}
+          isAssisting={isGenerating}
+          progress={generationProgress}
+          progressProps={{
+            onCancel: () => session?.client.job.cancelRequest('generation'),
+            ...(onDismissProgress ? { onDismiss: onDismissProgress } : {}),
+            ...(generationOutcome ? {
+              outcome: {
+                label: generationOutcome.resourceName,
+                onOpen: () => session?.client.browse.openResource(generationOutcome.resourceId),
+              },
+              // The terminal sentence derives from the OUTCOME, not the final
+              // progress frame — whose fire-and-forget emit can lose the race
+              // with job:complete and leave "creating…" beside a ✅
+              // (GENERATION-ARRIVAL D4/D5).
+              endedMessage: generationOutcome.truncated
+                ? ta('codeCompleteGeneratedTruncated')
+                : ta('codeCompleteGenerated'),
+            } : {}),
+            translations: assistProgressTranslations(ta),
+          }}
+          form={
+            <>
+              <button
+                onClick={onGenerate}
+                className="semiont-resource-button semiont-resource-button--secondary"
+              >
+                ✨ {t('generate')}
+              </button>
+              <p className="semiont-resource-info-panel__description">
+                {t('generateDescription')}
+              </p>
+            </>
+          }
+        />
       )}
 
       {/* Clone Action */}
@@ -244,3 +286,30 @@ export function ResourceInfoPanel({
     </div>
   );
 }
+
+/**
+ * One derived-from entry: linked by id (wire identity), labeled by the source
+ * resource's NAME once `browse.resource` serves its descriptor. The raw id is
+ * the honest label until then — and stays if the descriptor never resolves
+ * (deleted source, no session). Own component because the id list maps in a
+ * loop and the subscription is a hook.
+ */
+function DerivedFromLink({ session, id, first }: {
+  session: SemiontSession | null;
+  id: string;
+  first: boolean;
+}) {
+  // `browse.resource` is stable per id (cache + scope wrappers memoize), so
+  // subscribing straight off the render read is safe; `failed` is an emission,
+  // never a stream error, so `readyValue` covers every unresolved state.
+  const descriptor = useObservable(session ? session.client.browse.resource(makeResourceId(id)) : null);
+  const name = descriptor ? readyValue(descriptor)?.name : undefined;
+  return (
+    <button
+      className="semiont-resource-info-panel__link"
+      onClick={() => session?.client.browse.openResource(makeResourceId(id))}
+    >
+      {!first && ', '}{name ?? id}
+    </button>
+  );
+}

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

@@ -6,7 +6,7 @@ import type { components, Selector } from '@semiont/core';
 type JobProgress = components['schemas']['JobProgress'];
 import type { RouteBuilder, LinkComponentProps } from '../../../contexts/RoutingContext';
 import type { SemiontSession } from '@semiont/sdk';
-import { annotatorKeyForMotivation, type Annotator } from '../../../lib/annotation-registry';
+import { annotatorKeyForMotivation, type Annotator, type AnnotatorKey } from '../../../lib/annotation-registry';
 import { StatisticsPanel } from './StatisticsPanel';
 import { HighlightPanel } from './HighlightPanel';
 import { ReferencesPanel } from './ReferencesPanel';
@@ -17,7 +17,9 @@ import './UnifiedAnnotationsPanel.css';
 
 import type { Annotation } from '@semiont/core';
 type Motivation = components['schemas']['Motivation'];
-type TabKey = 'statistics' | 'reference' | 'highlight' | 'assessment' | 'comment' | 'tag';
+// Derived from the annotator registry (the single motivation↔annotator
+// source) — a hand-written union here could drift from it.
+type TabKey = 'statistics' | AnnotatorKey;
 
 // Unified pending annotation type
 interface PendingAnnotation {
@@ -76,6 +78,8 @@ interface UnifiedAnnotationsPanelProps {
   entityTypesError?: Error | null;
   referencedByError?: Error | null;
   onRetryReferencedBy?: () => void;
+  /** Annotations currently sparkling (recently created or resolved) — RESOLUTION-SPARKLE D6. */
+  sparkleAnnotationIds?: Set<string>;
 
   // Resource context — threaded to every per-motivation panel, which stamps it
   // as `source` on mark:submit (multi-viewer routing).
@@ -328,6 +332,7 @@ export function UnifiedAnnotationsPanel(props: UnifiedAnnotationsPanelProps) {
                 referencedByLoading={props.referencedByLoading}
                 referencedByError={props.referencedByError}
                 onRetryReferencedBy={props.onRetryReferencedBy}
+                sparkleAnnotationIds={props.sparkleAnnotationIds}
                 Link={props.Link}
                 routes={props.routes}
               />

package/src/components/resource/panels/__tests__/ReferenceEntry.test.tsx

@@ -94,6 +94,24 @@ describe('ReferenceEntry', () => {
     mockGetEntityTypes.mockReturnValue([]);
   });
 
+  // RESOLUTION-SPARKLE D6: a just-resolved reference announces itself on the
+  // panel entry's icon with the same `.annotation-sparkle` glow the document
+  // span uses. The host decides WHEN (membership in the sparkle set); the
+  // entry only renders the boolean.
+  describe('Resolution sparkle', () => {
+    it('carries the sparkle animation on the icon when sparkle is set', () => {
+      const { container } = renderEntry({ sparkle: true });
+
+      expect(container.querySelector('.semiont-reference-icon')).toHaveClass('annotation-sparkle');
+    });
+
+    it('does not sparkle by default', () => {
+      const { container } = renderEntry();
+
+      expect(container.querySelector('.semiont-reference-icon')).not.toHaveClass('annotation-sparkle');
+    });
+  });
+
   describe('Rendering', () => {
     it('should render the selected text in quotes', () => {
       renderEntry();
@@ -172,6 +190,29 @@ describe('ReferenceEntry', () => {
 
       expect(screen.getByText(/My Linked Document/)).toBeInTheDocument();
     });
+
+    it('a resource-level derivation headlines Derived, never the generic type label', () => {
+      // The provenance edge minted by resource-focus generation: no selector
+      // (nothing to quote), resolved body naming the derived resource. The
+      // generic "Annotation" label said nothing — the qualifier says what
+      // the entry IS; the link line below says what it points at. Inference
+      // is from shape (the wire vocabulary deliberately has no 'deriving'
+      // purpose); the unresolved case keeps the plain type label.
+      mockGetAnnotationExactText.mockReturnValue('');
+      mockIsBodyResolved.mockReturnValue(true);
+      mockGetBodySource.mockReturnValue('gen-doc');
+
+      const provenanceRef = {
+        ...createMockReference({ target: { source: 'resource-1' } }),
+        _resolvedDocumentName: 'generated from Cedar County, Iowa',
+      };
+
+      renderEntry({ reference: provenanceRef as Annotation });
+
+      expect(screen.getByText('ReferencesPanel.derived')).toBeInTheDocument();
+      expect(screen.queryByText('Annotation')).not.toBeInTheDocument();
+      expect(screen.getByText(/generated from Cedar County, Iowa/)).toBeInTheDocument();
+    });
   });
 
   describe('Entity types', () => {

package/src/components/resource/panels/__tests__/ReferencesPanel.test.tsx

@@ -4,7 +4,7 @@ import { render, screen, waitFor } from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
 import '@testing-library/jest-dom';
 import { ReferencesPanel } from '../ReferencesPanel';
-import type { EventBus } from '@semiont/core';
+import type { Annotation, AnnotationId, EventBus } from '@semiont/core';
 import type { SemiontSession } from '@semiont/sdk';
 import { createTestSemiontWrapper } from '../../../../test-utils';
 
@@ -118,6 +118,38 @@ describe('ReferencesPanel Component', () => {
     vi.restoreAllMocks();
   });
 
+  // RESOLUTION-SPARKLE D6: the panel threads the host's sparkle set down to
+  // the entries — exactly the ids in the set glow, nothing else.
+  describe('Resolution sparkle threading', () => {
+    const linkingReference = (id: string): Annotation => ({
+      '@context': 'http://www.w3.org/ns/anno.jsonld',
+      id: id as AnnotationId,
+      type: 'Annotation',
+      motivation: 'linking',
+      created: '2026-08-21T12:00:00Z',
+      modified: '2026-08-21T12:00:00Z',
+      target: {
+        source: 'res-1',
+        selector: { type: 'TextQuoteSelector', exact: `text of ${id}` },
+      },
+      body: { type: 'SpecificResource', source: 'linked-doc', purpose: 'linking' },
+    });
+
+    it('sparkles exactly the entries named by sparkleAnnotationIds', () => {
+      const { container } = renderWithEventBus(
+        <ReferencesPanel
+          {...panelProps()}
+          annotations={[linkingReference('ann-dark'), linkingReference('ann-lit')]}
+          sparkleAnnotationIds={new Set(['ann-lit'])}
+        />,
+      );
+
+      const sparkling = container.querySelectorAll('.semiont-reference-icon.annotation-sparkle');
+      expect(sparkling).toHaveLength(1);
+      expect(sparkling[0]!.closest('.semiont-annotation-entry')).toHaveTextContent('text of ann-lit');
+    });
+  });
+
   describe('Rendering', () => {
     it('should render panel with title', () => {
       renderWithEventBus(<ReferencesPanel {...panelProps()} />);

package/src/components/resource/panels/__tests__/ResourceInfoPanel.test.tsx

@@ -2,8 +2,10 @@ import { describe, it, expect, vi, beforeEach } from 'vitest';
 import React from 'react';
 import { render, screen, fireEvent, waitFor } from '@testing-library/react';
 import '@testing-library/jest-dom';
-import type { EventBus } from '@semiont/core';
-import type { SemiontClient, SemiontSession } from '@semiont/sdk';
+import { BehaviorSubject } from 'rxjs';
+import type { EventBus, ResourceDescriptor } from '@semiont/core';
+import { resourceId as makeResourceId } from '@semiont/core';
+import type { CacheObservable, CacheState, SemiontClient, SemiontSession } from '@semiont/sdk';
 import { ResourceInfoPanel } from '../ResourceInfoPanel';
 import { createTestSemiontWrapper } from '../../../../test-utils';
 
@@ -281,17 +283,19 @@ describe('ResourceInfoPanel Component', () => {
   });
 
   describe('Generate Action', () => {
+    // The shell's collapsible header is ALSO a button named "Generate", so the
+    // form control is targeted by its exact accessible name (the ✨ is part of it).
     it('renders the Generate button when onGenerate is provided', () => {
       renderWithEventBus(
         <ResourceInfoPanel {...defaultProps} onGenerate={() => {}} />
       );
-      expect(screen.getByRole('button', { name: /Generate/i })).toBeInTheDocument();
+      expect(screen.getByRole('button', { name: '✨ Generate' })).toBeInTheDocument();
       expect(screen.getByText("Generate a new resource from this one's context")).toBeInTheDocument();
     });
 
     it('hides the Generate button when onGenerate is omitted', () => {
       renderWithEventBus(<ResourceInfoPanel {...defaultProps} />);
-      expect(screen.queryByRole('button', { name: /Generate/i })).not.toBeInTheDocument();
+      expect(screen.queryByRole('button', { name: '✨ Generate' })).not.toBeInTheDocument();
     });
 
     it('calls onGenerate when clicked', () => {
@@ -299,9 +303,117 @@ describe('ResourceInfoPanel Component', () => {
       renderWithEventBus(
         <ResourceInfoPanel {...defaultProps} onGenerate={onGenerate} />
       );
-      fireEvent.click(screen.getByRole('button', { name: /Generate/i }));
+      fireEvent.click(screen.getByRole('button', { name: '✨ Generate' }));
       expect(onGenerate).toHaveBeenCalledTimes(1);
     });
+
+    // ── GENERATE-FROM-RESOURCE P2 (D7/D8): the panel is the progress surface ──
+
+    it('the Generate control lives inside the assist shell (D7)', () => {
+      const { container } = renderWithEventBus(
+        <ResourceInfoPanel {...defaultProps} onGenerate={() => {}}
+          isGenerating={false} generationProgress={null} />
+      );
+      const shell = container.querySelector('.semiont-assist-widget[data-type="generation"]');
+      expect(shell).not.toBeNull();
+      expect(shell!.querySelector('button')).not.toBeNull(); // the form IS the Generate control
+    });
+
+    it('progress replaces the Generate form while a generation runs', () => {
+      const { container } = renderWithEventBus(
+        <ResourceInfoPanel {...defaultProps} onGenerate={() => {}}
+          isGenerating
+          generationProgress={{ percentage: 40, message: { code: 'generating-resource' } }} />
+      );
+      expect(container.querySelector('.semiont-assist-progress')).not.toBeNull();
+      expect(screen.queryByRole('button', { name: '✨ Generate' })).toBeNull();
+    });
+
+    it('the ended frame links the generated resource by name, and dismisses (D8)', () => {
+      const onDismissProgress = vi.fn();
+      const { client } = renderWithEventBus(
+        <ResourceInfoPanel {...defaultProps} onGenerate={() => {}}
+          isGenerating={false}
+          generationProgress={{ percentage: 100, message: { code: 'complete-generated', truncated: false } }}
+          generationOutcome={{
+            resourceId: makeResourceId('urn:semiont:resource:new1'),
+            resourceName: 'Summary of PB',
+            truncated: false,
+          }}
+          onDismissProgress={onDismissProgress} />
+      );
+      const openSpy = vi.spyOn(client.browse, 'openResource');
+
+      fireEvent.click(screen.getByRole('button', { name: 'Summary of PB' }));
+      expect(openSpy).toHaveBeenCalledTimes(1);
+      expect(String(openSpy.mock.calls[0]![0])).toBe('urn:semiont:resource:new1');
+
+      fireEvent.click(screen.getByTestId('semiont-assist-control'));
+      expect(onDismissProgress).toHaveBeenCalledTimes(1);
+    });
+
+    it('a truncated completion says so; a natural stop does not (GFR P3b, D6)', () => {
+      // The mocked translator echoes unknown keys, so the assertion reads the
+      // KEY the real assistProgressCopy branch picked — structure, not copy.
+      const base = { ...defaultProps, onGenerate: () => {}, isGenerating: false };
+      const { unmount } = renderWithEventBus(
+        <ResourceInfoPanel {...base}
+          generationProgress={{ percentage: 100, message: { code: 'complete-generated', truncated: true } }} />
+      );
+      expect(screen.getByTestId('semiont-assist-status').textContent)
+        .toContain('codeCompleteGeneratedTruncated');
+      unmount();
+
+      renderWithEventBus(
+        <ResourceInfoPanel {...base}
+          generationProgress={{ percentage: 100, message: { code: 'complete-generated', truncated: false } }} />
+      );
+      expect(screen.getByTestId('semiont-assist-status').textContent)
+        .toContain('codeCompleteGenerated');
+      expect(screen.getByTestId('semiont-assist-status').textContent)
+        .not.toContain('Truncated');
+    });
+
+    it('the ended frame speaks completion even when the final progress frame lost the race (GENERATION-ARRIVAL D4/D5)', () => {
+      // The screenshot case: last frame is the 95% "creating" payload, the
+      // terminal 100% frame never arrived — but the outcome did. The sentence
+      // derives from the OUTCOME, not the racing frame.
+      renderWithEventBus(
+        <ResourceInfoPanel {...defaultProps} onGenerate={() => {}}
+          isGenerating={false}
+          generationProgress={{ percentage: 95, message: { code: 'creating-resource' } }}
+          generationOutcome={{
+            resourceId: makeResourceId('urn:semiont:resource:new1'),
+            resourceName: 'Summary of PB',
+            truncated: false,
+          }} />
+      );
+      expect(screen.getByTestId('semiont-assist-status').textContent).toBe('codeCompleteGenerated');
+    });
+
+    it('a truncated outcome says so — the bit rides the outcome, not the racing frame (D5)', () => {
+      renderWithEventBus(
+        <ResourceInfoPanel {...defaultProps} onGenerate={() => {}}
+          isGenerating={false}
+          generationProgress={{ percentage: 95, message: { code: 'creating-resource' } }}
+          generationOutcome={{
+            resourceId: makeResourceId('urn:semiont:resource:new1'),
+            resourceName: 'Summary of PB',
+            truncated: true,
+          }} />
+      );
+      expect(screen.getByTestId('semiont-assist-status').textContent).toBe('codeCompleteGeneratedTruncated');
+    });
+
+    it('no outcome, no link: the ended frame renders without one until job:complete arrives', () => {
+      renderWithEventBus(
+        <ResourceInfoPanel {...defaultProps} onGenerate={() => {}}
+          isGenerating={false}
+          generationProgress={{ percentage: 100, message: { code: 'complete-generated', truncated: false } }}
+          generationOutcome={null} />
+      );
+      expect(screen.queryByText('Summary of PB')).toBeNull();
+    });
   });
 
   describe('Provenance Section', () => {
@@ -350,7 +462,9 @@ describe('ResourceInfoPanel Component', () => {
       expect(screen.getByText('Alice, Bob')).toBeInTheDocument();
     });
 
-    it('should render wasDerivedFrom when provided', () => {
+    it('should render wasDerivedFrom when provided — the id is the unresolved fallback', () => {
+      // The factory client's fetch fails in jsdom (no server), so the
+      // descriptor never resolves and the raw id stays as the honest label.
       renderWithEventBus(
         <ResourceInfoPanel
           {...defaultProps}
@@ -382,6 +496,34 @@ describe('ResourceInfoPanel Component', () => {
       expect(String(openSpy.mock.calls[0]![0])).toBe('urn:semiont:resource:abc123');
     });
 
+    it('resolves the derived-from id to its resource NAME; clicks still navigate by id', () => {
+      // The id is wire identity, not presentation. Once `browse.resource`
+      // serves the source's descriptor, the link wears its name — the raw
+      // hash only survives while the descriptor is unresolved (pin below).
+      const { SemiontWrapper, session, client } = createTestSemiontWrapper();
+      vi.spyOn(client.browse, 'resource').mockReturnValue(
+        new BehaviorSubject<CacheState<ResourceDescriptor>>({
+          status: 'ready',
+          value: { '@id': 'urn:semiont:resource:abc123', name: 'Source Doc' } as ResourceDescriptor,
+        }) as unknown as CacheObservable<ResourceDescriptor>,
+      );
+      const openSpy = vi.spyOn(client.browse, 'openResource');
+      render(
+        <ResourceInfoPanel
+          {...defaultProps}
+          session={session}
+          wasDerivedFrom="urn:semiont:resource:abc123"
+        />,
+        { wrapper: ({ children }) => <SemiontWrapper>{children}</SemiontWrapper> },
+      );
+
+      expect(screen.getByText('Source Doc')).toBeInTheDocument();
+      expect(screen.queryByText('urn:semiont:resource:abc123')).toBeNull();
+
+      fireEvent.click(screen.getByText('Source Doc'));
+      expect(String(openSpy.mock.calls[0]![0])).toBe('urn:semiont:resource:abc123');
+    });
+
     it('renders every id when the resource derives from several', () => {
       renderWithEventBus(
         <ResourceInfoPanel

package/src/features/resource-compose/__tests__/ResourceComposePage.test.tsx

@@ -28,10 +28,7 @@ vi.mock('../../../components/CodeMirrorRenderer', () => ({
 const createMockTranslations = () => ({
   title: 'Compose Resource',
   titleEditClone: 'Edit Cloned Resource',
-  titleCompleteReference: 'Complete Reference',
   subtitleClone: 'Editing a cloned resource',
-  subtitleReference: 'Creating a new resource for reference',
-  linkedNoticePrefix: 'This resource will be linked',
   resourceName: 'Resource Name',
   resourceNamePlaceholder: 'Enter resource name',
   entityTypes: 'Entity Types',
@@ -53,9 +50,7 @@ const createMockTranslations = () => ({
   cancel: 'Cancel',
   saving: 'Saving...',
   creating: 'Creating...',
-  creatingAndLinking: 'Creating and linking...',
   saveClonedResource: 'Save Cloned Resource',
-  createAndLinkResource: 'Create and Link Resource',
   createResource: 'Create Resource',
 });
 
@@ -207,66 +202,6 @@ describe('ResourceComposePage', () => {
     });
   });
 
-  describe('Reference Completion Mode', () => {
-    it('shows reference completion title', () => {
-      const props = createMockProps({
-        mode: 'reference',
-        referenceData: {
-          annotationUri: 'http://localhost:8080/annotations/ref-1',
-          sourceDocumentId: 'doc-1',
-          name: 'Referenced Resource',
-          entityTypes: ['Document'],
-        },
-      });
-      renderWithProviders(<ResourceComposePage {...props} />);
-
-      expect(screen.getByText('Complete Reference')).toBeInTheDocument();
-      expect(screen.getByText('Creating a new resource for reference')).toBeInTheDocument();
-      expect(screen.getByText('This resource will be linked')).toBeInTheDocument();
-    });
-
-    it('initializes with reference data', () => {
-      const props = createMockProps({
-        mode: 'reference',
-        referenceData: {
-          annotationUri: 'http://localhost:8080/annotations/ref-1',
-          sourceDocumentId: 'doc-1',
-          name: 'Referenced Resource',
-          entityTypes: ['Document', 'Article'],
-        },
-      });
-      renderWithProviders(<ResourceComposePage {...props} />);
-
-      const nameInput = screen.getByLabelText('Resource Name') as HTMLInputElement;
-      expect(nameInput.value).toBe('Referenced Resource');
-
-      expect(screen.getByText('Document')).toBeInTheDocument();
-      expect(screen.getByText('Article')).toBeInTheDocument();
-    });
-
-    it('shows entity types as read-only when provided', () => {
-      const props = createMockProps({
-        mode: 'reference',
-        referenceData: {
-          annotationUri: 'http://localhost:8080/annotations/ref-1',
-          sourceDocumentId: 'doc-1',
-          name: 'Referenced Resource',
-          entityTypes: ['Document'],
-        },
-      });
-      renderWithProviders(<ResourceComposePage {...props} />);
-
-      // Should show read-only entity types
-      expect(screen.getByText('Document')).toBeInTheDocument();
-
-      // Should not show selectable buttons
-      expect(screen.queryByRole('button', { name: /Document entity type/ })).not.toBeInTheDocument();
-    });
-  });
-
-  // Entity Type Selection tests removed - functionality not present in current component
-  // The component only displays entity types in reference mode, doesn't have selection buttons
-
   describe('Content Input Method', () => {
     it('defaults to write mode', () => {
       const props = createMockProps();