@semiont/react-ui 0.5.27 → 0.5.29

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';
 
@@ -71,7 +73,7 @@ function createEventTracker() {
       eventBus.get('yield:clone').subscribe((payload: any) => {
         events.push({ event: 'yield:clone', payload });
       });
-      // `mark:archive` / `mark:unarchive` are backend-routed via `actor.emit`;
+      // `mark:archive` / `mark:unarchive` are gateway-routed via `actor.emit`;
       // spy on the namespace methods instead of subscribing to a local bus.
       const origArchive = client.mark.archive.bind(client.mark);
       const origUnarchive = client.mark.unarchive.bind(client.mark);
@@ -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/auth/__tests__/SignInForm.a11y.test.tsx

@@ -29,8 +29,8 @@ const mockTranslations = {
   welcomeBack: 'Welcome back to Semiont',
   signInPrompt: 'Sign in to your knowledge workspace',
   continueWithGoogle: 'Continue with Google',
-  backendUrlLabel: 'Backend URL',
-  backendUrlPlaceholder: 'http://localhost:4000',
+  gatewayUrlLabel: 'Gateway URL',
+  gatewayUrlPlaceholder: 'http://localhost:4000',
   emailLabel: 'Email',
   emailPlaceholder: 'your@email.com',
   passwordLabel: 'Password',
@@ -44,9 +44,9 @@ const mockTranslations = {
   signUpInstead: 'Sign Up Instead',
   errorEmailRequired: 'Email is required',
   errorPasswordRequired: 'Password is required',
-  errorBackendUrlRequired: 'Backend URL is required',
-  errorBackendUrlInvalid: 'Backend URL is not valid',
-  errorBackendUrlUnreachable: 'Backend URL is unreachable',
+  errorGatewayUrlRequired: 'Gateway URL is required',
+  errorGatewayUrlInvalid: 'Gateway URL is not valid',
+  errorGatewayUrlUnreachable: 'Gateway URL is unreachable',
   tagline: 'make meaning',
 };
 
@@ -58,7 +58,7 @@ describe('SignInForm - Accessibility', () => {
       const { container } = render(
         <SignInForm
           onGoogleSignIn={onGoogleSignIn}
-          backendUrl="http://localhost:4000"
+          gatewayUrl="http://localhost:4000"
           Link={MockLink}
           translations={mockTranslations}
         />
@@ -206,7 +206,7 @@ describe('SignInForm - Accessibility', () => {
       render(
         <SignInForm
           onGoogleSignIn={onGoogleSignIn}
-          backendUrl="http://localhost:4000"
+          gatewayUrl="http://localhost:4000"
           Link={MockLink}
           translations={mockTranslations}
         />
@@ -244,7 +244,7 @@ describe('SignInForm - Accessibility', () => {
       render(
         <SignInForm
           onGoogleSignIn={onGoogleSignIn}
-          backendUrl="http://localhost:4000"
+          gatewayUrl="http://localhost:4000"
           Link={MockLink}
           translations={mockTranslations}
         />
@@ -261,7 +261,7 @@ describe('SignInForm - Accessibility', () => {
       render(
         <SignInForm
           onGoogleSignIn={onGoogleSignIn}
-          backendUrl="http://localhost:4000"
+          gatewayUrl="http://localhost:4000"
           Link={MockLink}
           translations={mockTranslations}
         />
@@ -361,7 +361,7 @@ describe('SignInForm - Accessibility', () => {
       render(
         <SignInForm
           onGoogleSignIn={onGoogleSignIn}
-          backendUrl="http://localhost:4000"
+          gatewayUrl="http://localhost:4000"
           Link={MockLink}
           translations={mockTranslations}
         />
@@ -379,7 +379,7 @@ describe('SignInForm - Accessibility', () => {
       const { container } = render(
         <SignInForm
           onGoogleSignIn={onGoogleSignIn}
-          backendUrl="http://localhost:4000"
+          gatewayUrl="http://localhost:4000"
           Link={MockLink}
           translations={mockTranslations}
         />
@@ -397,7 +397,7 @@ describe('SignInForm - Accessibility', () => {
       const { container } = render(
         <SignInForm
           onGoogleSignIn={onGoogleSignIn}
-          backendUrl="http://localhost:4000"
+          gatewayUrl="http://localhost:4000"
           Link={MockLink}
           translations={mockTranslations}
         />

package/src/features/auth/components/SignInForm.tsx

@@ -4,8 +4,8 @@
  * Supports both Google OAuth and email/password credentials.
  * No Next.js dependencies - all data via props.
  *
- * When backendUrl is provided it is shown as a locked read-only field.
- * When backendUrl is omitted the user must enter a backend URL to connect to.
+ * When gatewayUrl is provided it is shown as a locked read-only field.
+ * When gatewayUrl is omitted the user must enter a gateway URL to connect to.
  */
 
 import React from 'react';
@@ -15,21 +15,21 @@ import '../auth.css';
 export interface SignInFormProps {
   /**
    * Callback when user clicks Google sign-in.
-   * Receives the backend URL (either the locked one or what the user typed).
+   * Receives the gateway URL (either the locked one or what the user typed).
    */
-  onGoogleSignIn: (backendUrl: string) => Promise<void>;
+  onGoogleSignIn: (gatewayUrl: string) => Promise<void>;
 
   /**
    * Callback when user submits email/password credentials.
-   * Receives the backend URL along with email and password.
+   * Receives the gateway URL along with email and password.
    */
-  onCredentialsSignIn?: ((backendUrl: string, email: string, password: string) => Promise<void>) | undefined;
+  onCredentialsSignIn?: ((gatewayUrl: string, email: string, password: string) => Promise<void>) | undefined;
 
   /**
-   * Pre-filled backend URL. When provided the field is read-only (re-auth to known workspace).
+   * Pre-filled gateway URL. When provided the field is read-only (re-auth to known workspace).
    * When omitted the user enters the URL themselves (new connection).
    */
-  backendUrl?: string;
+  gatewayUrl?: string;
 
   /**
    * Error message to display (if any)
@@ -59,8 +59,8 @@ export interface SignInFormProps {
     welcomeBack: string;
     signInPrompt: string;
     continueWithGoogle: string;
-    backendUrlLabel: string;
-    backendUrlPlaceholder: string;
+    gatewayUrlLabel: string;
+    gatewayUrlPlaceholder: string;
     emailLabel: string;
     emailPlaceholder: string;
     passwordLabel: string;
@@ -72,9 +72,9 @@ export interface SignInFormProps {
     backToHome: string;
     learnMore: string;
     signUpInstead: string;
-    errorBackendUrlRequired: string;
-    errorBackendUrlInvalid: string;
-    errorBackendUrlUnreachable: string;
+    errorGatewayUrlRequired: string;
+    errorGatewayUrlInvalid: string;
+    errorGatewayUrlUnreachable: string;
     errorEmailRequired: string;
     errorPasswordRequired: string;
     tagline: string;
@@ -117,23 +117,23 @@ function normalizeUrlForProbe(raw: string): string | null {
 }
 
 /**
- * CredentialsAuthForm - Backend URL + email/password form.
- * When lockedBackendUrl is provided, the URL field is shown read-only.
+ * CredentialsAuthForm - Gateway URL + email/password form.
+ * When lockedGatewayUrl is provided, the URL field is shown read-only.
  */
 function CredentialsAuthForm({
-  lockedBackendUrl,
+  lockedGatewayUrl,
   onSubmit,
   translations: t,
 }: {
-  lockedBackendUrl: string | undefined;
-  onSubmit: (backendUrl: string, email: string, password: string) => Promise<void>;
+  lockedGatewayUrl: string | undefined;
+  onSubmit: (gatewayUrl: string, email: string, password: string) => Promise<void>;
   translations: SignInFormProps['translations'];
 }) {
-  const [backendUrl, setBackendUrl] = React.useState(lockedBackendUrl ?? '');
+  const [gatewayUrl, setGatewayUrl] = React.useState(lockedGatewayUrl ?? '');
   const [email, setEmail] = React.useState('');
   const [password, setPassword] = React.useState('');
   const [validationError, setValidationError] = React.useState<string | null>(null);
-  const [fieldErrors, setFieldErrors] = React.useState<{ backendUrl?: string; email?: string; password?: string }>({});
+  const [fieldErrors, setFieldErrors] = React.useState<{ gatewayUrl?: string; email?: string; password?: string }>({});
   const [urlProbeStatus, setUrlProbeStatus] = React.useState<UrlProbeStatus>('idle');
 
   const probeUrl = async (raw: string) => {
@@ -141,7 +141,7 @@ function CredentialsAuthForm({
     if (!url) return;
     // Validate format
     try { new URL(url); } catch {
-      setFieldErrors(prev => ({ ...prev, backendUrl: t.errorBackendUrlInvalid }));
+      setFieldErrors(prev => ({ ...prev, gatewayUrl: t.errorGatewayUrlInvalid }));
       setUrlProbeStatus('error');
       return;
     }
@@ -150,19 +150,19 @@ function CredentialsAuthForm({
       const res = await fetch(`${url}/api/health`, { signal: AbortSignal.timeout(5000) });
       setUrlProbeStatus(res.ok ? 'ok' : 'error');
       if (!res.ok) {
-        setFieldErrors(prev => ({ ...prev, backendUrl: t.errorBackendUrlUnreachable }));
+        setFieldErrors(prev => ({ ...prev, gatewayUrl: t.errorGatewayUrlUnreachable }));
       }
     } catch {
       setUrlProbeStatus('error');
-      setFieldErrors(prev => ({ ...prev, backendUrl: t.errorBackendUrlUnreachable }));
+      setFieldErrors(prev => ({ ...prev, gatewayUrl: t.errorGatewayUrlUnreachable }));
     }
   };
 
   const handleSubmit = async (e: React.FormEvent) => {
     e.preventDefault();
-    const errors: { backendUrl?: string; email?: string; password?: string } = {};
+    const errors: { gatewayUrl?: string; email?: string; password?: string } = {};
 
-    if (!backendUrl.trim()) errors.backendUrl = t.errorBackendUrlRequired;
+    if (!gatewayUrl.trim()) errors.gatewayUrl = t.errorGatewayUrlRequired;
     if (!email) errors.email = t.errorEmailRequired;
     if (!password) errors.password = t.errorPasswordRequired;
 
@@ -174,10 +174,10 @@ function CredentialsAuthForm({
 
     setFieldErrors({});
     setValidationError(null);
-    await onSubmit(backendUrl.trim(), email, password);
+    await onSubmit(gatewayUrl.trim(), email, password);
   };
 
-  const probeIndicator = !lockedBackendUrl && urlProbeStatus !== 'idle' ? (
+  const probeIndicator = !lockedGatewayUrl && urlProbeStatus !== 'idle' ? (
     <span
       className={`semiont-form__url-status semiont-form__url-status--${urlProbeStatus}`}
       aria-live="polite"
@@ -198,33 +198,33 @@ function CredentialsAuthForm({
 
       <form onSubmit={handleSubmit} className="semiont-auth__form" noValidate>
         <div className="semiont-form__field">
-          <label htmlFor="backend-url" className="semiont-form__label">
-            {t.backendUrlLabel}
+          <label htmlFor="gateway-url" className="semiont-form__label">
+            {t.gatewayUrlLabel}
           </label>
           <div className="semiont-form__input-row">
             <input
-              id="backend-url"
+              id="gateway-url"
               type="url"
-              value={backendUrl}
+              value={gatewayUrl}
               onChange={(e) => {
-                if (lockedBackendUrl) return;
-                setBackendUrl(e.target.value);
+                if (lockedGatewayUrl) return;
+                setGatewayUrl(e.target.value);
                 setUrlProbeStatus('idle');
-                if (fieldErrors.backendUrl) setFieldErrors({ ...fieldErrors, backendUrl: undefined });
+                if (fieldErrors.gatewayUrl) setFieldErrors({ ...fieldErrors, gatewayUrl: undefined });
               }}
-              onBlur={() => { if (!lockedBackendUrl) probeUrl(backendUrl); }}
-              readOnly={!!lockedBackendUrl}
-              placeholder={t.backendUrlPlaceholder}
-              className={`semiont-input${lockedBackendUrl ? ' semiont-input--readonly' : ''}`}
-              aria-invalid={!!fieldErrors.backendUrl}
-              aria-describedby={fieldErrors.backendUrl ? 'backend-url-error' : undefined}
+              onBlur={() => { if (!lockedGatewayUrl) probeUrl(gatewayUrl); }}
+              readOnly={!!lockedGatewayUrl}
+              placeholder={t.gatewayUrlPlaceholder}
+              className={`semiont-input${lockedGatewayUrl ? ' semiont-input--readonly' : ''}`}
+              aria-invalid={!!fieldErrors.gatewayUrl}
+              aria-describedby={fieldErrors.gatewayUrl ? 'gateway-url-error' : undefined}
               required
             />
             {probeIndicator}
           </div>
-          {fieldErrors.backendUrl && (
-            <span id="backend-url-error" className="semiont-form__error" role="alert">
-              {fieldErrors.backendUrl}
+          {fieldErrors.gatewayUrl && (
+            <span id="gateway-url-error" className="semiont-form__error" role="alert">
+              {fieldErrors.gatewayUrl}
             </span>
           )}
         </div>
@@ -295,23 +295,23 @@ function CredentialsAuthForm({
 /**
  * SignInForm - Main sign-in / connect component.
  *
- * When backendUrl is provided (re-auth to known workspace) the URL field is locked.
- * When backendUrl is omitted (new connection) the user enters the URL themselves.
+ * When gatewayUrl is provided (re-auth to known workspace) the URL field is locked.
+ * When gatewayUrl is omitted (new connection) the user enters the URL themselves.
  */
 export function SignInForm({
   onGoogleSignIn,
   onCredentialsSignIn,
-  backendUrl,
+  gatewayUrl,
   error,
   showCredentialsAuth = false,
   isLoading = false,
   translations: t,
 }: SignInFormProps) {
   const handleGoogleClick = () => {
-    // For Google auth we need the backend URL from the locked prop or we cannot proceed.
-    // The caller is responsible for ensuring backendUrl is set when Google sign-in is offered.
-    if (backendUrl) {
-      onGoogleSignIn(backendUrl);
+    // For Google auth we need the gateway URL from the locked prop or we cannot proceed.
+    // The caller is responsible for ensuring gatewayUrl is set when Google sign-in is offered.
+    if (gatewayUrl) {
+      onGoogleSignIn(gatewayUrl);
     }
   };
 
@@ -348,14 +348,14 @@ export function SignInForm({
               <>
                 {showCredentialsAuth && onCredentialsSignIn && (
                   <CredentialsAuthForm
-                    lockedBackendUrl={backendUrl}
+                    lockedGatewayUrl={gatewayUrl}
                     onSubmit={onCredentialsSignIn}
                     translations={t}
                   />
                 )}
 
-                {/* Google sign-in only shown when a backend URL is known */}
-                {backendUrl && (
+                {/* Google sign-in only shown when a gateway URL is known */}
+                {gatewayUrl && (
                   <button onClick={handleGoogleClick} className={`${buttonStyles.primary.base} semiont-button--full-width`}>
                     <GoogleIcon />
                     {t.continueWithGoogle}

package/src/features/auth-welcome/state/__tests__/welcome-state-unit.test.ts

@@ -3,7 +3,7 @@ import { firstValueFrom } from 'rxjs';
 import { filter } from 'rxjs/operators';
 import type { SemiontSession } from '@semiont/sdk';
 import { AuthNamespace } from '@semiont/sdk';
-import { createTestSession, stubBackend } from '@semiont/sdk/testing';
+import { createTestSession, stubGateway } from '@semiont/sdk/testing';
 import { createWelcomeStateUnit } from '../welcome-state-unit';
 import { assertStateUnitAxioms } from '@semiont/core/testing/axioms';
 
@@ -25,7 +25,7 @@ afterEach(() => {
 });
 
 function makeSession(): SemiontSession {
-  return createTestSession({ backend: stubBackend() }).session;
+  return createTestSession({ gateway: stubGateway() }).session;
 }
 
 describe('createWelcomeStateUnit', () => {

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();