@semiont/react-ui 0.5.27 → 0.5.29

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

@@ -14,7 +14,8 @@ import { ToastProvider } from '../../../components/Toast';
 import { ThemeProvider } from '../../../contexts/ThemeContext';
 import { LineNumbersProvider } from '../../../contexts/LineNumbersContext';
 import { createTestSemiontWrapper } from '../../../test-utils';
-import type { ResourceId } from '@semiont/core';
+import type { BodyOperation, EventMap, ResourceId, UserId } from '@semiont/core';
+import { annotationId as makeAnnotationId, resourceId as makeResourceId } from '@semiont/core';
 
 // jsdom doesn't implement window.matchMedia — mock it for useTheme
 Object.defineProperty(window, 'matchMedia', {
@@ -46,8 +47,8 @@ const { stubBrowser, stubClient } = vi.hoisted(() => {
   const { SemiontClient, HttpTransport, HttpContentTransport } = require('@semiont/sdk');
   const { baseUrl } = require('@semiont/core');
   const transport = new HttpTransport({ baseUrl: baseUrl('http://localhost:4000') });
-  // HttpTransport implements both ITransport and IBackendOperations; pass it
-  // as backend so `client.auth` (used by useMediaToken) is wired.
+  // HttpTransport implements both ITransport and IGatewayOperations; pass it
+  // as gateway so `client.auth` (used by useMediaToken) is wired.
   const client = new SemiontClient(transport, new HttpContentTransport(transport), transport);
   const stubActiveSession$ = new BehaviorSubject({ client });
   const stubOpenResources$ = new BehaviorSubject([]);
@@ -102,24 +103,22 @@ useDebouncedCallback: (fn: any) => fn,
       announceResourceLoaded: vi.fn(),
     }),
     useEventSubscriptions: vi.fn(),
-    useResourceAnnotations: () => ({
-      clearNewAnnotationId: vi.fn(),
-      newAnnotationIds: new Set(),
-      markAnnotation: vi.fn(),
-      deleteAnnotation: vi.fn(),
-      triggerSparkleAnimation: vi.fn(),
-    }),
+    useResourceAnnotations: () => sparkleContext,
   };
 });
 
+// Shared, assertable spies — the page's sparkle wiring is pinned against
+// these (a per-call `vi.fn()` object would be unobservable from the tests).
+const sparkleContext = vi.hoisted(() => ({
+  clearSparkle: vi.fn(),
+  sparkleAnnotationIds: new Set<string>(),
+  markAnnotation: vi.fn(),
+  deleteAnnotation: vi.fn(),
+  triggerSparkleAnimation: vi.fn(),
+}));
+
 vi.mock('../../../contexts/ResourceAnnotationsContext', () => ({
-  useResourceAnnotations: () => ({
-    clearNewAnnotationId: vi.fn(),
-    newAnnotationIds: new Set(),
-    markAnnotation: vi.fn(),
-    deleteAnnotation: vi.fn(),
-    triggerSparkleAnimation: vi.fn(),
-  }),
+  useResourceAnnotations: () => sparkleContext,
   ResourceAnnotationsProvider: ({ children }: any) => children,
 }));
 
@@ -206,6 +205,63 @@ describe('ResourceViewerPage — outcome toasts reach the user', () => {
   });
 });
 
