Return full project JSON from createProject and add error handling for delete/update

- `interlinearizer.createProject` now returns the full persisted project as a JSON string instead of just the UUID, so the WebView can populate `activeProject` with authoritative server data rather than reconstructing it locally
- `CreateProjectModal.onProjectCreated` callback now receives the parsed `InterlinearProjectSummary` object instead of `(id, writingSystem)` pair
- Add `isInterlinearProjectSummary` type guard to `SelectInterlinearProjectModal` and reuse it in the project list filter and the new create flow
- Wrap `deleteProject` and `updateProjectMetadata` backend handlers in try/catch with logging and error notifications (previously unhandled rejections)
- Register a no-op `interlinearizer.viewProjectInfo` backend command so the platform menu system can surface it; all logic runs in the WebView
- Update tests and type declarations to match

Author: alex-rawlings-yyc

src/__tests__/components/CreateProjectModal.test.tsx

@@ -99,8 +99,12 @@ describe('CreateProjectModal', () => {
     );
   });
 
-  it('calls onClose after submitting when sendCommand returns an ID', async () => {
-    jest.mocked(papi.commands.sendCommand).mockResolvedValue('new-project-id');
+  it('calls onClose after submitting when sendCommand returns a project JSON', async () => {
+    jest
+      .mocked(papi.commands.sendCommand)
+      .mockResolvedValue(
+        JSON.stringify({ id: 'new-project-id', createdAt: '2026-01-01T00:00:00.000Z' }),
+      );
     const onClose = jest.fn();
     render(<CreateProjectModal projectId={testProjectId} onClose={onClose} />);
 
@@ -117,8 +121,14 @@ describe('CreateProjectModal', () => {
     expect(container.firstChild).toBeNull();
   });
 
-  it('calls onProjectCreated with the new ID and language when sendCommand returns an ID', async () => {
-    jest.mocked(papi.commands.sendCommand).mockResolvedValue('new-project-id');
+  it('calls onProjectCreated with the parsed project when sendCommand returns a project JSON', async () => {
+    const persistedProject = {
+      id: 'new-project-id',
+      createdAt: '2026-01-01T00:00:00.000Z',
+      sourceProjectId: testProjectId,
+      analysisWritingSystem: 'en',
+    };
+    jest.mocked(papi.commands.sendCommand).mockResolvedValue(JSON.stringify(persistedProject));
     const onProjectCreated = jest.fn();
     render(
       <CreateProjectModal
@@ -130,7 +140,9 @@ describe('CreateProjectModal', () => {
 
     await userEvent.click(screen.getByRole('button', { name: /^create$/i }));
 
-    expect(onProjectCreated).toHaveBeenCalledWith('new-project-id', 'en');
+    await waitFor(() =>
+      expect(onProjectCreated).toHaveBeenCalledWith(expect.objectContaining(persistedProject)),
+    );
   });
 
   it('does not call onProjectCreated or onClose when sendCommand returns undefined', async () => {

src/__tests__/interlinearizer.web-view.test.tsx

@@ -26,11 +26,26 @@ jest.mock('../components/CreateProjectModal', () => ({
     onProjectCreated,
   }: {
     onClose: () => void;
-    onProjectCreated?: (id: string, ws: string) => void;
+    onProjectCreated?: (project: {
+      id: string;
+      createdAt: string;
+      sourceProjectId: string;
+      analysisWritingSystem: string;
+    }) => void;
   }) => (
     <div>
       <h2>Create Interlinear Project</h2>
-      <button type="button" onClick={() => onProjectCreated?.('new-il-id', 'en')}>
+      <button
+        type="button"
+        onClick={() =>
+          onProjectCreated?.({
+            id: 'new-il-id',
+            createdAt: '2026-01-01T00:00:00.000Z',
+            sourceProjectId: 'test-project-id',
+            analysisWritingSystem: 'en',
+          })
+        }
+      >
         Submit
       </button>
       <button type="button" onClick={onClose}>

src/__tests__/main.test.ts

@@ -215,6 +215,7 @@ describe('main', () => {
           'interlinearizer.createProject',
           'interlinearizer.getProjectsForSource',
           'interlinearizer.newProject',
+          'interlinearizer.viewProjectInfo',
           'interlinearizer.updateProjectMetadata',
           'interlinearizer.deleteProject',
         ]),
@@ -449,6 +450,32 @@ describe('main', () => {
     });
   });
 
+  describe('interlinearizer.viewProjectInfo command', () => {
+    it('registers the interlinearizer.viewProjectInfo command', async () => {
+      const context = createTestActivationContext();
+
+      await activate(context);
+
+      expect(__mockRegisterCommand).toHaveBeenCalledWith(
+        'interlinearizer.viewProjectInfo',
+        expect.any(Function),
+        expect.any(Object),
+      );
+    });
+
+    it('resolves to undefined and triggers no side effects (handled entirely in the WebView)', async () => {
+      const context = createTestActivationContext();
+      await activate(context);
+      const rawHandler = findRegisteredHandler('interlinearizer.viewProjectInfo');
+      if (!rawHandler) throw new Error('Handler not found for interlinearizer.viewProjectInfo');
+
+      await expect(rawHandler()).resolves.toBeUndefined();
+      expect(__mockOpenWebView).not.toHaveBeenCalled();
+      expect(__mockSelectProject).not.toHaveBeenCalled();
+      expect(__mockNotificationsSend).not.toHaveBeenCalled();
+    });
+  });
+
   describe('interlinearizer.createProject command', () => {
     const mockCreateProject = jest.mocked(projectStorage.createProject);
     const emptyAnalysis = { segmentAnalyses: [], tokenAnalyses: [], phrases: [] };
@@ -474,7 +501,7 @@ describe('main', () => {
       );
     });
 
-    it('delegates to projectStorage.createProject and returns the new project ID', async () => {
+    it('delegates to projectStorage.createProject and returns the JSON-serialized project', async () => {
       mockCreateProject.mockResolvedValue(stubProject);
       const handler = await getCreateProjectHandler();
 
@@ -487,7 +514,7 @@ describe('main', () => {
         undefined,
         undefined,
       );
-      expect(result).toBe('new-project-id');
+      expect(result).toBe(JSON.stringify(stubProject));
     });
 
     it('does not show a project picker dialog', async () => {
@@ -683,6 +710,21 @@ describe('main', () => {
 
       expect(mockDeleteProject).toHaveBeenCalledWith(expect.anything(), 'to-delete-id');
     });
+
+    it('logs the error and sends an error notification when storage throws', async () => {
+      mockDeleteProject.mockRejectedValue(new Error('disk full'));
+      const handler = await getDeleteProjectHandler();
+
+      await handler('to-delete-id');
+
+      expect(__mockLogger.error).toHaveBeenCalledWith(
+        'Interlinearizer: failed to delete project',
+        expect.any(Error),
+      );
+      expect(__mockNotificationsSend).toHaveBeenCalledWith(
+        expect.objectContaining({ severity: 'error' }),
+      );
+    });
   });
 
   describe('interlinearizer.getProjectsForSource command', () => {
@@ -799,6 +841,22 @@ describe('main', () => {
 
       expect(result).toBeUndefined();
     });
+
+    it('logs the error, sends an error notification, and returns undefined when storage throws', async () => {
+      mockUpdateProjectMetadata.mockRejectedValue(new Error('disk full'));
+      const handler = await getUpdateProjectMetadataHandler();
+
+      const result = await handler('proj-id', 'My Name', 'My Desc');
+
+      expect(result).toBeUndefined();
+      expect(__mockLogger.error).toHaveBeenCalledWith(
+        'Interlinearizer: failed to update project metadata',
+        expect.any(Error),
+      );
+      expect(__mockNotificationsSend).toHaveBeenCalledWith(
+        expect.objectContaining({ severity: 'error' }),
+      );
+    });
   });
 
   describe('deactivate', () => {

src/components/CreateProjectModal.tsx

@@ -2,6 +2,10 @@ import papi, { logger } from '@papi/frontend';
 import { useLocalizedStrings } from '@papi/frontend/react';
 import { Button } from 'platform-bible-react';
 import { useState, useCallback, useMemo } from 'react';
+import {
+  type InterlinearProjectSummary,
+  isInterlinearProjectSummary,
+} from './SelectInterlinearProjectModal';
 
 /** Localized string keys used by {@link CreateProjectModal}. */
 const CREATE_PROJECT_MODAL_STRING_KEYS = [
@@ -24,8 +28,8 @@ const CREATE_PROJECT_MODAL_STRING_KEYS = [
  * @param props - Component props
  * @param props.projectId - Source project to create the interlinear project for
  * @param props.onClose - Callback invoked when the modal should be dismissed (cancel or submit)
- * @param props.onProjectCreated - Optional callback invoked with the new project UUID and analysis
- *   language after successful creation, before `onClose` is called.
+ * @param props.onProjectCreated - Optional callback invoked with the full persisted project after
+ *   successful creation, before `onClose` is called.
  * @returns The modal overlay with name, description, language inputs and submit/cancel buttons, or
  *   nothing while localized strings are loading.
  */
@@ -36,7 +40,7 @@ export function CreateProjectModal({
 }: Readonly<{
   projectId: string;
   onClose: () => void;
-  onProjectCreated?: (interlinearProjectId: string, analysisWritingSystem: string) => void;
+  onProjectCreated?: (project: InterlinearProjectSummary) => void;
 }>) {
   const [localizedStrings, stringsLoading] = useLocalizedStrings(
     useMemo(() => [...CREATE_PROJECT_MODAL_STRING_KEYS], []),
@@ -48,19 +52,23 @@ export function CreateProjectModal({
 
   /**
    * Sends the `interlinearizer.createProject` command with the collected form values, notifies the
-   * caller via `onProjectCreated`, then closes the modal.
+   * caller via `onProjectCreated`, then closes the modal. Logs and shows a notification on
+   * failure.
+   *
+   * @returns A promise that resolves when the command completes or the error notification is sent.
    */
   const handleSubmit = useCallback(async () => {
     try {
-      const newId = await papi.commands.sendCommand(
+      const projectJson = await papi.commands.sendCommand(
         'interlinearizer.createProject',
         projectId,
         analysisLanguage,
         name || undefined,
         description || undefined,
       );
-      if (!newId) return;
-      onProjectCreated?.(newId, analysisLanguage);
+      if (!projectJson) return;
+      const parsed: unknown = JSON.parse(projectJson);
+      if (isInterlinearProjectSummary(parsed)) onProjectCreated?.(parsed);
       onClose();
     } catch (e) {
       logger.error('Interlinearizer: failed to create project', e);

src/components/ProjectMetadataModal.tsx

@@ -83,7 +83,9 @@ export function ProjectMetadataModal({
 
   /**
    * Sends the updated name, description, and analysis language to the backend, then notifies the
-   * caller and closes the modal.
+   * caller and closes the modal. Logs and shows a notification on failure.
+   *
+   * @returns A promise that resolves when the command completes or the error notification is sent.
    */
   const handleSave = useCallback(async () => {
     const newName = editName || undefined;
@@ -111,7 +113,12 @@ export function ProjectMetadataModal({
     }
   }, [editName, editDescription, editLanguage, interlinearProjectId, onProjectSaved, onClose]);
 
-  /** Sends the delete command to the backend, then notifies the caller and closes the modal. */
+  /**
+   * Sends the delete command to the backend, then notifies the caller and closes the modal. Logs
+   * and shows a notification on failure.
+   *
+   * @returns A promise that resolves when the command completes or the error notification is sent.
+   */
   const handleDelete = useCallback(async () => {
     try {
       await papi.commands.sendCommand('interlinearizer.deleteProject', interlinearProjectId);

src/components/SelectInterlinearProjectModal.tsx

@@ -21,6 +21,22 @@ export type InterlinearProjectSummary = Pick<
   'id' | 'createdAt' | 'sourceProjectId' | 'analysisWritingSystem' | 'name' | 'description'
 >;
 
+/** Type guard for {@link InterlinearProjectSummary} parsed from unknown JSON. */
+export function isInterlinearProjectSummary(p: unknown): p is InterlinearProjectSummary {
+  return (
+    !!p &&
+    typeof p === 'object' &&
+    'id' in p &&
+    typeof p.id === 'string' &&
+    'createdAt' in p &&
+    typeof p.createdAt === 'string' &&
+    'sourceProjectId' in p &&
+    typeof p.sourceProjectId === 'string' &&
+    'analysisWritingSystem' in p &&
+    typeof p.analysisWritingSystem === 'string'
+  );
+}
+
 /**
  * Modal that lists all existing interlinearizer projects for a source project and lets the user
  * select one, view its details (via the info icon), or request that a new one be created. Fires
@@ -54,18 +70,21 @@ export function SelectInterlinearProjectModal({
 
   const [projects, setProjects] = useState<InterlinearProjectSummary[]>([]);
 
-  /** Fetches interlinear projects for `sourceProjectId` and updates the `projects` state. */
+  /**
+   * Fetches interlinear projects for `sourceProjectId` and updates the `projects` state. Logs and
+   * shows a notification on failure.
+   *
+   * @returns A promise that resolves when the project list is loaded or the error notification is
+   *   sent.
+   */
   const loadProjects = useCallback(async () => {
     try {
       const json = await papi.commands.sendCommand(
         'interlinearizer.getProjectsForSource',
         sourceProjectId,
       );
       const parsed: unknown = JSON.parse(json);
-      if (Array.isArray(parsed))
-        setProjects(
-          parsed.filter((p): p is InterlinearProjectSummary => !!p && typeof p === 'object'),
-        );
+      if (Array.isArray(parsed)) setProjects(parsed.filter(isInterlinearProjectSummary));
     } catch (e) {
       logger.error('Interlinearizer: failed to load projects for source', e);
       await papi.notifications
@@ -82,6 +101,7 @@ export function SelectInterlinearProjectModal({
    * Delegates to `onSelect` when the user clicks a project row.
    *
    * @param project - The project the user selected.
+   * @returns Void
    */
   const handleSelect = useCallback(
     (project: InterlinearProjectSummary) => {
@@ -94,6 +114,7 @@ export function SelectInterlinearProjectModal({
    * Delegates to `onViewInfo` when the user clicks a project's info icon.
    *
    * @param project - The project whose info icon was clicked.
+   * @returns Void
    */
   const handleViewInfo = useCallback(
     (project: InterlinearProjectSummary) => {

src/interlinearizer.web-view.tsx

@@ -305,19 +305,13 @@ globalThis.webViewComponent = function InterlinearizerWebView({
   /**
    * Records a newly created interlinear project as the active project and closes the create modal.
    *
-   * @param interlinearProjectId - UUID of the newly created interlinear project.
-   * @param analysisWritingSystem - BCP47 writing-system tag chosen during project creation.
+   * @param project - The full persisted project returned by the create command.
    */
   const handleProjectCreated = useCallback(
-    (interlinearProjectId: string, analysisWritingSystem: string) => {
-      setActiveProject({
-        id: interlinearProjectId,
-        createdAt: new Date().toISOString(),
-        sourceProjectId: projectId ?? /* c8 ignore next -- projectId is never undefined here */ '',
-        analysisWritingSystem,
-      });
+    (project: InterlinearProjectSummary) => {
+      setActiveProject(project);
     },
-    [projectId, setActiveProject],
+    [setActiveProject],
   );
 
   /**