Address code review feedback on fix-create-proj

- Restructure createAndPersistProject to eliminate duplicate
  setCreateSourceIsSelect/setModal calls via a single exit path
- Set isCreating during the discard-confirm createAndPersistProject
  path so the create modal buttons are disabled in that flow too
- Update stale JSDoc: PendingReplace comment and component summary
  now accurately describe the immediate-persist New behavior
- Split the old New-flow test into success and failure cases so
  resetActiveProject is asserted for the right reason in each
- Add validation-failure test (parse succeeds, non-project shape)
  to cover lines 242-245 and restore 100% coverage
- Fix no-type-assertion lint error in makeWebViewStateWithActiveProjectSpies
- Update discard-confirm test to assert createProject is called after confirm

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: imnasnainaec

src/__tests__/components/modals/ProjectModals.test.tsx

@@ -292,6 +292,25 @@ function makeWebViewStateWithResetSpy(resetActiveProject: () => void) {
   ];
 }
 
+/**
+ * Builds a `useWebViewState` stub with spies on both the setter and the reset for the
+ * `'activeProject'` key, so tests can assert which path was taken after a create attempt.
+ *
+ * @param setActiveProject - Spy invoked when the `'activeProject'` slot is set.
+ * @param resetActiveProject - Spy invoked when the `'activeProject'` slot is reset.
+ * @returns A `useWebViewState`-shaped hook stub.
+ */
+function makeWebViewStateWithActiveProjectSpies(
+  setActiveProject: jest.Mock,
+  resetActiveProject: jest.Mock,
+) {
+  return <T,>(key: string, defaultValue: T): [T, (v: T) => void, () => void] => [
+    defaultValue,
+    key === 'activeProject' ? setActiveProject : () => {},
+    key === 'activeProject' ? resetActiveProject : () => {},
+  ];
+}
+
 describe('ProjectModals', () => {
   beforeEach(() => {
     jest.mocked(papi.notifications.send).mockResolvedValue('notification-id');
@@ -452,7 +471,48 @@ describe('ProjectModals', () => {
   });
 
   describe('new (create) flow', () => {
-    it('starts an empty draft, clears the active project, and closes when not dirty', async () => {
+    it('seeds the draft, calls createProject on the backend, and closes', async () => {
+      jest.mocked(papi.commands.sendCommand).mockResolvedValueOnce(JSON.stringify(MOCK_PROJECT));
+      const newDraft = jest.fn();
+      const setModal = jest.fn();
+      const setActiveProject = jest.fn();
+      const resetActiveProject = jest.fn();
+      render(
+        <ProjectModals
+          {...buildProps({
+            modal: 'create',
+            newDraft,
+            setModal,
+            useWebViewState: makeWebViewStateWithActiveProjectSpies(
+              setActiveProject,
+              resetActiveProject,
+            ),
+          })}
+        />,
+      );
+
+      await userEvent.click(screen.getByTestId('create-submit'));
+
+      await waitFor(() => expect(setActiveProject).toHaveBeenCalledWith(MOCK_PROJECT));
+      expect(newDraft).toHaveBeenCalledWith({
+        analysisLanguages: ['en'],
+        suggestedName: 'New',
+        suggestedDescription: 'Desc',
+      });
+      expect(papi.commands.sendCommand).toHaveBeenCalledWith(
+        'interlinearizer.createProject',
+        'source-proj',
+        ['en'],
+        undefined,
+        'New',
+        'Desc',
+      );
+      expect(resetActiveProject).not.toHaveBeenCalled();
+      expect(setModal).toHaveBeenCalledWith('none');
+    });
+
+    it('falls back to resetActiveProject and closes when backend project creation fails', async () => {
+      // Default mock returns undefined; JSON.parse(undefined) throws into the catch block.
       const newDraft = jest.fn();
       const setModal = jest.fn();
       const resetActiveProject = jest.fn();
@@ -469,23 +529,45 @@ describe('ProjectModals', () => {
 
       await userEvent.click(screen.getByTestId('create-submit'));
 
-      // New starts a draft locally (carrying the typed name/description for the Save As prefill) and
-      // clears the active project so Save routes to Save As; no backend project is created.
+      await waitFor(() => expect(setModal).toHaveBeenCalledWith('none'));
       expect(newDraft).toHaveBeenCalledWith({
         analysisLanguages: ['en'],
         suggestedName: 'New',
         suggestedDescription: 'Desc',
       });
-      expect(papi.commands.sendCommand).not.toHaveBeenCalledWith(
+      expect(papi.commands.sendCommand).toHaveBeenCalledWith(
         'interlinearizer.createProject',
-        expect.anything(),
-        expect.anything(),
-        expect.anything(),
-        expect.anything(),
-        expect.anything(),
+        'source-proj',
+        ['en'],
+        undefined,
+        'New',
+        'Desc',
       );
       expect(resetActiveProject).toHaveBeenCalledTimes(1);
-      expect(setModal).toHaveBeenCalledWith('none');
+    });
+
+    it('notifies and falls back to resetActiveProject when backend returns a non-project shape', async () => {
+      jest.mocked(papi.commands.sendCommand).mockResolvedValueOnce(JSON.stringify({ bad: true }));
+      const setModal = jest.fn();
+      const resetActiveProject = jest.fn();
+      render(
+        <ProjectModals
+          {...buildProps({
+            modal: 'create',
+            setModal,
+            useWebViewState: makeWebViewStateWithResetSpy(resetActiveProject),
+          })}
+        />,
+      );
+
+      await userEvent.click(screen.getByTestId('create-submit'));
+
+      await waitFor(() => expect(setModal).toHaveBeenCalledWith('none'));
+      expect(papi.notifications.send).toHaveBeenCalledWith({
+        message: '%interlinearizer_error_create_project_failed%',
+        severity: 'error',
+      });
+      expect(resetActiveProject).toHaveBeenCalledTimes(1);
     });
 
     it('calls setModal with none when the create modal closes without a select source', async () => {
@@ -540,14 +622,22 @@ describe('ProjectModals', () => {
       expect(loadFromProject).not.toHaveBeenCalled();
     });
 
-    it('confirms before starting a new draft when the draft is dirty', async () => {
+    it('confirms before creating a project when the draft is dirty', async () => {
       const newDraft = jest.fn();
       render(<ProjectModals {...buildProps({ modal: 'create', dirty: true, newDraft })} />);
 
       await userEvent.click(screen.getByTestId('create-submit'));
       expect(screen.getByTestId('discard-modal')).toBeInTheDocument();
-      // The new draft must not start until the user confirms discarding the current one.
+      // Neither draft nor project creation should start until the user confirms discarding.
       expect(newDraft).not.toHaveBeenCalled();
+      expect(papi.commands.sendCommand).not.toHaveBeenCalledWith(
+        'interlinearizer.createProject',
+        expect.anything(),
+        expect.anything(),
+        expect.anything(),
+        expect.anything(),
+        expect.anything(),
+      );
 
       await userEvent.click(screen.getByTestId('discard-confirm'));
       await waitFor(() =>
@@ -557,6 +647,14 @@ describe('ProjectModals', () => {
           suggestedDescription: 'Desc',
         }),
       );
+      expect(papi.commands.sendCommand).toHaveBeenCalledWith(
+        'interlinearizer.createProject',
+        'source-proj',
+        ['en'],
+        undefined,
+        'New',
+        'Desc',
+      );
     });
 
     it('disables the discard-confirm button while an open is in flight', async () => {

src/components/modals/ProjectModals.tsx

@@ -15,8 +15,9 @@ import { SelectInterlinearProjectModal } from './SelectInterlinearProjectModal';
 export type ModalState = 'none' | 'select' | 'create' | 'metadata' | 'saveAs';
 
 /**
- * A draft-replacing action deferred behind the unsaved-changes confirmation: either starting a new
- * empty draft or opening an existing project into the draft.
+ * A draft-replacing action deferred behind the unsaved-changes confirmation: either creating and
+ * persisting a new project (then seeding the draft from it), or opening an existing project into
+ * the draft.
  */
 type PendingReplace =
   | { kind: 'new'; config: CreateDraftConfig }
@@ -27,8 +28,10 @@ type PendingReplace =
  * {@link SelectInterlinearProjectModal}, {@link CreateProjectModal}, {@link ProjectMetadataModal}, or
  * {@link SaveAsProjectModal}, with the {@link DiscardDraftConfirm} guard overlaid on top when a
  * draft-replacing action is pending (so canceling returns to the underlying modal with its state
- * intact); manages the shared WebView state for the active project; and routes New / Open / Save As
- * through the draft (rather than persisting projects directly on every edit).
+ * intact); manages the shared WebView state for the active project; and routes project lifecycle
+ * actions through the draft: New creates and persists a project immediately (so it appears in
+ * Select right away) and seeds the draft from it; Open loads an existing project into the draft;
+ * Save / Save As write the draft's analysis back to the active project or create a new one.
  *
  * @param props - Component props
  * @param props.activeProject - The currently active interlinear project (the Save target), read
@@ -222,6 +225,7 @@ export default function ProjectModals({
         ...(config.name !== undefined && { suggestedName: config.name }),
         ...(config.description !== undefined && { suggestedDescription: config.description }),
       });
+      let created: InterlinearProjectSummary | undefined;
       try {
         const createdJson = await papi.commands.sendCommand(
           'interlinearizer.createProject',
@@ -231,19 +235,20 @@ export default function ProjectModals({
           config.name,
           config.description,
         );
-        const created: unknown = JSON.parse(createdJson);
-        if (!isInterlinearProjectSummary(created)) {
+        const parsed: unknown = JSON.parse(createdJson);
+        if (isInterlinearProjectSummary(parsed)) {
+          created = parsed;
+        } else {
           await papi.notifications
             .send({ message: '%interlinearizer_error_create_project_failed%', severity: 'error' })
             .catch(() => {});
-          resetActiveProject();
-          setCreateSourceIsSelect(false);
-          setModal('none');
-          return;
         }
-        setActiveProject(created);
       } catch (e) {
         logger.error('Interlinearizer: failed to create project from New dialog', e);
+      }
+      if (created) {
+        setActiveProject(created);
+      } else {
         resetActiveProject();
       }
       setCreateSourceIsSelect(false);
@@ -302,7 +307,12 @@ export default function ProjectModals({
       if (pendingReplace.kind === 'open') {
         await openProject(pendingReplace.project);
       } else {
-        await createAndPersistProject(pendingReplace.config);
+        setIsCreating(true);
+        try {
+          await createAndPersistProject(pendingReplace.config);
+        } finally {
+          setIsCreating(false);
+        }
       }
     } finally {
       setIsReplacing(false);