+// RESOLUTION-SPARKLE D2: a reference resolving — from ANY strategy, local or
+// remote — arrives as mark:body-updated with a linking-add operation, and the
+// page turns exactly that into a sparkle. The harness mocks
+// useEventSubscriptions, so the pin drives the captured handler directly.
+describe('ResourceViewerPage — resolution sparkles', () => {
+  const bodyUpdated = (operations: BodyOperation[]): EventMap['mark:body-updated'] => ({
+    id: 'evt-1',
+    timestamp: '2026-08-21T12:00:00Z',
+    resourceId: makeResourceId('test-123'),
+    userId: 'did:web:example.com:users:alice' as UserId,
+    version: 1,
+    type: 'mark:body-updated',
+    payload: { annotationId: makeAnnotationId('ann-7'), operations },
+    metadata: { sequenceNumber: 1 },
+  });
+
+  const renderAndGetHandler = () => {
+    mockUseEventSubscriptions.mockClear();
+    sparkleContext.triggerSparkleAnimation.mockClear();
+    renderWithProviders(<ResourceViewerPage {...createMockProps()} />);
+    const map = mockUseEventSubscriptions.mock.calls.at(-1)?.[0] as
+      Record<string, (event: EventMap['mark:body-updated']) => void>;
+    return map['mark:body-updated'];
+  };
+
+  it('an operation adding a linking SpecificResource sparkles the annotation', () => {
+    const handler = renderAndGetHandler();
+    expect(handler).toBeDefined();
+
+    handler!(bodyUpdated([
+      { op: 'add', item: { type: 'SpecificResource', source: 'res-target', purpose: 'linking' } },
+    ]));
+
+    expect(sparkleContext.triggerSparkleAnimation).toHaveBeenCalledWith('ann-7');
+  });
+
+  it('unlink (remove-only operations) stays dark — A2', () => {
+    const handler = renderAndGetHandler();
+
+    handler?.(bodyUpdated([
+      { op: 'remove', item: { type: 'SpecificResource', source: 'res-target', purpose: 'linking' } },
+    ]));
+
+    expect(sparkleContext.triggerSparkleAnimation).not.toHaveBeenCalled();
+  });
+
+  it('a TextualBody add stays dark', () => {
+    const handler = renderAndGetHandler();
+
+    handler?.(bodyUpdated([
+      { op: 'add', item: { type: 'TextualBody', value: 'Person', purpose: 'tagging' } },
+    ]));
+
+    expect(sparkleContext.triggerSparkleAnimation).not.toHaveBeenCalled();
+  });
+});
+
 describe('ResourceViewerPage', () => {
   beforeEach(() => {
   });

package/src/features/resource-viewer/__tests__/generation-options.test.ts

@@ -0,0 +1,53 @@
+/**
+ * GENERATION-OUTPUT-FORMAT D8 — the submitted config becomes generation
+ * options in ONE place, by spread.
+ *
+ * Both page handlers used to build the options object field-by-field, so any
+ * field not explicitly listed was silently dropped. That is precisely what
+ * stranded `outputMediaType` in the SDK one layer down (P1), relocated one
+ * layer up. These pins state the PROPERTY — everything the config carries is
+ * forwarded — rather than enumerating today's fields, so a knob added later
+ * cannot regress the mode back into existence.
+ */
+import { describe, it, expect } from 'vitest';
+import type { GatheredContext } from '@semiont/core';
+import { toGenerationOptions } from '../generation-options';
+import type { GenerationConfig } from '../../../components/modals/ConfigureGenerationStep';
+
+const context = { focus: { kind: 'resource' } } as unknown as GatheredContext;
+
+const config: GenerationConfig = {
+  title: 'Cedar County',
+  storageUri: 'file://research/notes.pdf',
+  prompt: 'lead with the treaty',
+  language: 'en',
+  temperature: 0.7,
+  maxTokens: 500,
+  outputMediaType: 'application/pdf',
+  context,
+};
+
+describe('toGenerationOptions', () => {
+  it('forwards EVERY field the config carries except the context', () => {
+    // Stated structurally on purpose: the expectation is derived from the
+    // same object, so adding a field to GenerationConfig extends this pin
+    // automatically. A field-by-field assertion would have passed happily
+    // while the real handler dropped the new one.
+    const { context: _positional, ...forwarded } = config;
+    expect(toGenerationOptions(config, 'fr')).toMatchObject(forwarded);
+  });
+
+  it('does not pass the context as an option — it is the positional argument', () => {
+    expect(toGenerationOptions(config, 'fr')).not.toHaveProperty('context');
+  });
+
+  it('injects the sourceLanguage, which comes from the viewed resource and not the form', () => {
+    expect(toGenerationOptions(config, 'fr').sourceLanguage).toBe('fr');
+  });
+
+  it('omits sourceLanguage entirely when the resource has no language', () => {
+    // Absence must stay absence: a manufactured '' would tell the prompt the
+    // source is in a language named empty string.
+    expect(toGenerationOptions(config, undefined)).not.toHaveProperty('sourceLanguage');
+  });
+});

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

@@ -6,12 +6,12 @@
  */
 
 import React, { useState, useEffect, useCallback } from 'react';
-import { assistProgressTranslations } from '../../../lib/assist-progress-copy';
 import { useResourceViewedReport } from '../hooks/useResourceViewedReport';
-import type { components, ResourceDescriptor, ResourceId, GatheredContext, EventMap } from '@semiont/core';
+import type { components, ResourceDescriptor, ResourceId, EventMap } from '@semiont/core';
 import type { ConnectionState } from '@semiont/core';
-import { annotationId } from '@semiont/core';
-import { getLanguage, getPrimaryRepresentation, getPrimaryMediaType, capabilitiesOf } from '@semiont/core';
+import { annotationId, folderOf } from '@semiont/core';
+import type { ComposeParams } from '../../../components/modals/ComposeStep';
+import { getLanguage, getPrimaryRepresentation, getPrimaryMediaType, getStorageUri, capabilitiesOf, extensionForMediaType } from '@semiont/core';
 import { ANNOTATORS } from '@semiont/react-ui';
 import { ErrorBoundary } from '@semiont/react-ui';
 import { AnnotationHistory } from '@semiont/react-ui';
@@ -30,6 +30,7 @@ import { useCollaborators } from '../../../hooks/useCollaborators';
 import { mediaUrl } from '../../../lib/media-url';
 import { useToast } from '../../../components/Toast';
 import { useOutcomeToasts } from '../../../hooks/useOutcomeToasts';
+import { useGenerationArrival } from '../../../hooks/useGenerationArrival';
 import { useTheme } from '../../../contexts/ThemeContext';
 import { useLineNumbers } from '../../../contexts/LineNumbersContext';
 import { useHoverDelay } from '../../../hooks/useHoverDelay';
@@ -45,8 +46,8 @@ import { useShellStateUnit } from '../../../hooks/useShellStateUnit';
 import { useTranslations } from '../../../contexts/TranslationContext';
 import { ReferenceWizardModal } from '../../../components/modals/ReferenceWizardModal';
 import { ResourceGenerateModal } from '../../../components/modals/ResourceGenerateModal';
-import { AssistProgress } from '../../../components/AssistProgress';
 import type { GenerationConfig } from '../../../components/modals/ConfigureGenerationStep';
+import { toGenerationOptions } from '../generation-options';
 
 type SemiontResource = ResourceDescriptor;
 
@@ -120,6 +121,7 @@ export interface ResourceViewerPageProps {
  * @subscribes yield:clone - Clone the current resource
  * @subscribes beckon:sparkle - Trigger sparkle animation
  * @subscribes mark:added - Annotation was created (sparkle)
+ * @subscribes mark:body-updated - Reference resolved via a linking-add operation (sparkle, both loci)
  * @subscribes browse:resource-open - Open a resource in the viewer (local links + the launcher's tour verbs)
  * @subscribes browse:entity-type-clicked - Navigate filtered by entity type
  *
@@ -143,7 +145,6 @@ export function ResourceViewerPage({
   // Translations
   const tw = useTranslations('ReferenceWizard');
   const tg = useTranslations('ResourceGenerate');
-  const ta = useTranslations('AssistProgress');
 
   const browser = useSemiont();
   const session = useObservable(browser.activeSession$);
@@ -177,7 +178,7 @@ export function ResourceViewerPage({
   const { theme } = useTheme();
   const { showLineNumbers } = useLineNumbers();
   const { hoverDelayMs } = useHoverDelay();
-  const { triggerSparkleAnimation, clearNewAnnotationId, newAnnotationIds } = useResourceAnnotations();
+  const { triggerSparkleAnimation, clearSparkle, sparkleAnnotationIds } = useResourceAnnotations();
 
   // Render mode chooses the content path: 'text' decodes inline; 'image'
   // and 'pdf' go through the media-token (binary) path. 'none'/registry-miss
@@ -240,9 +241,27 @@ export function ResourceViewerPage({
   const onScrollCompleted = stateUnit?.browse.onScrollCompleted;
   const generationProgress = useObservable(stateUnit?.yield.progress$) ?? null;
   const isGenerating = useObservable(stateUnit?.yield.isGenerating$) ?? false;
+  const generationOutcome = useObservable(stateUnit?.yield.outcome$) ?? null;
+
+  // GENERATION-ARRIVAL P2: a completion witnessed on this page reveals the
+  // derivation edge the worker minted — the annotations panel opens on
+  // References, scrolls to the provenance reference, and its sparkle is
+  // re-armed (the mark:added glow burned its window unseen). Never navigates
+  // (A2); a held outcome on remount stays quiet (D6, inside the hook).
+  const handleGenerationArrival = useCallback((annId: string) => {
+    browser.emit('panel:open', { panel: 'annotations', scrollToAnnotationId: annId, motivation: 'linking' });
+    triggerSparkleAnimation(annId);
+  }, [browser, triggerSparkleAnimation]);
+  useGenerationArrival(generationOutcome, annotations, handleGenerationArrival);
+
   const gatherContext = useObservable(stateUnit?.gather.context$) ?? null;
   const gatherLoading = useObservable(stateUnit?.gather.loading$) ?? false;
   const gatherError = useObservable(stateUnit?.gather.error$) ?? null;
+  // Resource-gather slots (FLOW-LIFECYCLE-CONVERGENCE D2a: separate from the
+  // annotation slots above — the two gathers can be live at once).
+  const resourceGatherContext = useObservable(stateUnit?.gather.resourceContext$) ?? null;
+  const resourceGatherLoading = useObservable(stateUnit?.gather.resourceLoading$) ?? false;
+  const resourceGatherError = useObservable(stateUnit?.gather.resourceError$) ?? null;
   const wizardState = useObservable(stateUnit?.wizard$);
   const wizardOpen = wizardState?.open ?? false;
   const wizardAnnotationId = wizardState?.annotationId ?? null;
@@ -256,35 +275,19 @@ export function ResourceViewerPage({
   }, [stateUnit]);
 
   const handleWizardGenerateSubmit = useCallback((referenceId: string, config: GenerationConfig) => {
-    clearNewAnnotationId(annotationId(referenceId));
-    stateUnit?.yield.generate(config.context, {
-      title: config.title,
-      storageUri: config.storagePath,
-      prompt: config.prompt,
-      language: config.language,
-      // The source resource is the one the user is viewing — fed into the
-      // prompt so the LLM understands the embedded context (selected
-      // passage, surrounding text) regardless of UI/target language.
-      sourceLanguage: getLanguage(resource),
-      temperature: config.temperature,
-      maxTokens: config.maxTokens,
-    });
-  }, [stateUnit, clearNewAnnotationId, resource]);
+    clearSparkle(annotationId(referenceId));
+    // D8: forwarded by spread in ONE place, so a knob added to the form is
+    // never dropped on the way to the wire. `sourceLanguage` is the viewed
+    // resource's language — a page fact the form cannot know.
+    stateUnit?.yield.generate(config.context, toGenerationOptions(config, getLanguage(resource)));
+  }, [stateUnit, clearSparkle, resource]);
 
   // Resource-generate flow (GENERATE-FROM-BUTTON): drive the SAME yield progress$
   // the annotation path uses so the full `AssistProgress` widget shows — NOT a
   // toast. Both paths are one `generate(context, options)` now: the context's
   // focus.kind (resource here, annotation above) decides the shape.
   const handleResourceGenerateSubmit = useCallback((_resourceId: string, config: GenerationConfig) => {
-    stateUnit?.yield.generate(config.context, {
-      title: config.title,
-      storageUri: config.storagePath,
-      ...(config.prompt ? { prompt: config.prompt } : {}),
-      language: config.language,
-      sourceLanguage: getLanguage(resource),
-      temperature: config.temperature,
-      maxTokens: config.maxTokens,
-    });
+    stateUnit?.yield.generate(config.context, toGenerationOptions(config, getLanguage(resource)));
   }, [stateUnit, resource]);
 
   const handleWizardLinkResource = useCallback(async (referenceId: string, targetResourceId: string) => {
@@ -301,26 +304,43 @@ export function ResourceViewerPage({
     }
   }, [rUri, semiont, showSuccess, showError]);
 
-  const handleWizardComposeNavigate = useCallback((
-    context: GatheredContext,
-    annId: string,
-    resId: string,
-    title: string,
-    entTypes: string[],
-  ) => {
-    // Store context in sessionStorage for the compose page
-    sessionStorage.setItem(`gather-context:${annId}`, JSON.stringify(context));
-    const params = new URLSearchParams({
-      annotationUri: annId,
-      sourceDocumentId: resId,
-      name: title,
-      entityTypes: entTypes.join(','),
-    });
-    browser.emit('nav:push', {
-      path: `/know/compose?${params.toString()}`,
-      reason: 'compose-from-wizard',
-    });
-  }, [browser]);
+  // COMPOSE-IN-MODAL P3: create-and-link, in place. The old flow stashed the
+  // context in sessionStorage and navigated to the compose page; the modal
+  // already holds the context, so the side-channel dies with the mode.
+  // Text-only by design — uploads stay on the standalone compose page.
+  const handleWizardComposeSubmit = useCallback(async (referenceId: string, params: ComposeParams) => {
+    if (!semiont) throw new Error('No active session');
+    try {
+      const format = 'text/markdown';
+      const file = new File(
+        [new Blob([params.content], { type: format })],
+        params.name + extensionForMediaType(format),
+        { type: format },
+      );
+      const newResourceId = await new Promise<ResourceId>((resolve, reject) => {
+        semiont.yield.resource({
+          name: params.name,
+          file,
+          format,
+          entityTypes: params.entityTypes,
+          language: params.language,
+          storageUri: params.storagePath,
+        }).subscribe({
+          next: (event) => { if (event.phase === 'finished') resolve(event.resourceId); },
+          error: reject,
+        });
+      });
+      await semiont.bind.body(
+        rUri,
+        annotationId(referenceId),
+        [{ op: 'add', item: { type: 'SpecificResource' as const, source: newResourceId, purpose: 'linking' as const } }],
+      );
+      showSuccess('Reference successfully linked to the new resource');
+    } catch (error) {
+      showError(`Failed to compose resource: ${error instanceof Error ? error.message : String(error)}`);
+      throw error; // ComposeStep re-enables its footer on rejection
+    }
+  }, [semiont, rUri, showSuccess, showError]);
 
   // Add resource to open tabs when it loads, and record it as this KB's
   // last-viewed for the /know landing route to resume from. Both are per-KB
@@ -329,7 +349,7 @@ export function ResourceViewerPage({
   useEffect(() => {
     if (resource && rUri) {
       const mediaType = getPrimaryMediaType(resource);
-      browser.addOpenResource(rUri, resource.name, mediaType || undefined, resource.storageUri);
+      browser.addOpenResource(rUri, resource.name, mediaType || undefined, getStorageUri(resource));
       browser.setLastViewedResource(rUri);
     }
   }, [resource, rUri, browser]);
@@ -392,6 +412,19 @@ export function ResourceViewerPage({
     triggerSparkleAnimation(stored.payload.annotation.id);
   }, [triggerSparkleAnimation]);
 
+  // RESOLUTION-SPARKLE D2: a reference resolving — Compose, Search → Link, a
+  // Generate job landing, or a remote collaborator — is a body update whose
+  // operations add a linking SpecificResource. Exactly that sparkles; an unlink
+  // (remove) or an entity-tag body change stays dark.
+  const handleAnnotationBodyUpdated = useCallback((stored: EventMap['mark:body-updated']) => {
+    const resolves = stored.payload.operations.some(
+      (op) => op.op === 'add' && op.item.type === 'SpecificResource' && op.item.purpose === 'linking',
+    );
+    if (resolves) {
+      triggerSparkleAnimation(stored.payload.annotationId);
+    }
+  }, [triggerSparkleAnimation]);
+
   const handleResourceOpen = useCallback(({ resourceId }: { resourceId: string }) => {
     if (routes.resourceDetail) {
       const path = routes.resourceDetail(resourceId);
@@ -421,6 +454,7 @@ export function ResourceViewerPage({
     'yield:clone': handleResourceClone,
     'beckon:sparkle': handleAnnotationSparkle,
     'mark:added': handleAnnotationAdded,
+    'mark:body-updated': handleAnnotationBodyUpdated,
     'browse:resource-open': handleResourceOpen,
     'browse:entity-type-clicked': handleEntityTypeClicked,
   });
@@ -490,21 +524,6 @@ export function ResourceViewerPage({
               </h2>
             </div>
           </div>
-          {/* Resource-generation progress (GENERATE-FROM-BUTTON P7) — no annotationId ⇒ a resource-gen job */}
-          {generationProgress && !generationProgress.annotationId && (
-            <AssistProgress
-              progress={generationProgress}
-              dataType="generation"
-              // The ending is the owner's fact and every owner must state it
-              // (CLEAN-PROGRESS D1). This call site used to pass neither
-              // `ended` nor `onDismiss`, so a finished generation stayed in its
-              // running form and then vanished on a timer.
-              ended={!isGenerating}
-              onCancel={() => session?.client.job.cancelRequest('generation')}
-              onDismiss={() => stateUnit?.yield.dismissProgress()}
-              translations={assistProgressTranslations(ta)}
-            />
-          )}
           {/* Scrollable body wrapper - contains document content, header is sibling above */}
           <div className="semiont-document-viewer__scrollable-body" lang={getLanguage(resource) || undefined}>
             <ErrorBoundary
@@ -544,7 +563,7 @@ export function ResourceViewerPage({
                   onSelectionMotivationChange={toolbarPrefs.setSelectionMotivation}
                   shape={toolbarPrefs.shape}
                   onShapeChange={toolbarPrefs.setShape}
-                  newAnnotationIds={newAnnotationIds}
+                  sparkleAnnotationIds={sparkleAnnotationIds}
                   generatingReferenceId={generationProgress?.annotationId ?? null}
                   showLineNumbers={showLineNumbers}
                   hoverDelayMs={hoverDelayMs}
@@ -594,6 +613,7 @@ export function ResourceViewerPage({
                 onRetryAnnotations={stateUnit?.annotations.retry}
                 entityTypesError={entityTypesError}
                 generatingReferenceId={generationProgress?.annotationId ?? null}
+                sparkleAnnotationIds={sparkleAnnotationIds}
                 referencedBy={referencedBy}
                 referencedByLoading={referencedByLoading}
                 referencedByError={referencedByError}
@@ -604,7 +624,7 @@ export function ResourceViewerPage({
                 scrollToAnnotationId={scrollToAnnotationId}
                 hoveredAnnotationId={hoveredAnnotationId}
                 onScrollCompleted={onScrollCompleted}
-                initialTab={panelInitialTab?.tab as any}
+                initialTab={panelInitialTab?.tab}
                 initialTabGeneration={panelInitialTab?.generation}
                 Link={Link}
                 routes={routes}
@@ -636,7 +656,7 @@ export function ResourceViewerPage({
                 documentLocale={getLanguage(resource)}
                 primaryMediaType={primaryMediaType}
                 primaryByteSize={primaryByteSize}
-                storageUri={resource.storageUri}
+                storageUri={getStorageUri(resource)}
                 isArchived={resource.archived ?? false}
                 dateCreated={resource.dateCreated}
                 dateModified={resource.dateModified}
@@ -644,6 +664,15 @@ export function ResourceViewerPage({
                 wasDerivedFrom={resource.wasDerivedFrom}
                 generator={resource.generator as components['schemas']['Agent'] | components['schemas']['Agent'][] | undefined}
                 onGenerate={() => setGenerateOpen(true)}
+                // The panel is generation's progress surface (GENERATE-FROM-
+                // RESOURCE D7); no annotationId ⇒ a resource-gen job — the
+                // annotation path's frame renders in the reference wizard.
+                isGenerating={isGenerating}
+                generationProgress={
+                  generationProgress && !generationProgress.annotationId ? generationProgress : null
+                }
+                generationOutcome={generationOutcome}
+                onDismissProgress={() => stateUnit?.yield.dismissProgress()}
               />
             )}
 
@@ -680,27 +709,35 @@ export function ResourceViewerPage({
         annotationId={wizardAnnotationId}
         resourceId={wizardResourceId}
         defaultTitle={wizardDefaultTitle}
+        defaultFolder={folderOf(getStorageUri(resource))}
         entityTypes={wizardEntityTypes}
+        resourceName={resource.name}
         locale={locale}
         context={gatherContext}
         contextLoading={gatherLoading}
         contextError={gatherError}
         onGenerateSubmit={handleWizardGenerateSubmit}
         onLinkResource={handleWizardLinkResource}
-        onComposeNavigate={handleWizardComposeNavigate}
+        onComposeSubmit={handleWizardComposeSubmit}
+        entityTypeOptions={allEntityTypes}
+        hoverDelayMs={hoverDelayMs}
         translations={{
-          gatherTitle: tw('gatherTitle'),
-          configureGenerationTitle: tw('configureGenerationTitle'),
-          configureSearchTitle: tw('configureSearchTitle'),
-          searchResultsTitle: tw('searchResultsTitle'),
+          resolveTitle: tw('resolveTitle'),
           sourceContextLabel: tw('sourceContextLabel'),
           connectionsLabel: tw('connectionsLabel'),
           citedByLabel: tw('citedByLabel'),
           userHintLabel: tw('userHintLabel'),
+          userHintEffect: tw('userHintEffect'),
           userHintPlaceholder: tw('userHintPlaceholder'),
+          graphPaneTitle: tw('graphPaneTitle'),
+          graphEmpty: tw('graphEmpty'),
+          resourceLinkLabel: tw('resourceLinkLabel'),
+          corpusPaneTitle: tw('corpusPaneTitle'),
+          corpusEmpty: tw('corpusEmpty'),
+          excludedReceipt: tw('excludedReceipt'),
+          machineRead: tw('machineRead'),
           loadingContext: tw('loadingContext'),
           failedContext: tw('failedContext'),
-          cancel: tw('cancel'),
           search: tw('search'),
           searching: tw('searching'),
           generate: tw('generate'),
@@ -712,6 +749,7 @@ export function ResourceViewerPage({
           noResults: tw('noResults'),
           resourceTitle: tw('resourceTitle'),
           resourceTitlePlaceholder: tw('resourceTitlePlaceholder'),
+          saveLocation: tw('saveLocation'),
           additionalInstructions: tw('additionalInstructions'),
           additionalInstructionsPlaceholder: tw('additionalInstructionsPlaceholder'),
           language: tw('language'),
@@ -722,9 +760,19 @@ export function ResourceViewerPage({
           maxLength: tw('maxLength'),
           maxLengthHelp: tw('maxLengthHelp'),
           maxLengthCeiling: tw('maxLengthCeiling'),
+          outputFormat: tw('outputFormat'),
+          formatExtensionMismatch: tw('formatExtensionMismatch'),
           maxResults: tw('maxResults'),
           semanticScoring: tw('semanticScoring'),
           semanticScoringHelp: tw('semanticScoringHelp'),
+          searchFailed: tw('searchFailed'),
+          entityTypes: tw('entityTypes'),
+          contentLabel: tw('contentLabel'),
+          createAndLink: tw('createAndLink'),
+          creatingAndLinking: tw('creatingAndLinking'),
+          discardDraftPrompt: tw('discardDraftPrompt'),
+          discardDraft: tw('discardDraft'),
+          keepEditing: tw('keepEditing'),
         }}
       />
 
@@ -734,31 +782,43 @@ export function ResourceViewerPage({
         isOpen={generateOpen}
         onClose={() => setGenerateOpen(false)}
         resourceId={rUri}
-        defaultTitle=""
+        // Seed the proposed title from the source resource's name (GFR D4/A4);
+        // the field stays editable and required.
+        defaultTitle={resource.name}
+        defaultFolder={folderOf(getStorageUri(resource))}
         locale={locale}
         entityTypeOptions={allEntityTypes}
         onGenerateSubmit={handleResourceGenerateSubmit}
+        gatherContext={resourceGatherContext}
+        gatherLoading={resourceGatherLoading}
+        gatherError={resourceGatherError}
+        onGather={(options) => stateUnit?.gather.gatherResource(rUri, options)}
         translations={{
-          gatherTitle: tg('gatherTitle'),
-          reviewTitle: tg('reviewTitle'),
-          configureTitle: tg('configureTitle'),
-          next: tg('next'),
-          back: tg('back'),
-          cancel: tg('cancel'),
+          title: tg('title'),
           gatherIntro: tg('gatherIntro'),
           includeContent: tg('includeContent'),
           includeSummary: tg('includeSummary'),
           gatherDepth: tg('gatherDepth'),
           gatherMaxResources: tg('gatherMaxResources'),
           gatherButton: tg('gatherButton'),
-          excludeLabel: tg('excludeLabel'),
+          editGather: tg('editGather'),
+          recallLabel: tg('recallLabel'),
           loadingContext: tg('loadingContext'),
           failedContext: tg('failedContext'),
           sourceContextLabel: tg('sourceContextLabel'),
           connectionsLabel: tg('connectionsLabel'),
           citedByLabel: tg('citedByLabel'),
+          graphPaneTitle: tg('graphPaneTitle'),
+          graphEmpty: tg('graphEmpty'),
+          resourceLinkLabel: tg('resourceLinkLabel'),
+          corpusPaneTitle: tg('corpusPaneTitle'),
+          corpusEmpty: tg('corpusEmpty'),
+          excludedReceipt: tg('excludedReceipt'),
+          machineRead: tg('machineRead'),
+          score: tg('score'),
           resourceTitle: tg('resourceTitle'),
           resourceTitlePlaceholder: tg('resourceTitlePlaceholder'),
+          saveLocation: tg('saveLocation'),
           additionalInstructions: tg('additionalInstructions'),
           additionalInstructionsPlaceholder: tg('additionalInstructionsPlaceholder'),
           language: tg('language'),
@@ -769,7 +829,12 @@ export function ResourceViewerPage({
           maxLength: tg('maxLength'),
           maxLengthHelp: tg('maxLengthHelp'),
           maxLengthCeiling: tg('maxLengthCeiling'),
+          outputFormat: tg('outputFormat'),
+          formatExtensionMismatch: tg('formatExtensionMismatch'),
           generate: tg('generate'),
+          discardDraftPrompt: tg('discardDraftPrompt'),
+          discardDraft: tg('discardDraft'),
+          keepEditing: tg('keepEditing'),
         }}
       />
     </div>

package/src/features/resource-viewer/generation-options.ts

@@ -0,0 +1,29 @@
+import type { GenerationOptions } from '@semiont/sdk';
+import type { GenerationConfig } from '../../components/modals/ConfigureGenerationStep';
+
+/**
+ * The submitted form config becomes generation options — in ONE place, by
+ * spread (GENERATION-OUTPUT-FORMAT D8).
+ *
+ * Both page handlers previously built this object field-by-field, so a knob
+ * the list didn't mention was silently dropped on the way to the wire. That
+ * is exactly how `outputMediaType` came to be unreachable one layer down
+ * (P1's finding), and copying the pattern here would have re-created it for
+ * every future knob. Spreading means the default is "forwarded"; only the two
+ * genuine transformations are spelled out:
+ *
+ * - `context` leaves the bag — it is `fromContext`'s positional argument.
+ * - `sourceLanguage` joins it — the language of the resource being VIEWED,
+ *   which the form cannot know and the page can. Omitted entirely when
+ *   unknown, so absence stays absence rather than becoming `''`.
+ */
+export function toGenerationOptions(
+  config: GenerationConfig,
+  sourceLanguage: string | undefined,
+): GenerationOptions {
+  const { context: _positional, ...options } = config;
+  return {
+    ...options,
+    ...(sourceLanguage ? { sourceLanguage } : {}),
+  };
+}