Trip Editor E2E tests must prove real contracts, not mocked CRUD paths

[stef-k]

Problem

Trip Editor manual release-candidate testing repeatedly found basic CRUD, state, image, and parity failures after agents reported green or focused E2E results. The immediate cause is not that browser testing is useless; it is that several tests currently fake or mock critical backend behavior and then get described as end-to-end proof.

Mocked Playwright tests are useful for frontend rendering states, but they cannot prove CRUD correctness, authorization rules, persistence, affected-order responses, or real endpoint behavior.

Concrete recent example from #295:

• A browser test proved the Region selector/request path for Unassigned Places.
• The actual backend update path still returned 403 when moving an existing place from a normal region to Unassigned Places.
• Manual testing found the failure.
• The fix required backend mutation tests plus a browser assertion that the sidebar visually moved the place after the real contract was corrected.

Required Outcome

Make the Trip Editor test suite honest about what it proves, and replace weak mocked/proxy assertions with real contract coverage for release-critical workflows.

Testing Policy

• Tests that mock mutation responses must not be described as E2E proof for CRUD correctness.
• Mocked Playwright tests may prove frontend rendering, loading, error, and difficult browser-only states.
• Release-critical CRUD requires backend-rule coverage plus browser-visible outcome coverage.
• If a browser test uses mocked data for a mutation, the test/report must explicitly state that it proves only frontend behavior and must be paired with backend tests for the same mutation contract.
• Full Trip Editor E2E passing is not release proof unless the important tests prove real user contracts.

Audit Scope

Audit the Trip Editor workflows below and classify existing tests as:

• contract: proves final user-visible outcome;
• backend-rule: proves server mutation/authorization/validation/persistence;
• integration: uses real endpoint plus UI interaction;
• mocked-only: proves frontend rendering only;
• proxy: proves only selector/button/request/presence;
• missing: no meaningful proof.

Workflows:

• Trip metadata save, public trip, share progress.
• Region create/edit/delete/reorder.
• Place create/edit/delete/reorder/move between regions/Unassigned Places.
• Place geosearch add.
• Place coordinate pick.
• Area create/edit/delete/reorder/polygon map work.
• Segment create/edit/delete/reorder/route map work.
• Visit progress/history.
• Rich notes text/images/alignment/sanitize/save.
• Sidebar search/filter.
• Map utilities: fit, recenter, focus, zoom display, measure, copy link.
• Published production bundle loading.
• Light/dark/narrow layout.

Fix Requirements

For every high-risk or release-critical workflow:

• add or strengthen backend tests for mutation rules;
• add or strengthen focused browser tests for final user-visible state;
• remove or relabel tests that only prove mocked request/render behavior;
• avoid adding broad slow tests when a focused contract test is enough;
• keep runtime under control by using focused specs during development and one full-suite smoke only near final release-candidate validation.

Validation

When this issue is implemented, provide:

• a coverage classification matrix;
• list of tests strengthened or removed;
• focused validation results;
• full Trip Editor E2E runtime and result only once the focused contract coverage is corrected;
• remaining manual-only RC checks, limited to visual feel and final confirmation rather than basic CRUD discovery.

Notes

This is not a request to add more fake E2E tests. It is a request to make the suite truthful and useful so manual testing is no longer the primary mechanism for discovering basic editor failures.

[stef-k]

Initial Read-only Test Credibility Audit

This audit classifies current Trip Editor automated coverage by whether it proves real user/backend contracts or only mocked/proxy behavior. It is the starting point for #297; a tightening pass should extend it for auth/error/dirty/delete/create/navigation scope before implementation begins.

Workflow	Current files	Backend tests	Playwright tests	Mocking / asserted proof	Classification	Risk	Recommended fix
Trip metadata save, public trip, share progress	TripEditorController.cs, TripEditorTagShareProgressController.cs, MetadataEditor.vue, tripEditorApi.ts	Metadata persistence/validation in TripEditorMetadataControllerTests.cs; share progress auth/persistence in TripEditorTagsShareProgressControllerTests.cs; read-state public URLs in TripEditorControllerTests.cs	Real endpoint UI smoke in tripEditorRemainingParity.spec.ts; tags real smoke in tripEditor.spec.ts; disabled toggle UI only in tripEditor.spec.ts	Metadata/share progress spec waits for real PATCH 200 and Saved. It does not reread or assert persisted public/progress URLs after reload.	backend-rule + proxy, partial contract	Medium	Add one focused real endpoint/UI reload check: toggle public/share, reload/read API, assert metadata URLs/toggles. Keep existing UI smoke but limit claim to request success.
Region create/edit/delete/reorder	TripEditorController.cs, TripEditorRegionMutationService.cs, RegionManager.vue, RegionEditorForm.vue	Strong backend CRUD/order/auth coverage in TripEditorRegionControllerTests.cs	Real UI only edits existing region validation and creates a temp place in tripEditor.spec.ts; broad surface tests only	No mocked region mutation Playwright found for region CRUD. Real E2E does not prove region create/delete/reorder user outcome.	backend-rule	Medium	Add one focused Playwright real-endpoint region create/edit/delete/reorder flow against disposable data, or explicitly document backend-only coverage.
Place create/edit/delete/reorder/move/Unassigned Places	TripEditorPlacesController.cs, TripEditorPlaceMutationService.cs, PlaceEditorForm.vue, RegionPlaceList.vue	Strong backend create/move/delete/order/coordinate/validation coverage in TripEditorPlaceControllerTests.cs and TripEditorPlaceValidationControllerTests.cs	Real place create/cleanup smoke in tripEditor.spec.ts; move mocked in tripEditorPlaceReassignment.spec.ts; icon/save mocked in tripEditorIconSelector.spec.ts; feedback mocked in tripEditorMarkerParity.spec.ts; reorder only annotated, not run, in tripEditor.spec.ts	Move/reload proof is synthetic: it mutates an in-memory cloned state and fulfills PUT. Reorder has no automated mutation proof.	backend-rule + mocked-only	High	Replace place move and reorder mocked assertions with one real endpoint focused Playwright flow; keep icon/feedback mocked tests but relabel as frontend rendering/request-shape only.
Place geosearch add	TripEditorController.cs, TripEditorGeocodeSearchService.cs, MapSearchControl.vue, placeEditorActions.ts	Backend proxy/auth/provider mapping in TripEditorGeocodeControllerTests.cs	Geosearch UI uses mocked geocode responses and mocked editor state in tripEditorMapSearch.spec.ts	Tests prove proxy UI states and that Add as place opens an Add Place draft without saving. They do not prove saved search-add persists through real place endpoint.	proxy + backend-rule	Medium	Add one real endpoint handoff: mocked geocode result may remain, but Save Place should hit the real create-place endpoint and assert row/reload.
Place coordinate pick	placeCoordinateMapWork.ts, leafletAdapter.ts, TripEditorPlaceMutationService.cs	Backend coordinate route rewrite in TripEditorPlaceControllerTests.cs	UI map-work mostly read-only mocked state in tripEditorPlaceCoordinateMapWork.spec.ts; save-after-Done intercepts PUT and fulfills fake success	Proves coordinate draft UI and request body. Does not prove real endpoint accepts/persists picked coordinate from UI.	backend-rule + mocked-only	Medium	Add a focused real-endpoint coordinate-pick Save Place test with reload/API assertion. Keep map pixel/draft tests mocked.
Area CRUD/reorder/polygon map work	TripEditorAreasController.cs, TripEditorAreaMutationService.cs, AreaEditorForm.vue, areaPolygonMapWork.ts	Strong backend CRUD/order/geometry validation in TripEditorAreaControllerTests.cs	Area save/reorder specs mock mutation responses in tripEditorAreaEditing.spec.ts	Proves frontend sends polygon/order payload and reacts to fake affected slices. Does not prove real endpoint persistence from UI.	backend-rule + mocked-only	High	Replace one mocked area save/reorder Playwright path with real endpoint coverage and reload assertion. Keep map-work draft-only tests mocked.
Segment CRUD/reorder/route map work	TripEditorSegmentsController.cs, TripEditorSegmentMutationService.cs, SegmentManager.vue, segmentRouteMapWork.ts	Strong backend CRUD/order/route validation in TripEditorSegmentControllerTests.cs and TripEditorSegmentValidationControllerTests.cs	Segment route save/order specs mock mutation responses in tripEditorSegmentEditing.spec.ts	Proves frontend request shape and UI update from synthetic response. Does not prove real segment endpoint accepts UI route/order payloads.	backend-rule + mocked-only	High	Add one real endpoint route-save and reorder Playwright flow with reload/API assertion.
Visit progress/history	EditorTripStateMapper.cs, TripEditorPlaceMutationReader.cs, VisitProgressSurface.vue	Read-state backend asserts totals/history ordering in TripEditorControllerTests.cs	Visit specs mock read model in tripEditorVisitProgress.spec.ts	Proves component rendering/filtering with synthetic visit state. Backend proves mapper shape, but no real UI against seeded backend visit data.	backend-rule + mocked-only	Low/Medium	Add small backend test for any missing edge found by manual RC; optional real UI read-only smoke if visit display regressed.
Rich notes text/images/alignment/sanitize/save	RichNotesEditor.vue, notesHtml.ts, owner forms, mutation endpoints	Backend mutation tests cover notes fields as part of metadata/region/place/area/segment saves, but no dedicated rich-note sanitizer/browser normalization server test found	Rich notes specs mock mutation endpoints in tripEditorRichNotes.spec.ts	Proves client canonicalization/request body and proxy display. Does not prove server persistence/sanitization for Quill alignment/images from real UI.	mocked-only, partial backend-rule	High	Add backend sanitizer/persistence tests for canonical notes HTML on each relevant parser or one shared parser boundary; add one real endpoint UI save/reload for metadata rich notes.
Sidebar search/filter	TripSidebar.vue, RegionPlaceList.vue	No backend mutation needed; read-state backend indirectly covers data shape	Real app read model in tripEditorSidebarSearch.spec.ts; remaining parity real smoke in tripEditorRemainingParity.spec.ts	No API mocking in main sidebar spec; it asserts visible filtering and no network search requests. This is credible frontend contract coverage.	contract	Low	No action, except keep as frontend-only claim.
Map utilities: fit/recenter/focus/zoom/measure/copy link	leafletAdapter.ts, mapUtilitiesControl.ts, MapWorkToolbar.vue	Read-state geometry shape in TripEditorControllerTests.cs	Toolbar presence real smoke in tripEditorMapNavigation.spec.ts; many focus scenarios mock GET state; utility real smoke in tripEditorRemainingParity.spec.ts	Fit/focus variants mostly synthetic read models. Zoom/measure/copy are real UI assertions, no backend persistence.	contract for utilities, mocked-only for geometry variants	Medium	Keep geometry-variant mocks, but relabel them as map-adapter behavior. Add no backend work unless a real geometry fixture gap appears.
Published production bundle loading	Areas/User/Views/Trip/Edit.cshtml, vite.config.ts, Wayfarer.csproj	None found for manifest/published output	tripEditor.spec.ts proves current served editor/API route loads, but not published Production bundle	No test proves dotnet publish output serves /vite/trip-editor/* and mounts the editor.	missing	High	Add a narrow publish smoke script/test: npm run build, dotnet publish, run published app in Production, GET editor shell/assets, browser assert Vue mounted.
Light/dark/narrow layout	theme.css, styles.css, surfaces.css, map.css, editor components	N/A	Real layout smoke in tripEditor.spec.ts; visual polish uses mocked read-only state in tripEditorVisualPolish.spec.ts; icon selector responsive uses mocked mutation state	Proves layout/rendering in browser. Some data is mocked, but final user-visible layout assertions are credible for visual regressions.	contract for layout, mocked-only for data-dependent visuals	Low/Medium	No broad rewrite. Keep as visual contract; label fixture-backed visual specs separately from real-runbook smoke.

Initial Prioritized Fix Plan

1. Batch 1: Stop overclaiming mocked mutation specs.

   • Update test names/comments/docs/matrix labels so tripEditorAreaEditing, tripEditorSegmentEditing, tripEditorPlaceReassignment, tripEditorRichNotes, tripEditorIconSelector, tripEditorMarkerParity, and coordinate-save specs are not described as E2E persistence proof when they use page.route(...).fulfill(...).

2. Batch 2: Add real endpoint UI coverage for highest-risk CRUD.

   • One focused Playwright flow each for place move/reorder, area save/reorder, and segment route-save/reorder.
   • Use disposable data and assert final visible row/order plus reload or API reread.

3. Batch 3: Harden rich notes contract.

   • Add backend sanitizer/persistence tests for canonical Quill HTML, images, alignment, and blocked unsafe content.
   • Add one real metadata rich-notes UI save/reload test; keep broad editor behavior tests mocked.

4. Batch 4: Production bundle smoke.

   • Add a narrow published-output validation path for Production: published app serves manifest assets and Trip Editor mounts.
   • This should be separate from dev-server Playwright claims.

5. Batch 5: Optional lower-risk real read smoke.

   • Visit progress and map geometry variants can stay mostly backend-rule plus mocked UI, but add one real fixture UI smoke if manual RC found a specific regression there.

Net Assessment

Backend mutation coverage is generally strong for server rules, but several Playwright specs currently prove request shape and frontend response handling, not real user/backend contracts. The highest release risk is where mocked route.fulfill was treated as persistence proof for place, area, segment, and rich-notes saves.

Required Tightening Pass Before Implementation

This initial matrix covers the main editor surfaces, but it is not yet the full editor contract. Before implementation starts, extend this matrix with explicit rows for:

1. Auth/ownership/error behavior:

   • unauthenticated;
   • wrong role;
   • non-owner;
   • missing trip;
   • missing/stale entity mutation;
   • cross-trip entity IDs.

2. Dirty/cancel/delete/error-feedback flows:

   • dirty prompt keep/discard;
   • clean cancel;
   • failed save preserves draft and shows error;
   • delete confirmation;
   • delete visual removal after success;
   • delete failure feedback.

3. Create flows separately from edit/reorder:

   • region create;
   • place create;
   • area create;
   • segment create;
   • defaults, temp IDs, focus/scroll, affected order response.

4. Navigation/save-exit behavior:

   • Save & Exit if currently supported;
   • route/navigation-away dirty protection if currently supported;
   • clarify if out of scope.

5. Development and published asset modes:

   • Development Vite server smoke;
   • published-output production bundle smoke;
   • clarify what each proves.

6. Map search/Add Place after Trip Editor RC geosearch add-place workflow and place-edit parity regressions #295:

   • Unassigned Places default;
   • selected-region one-off add;
   • reset back to Unassigned Places;
   • pending marker;
   • save/reload persistence.

7. Scope exclusions:

   • explicitly classify import/export/backfill/public viewer/mobile/API as out of Trip Editor E2E scope unless an editor entry point depends on them.

[stef-k]

Tightening Pass: Added Editor Contract Rows

This extends the initial audit in #297 (comment). The initial matrix covered the main editor surfaces, but not the full release contract. These rows add auth/error/dirty/delete/create/navigation/asset-mode/search-add scope before implementation begins.

Added workflow	Current coverage	Classification	Risk	Fix direction
Unauthenticated editor/API access	Backend read-state and mutation auth tests cover anonymous users; no browser-visible auth redirect/401 smoke.	backend-rule	Medium	Add one browser smoke for unauthenticated editor entry and one mutation/API status assertion if not already covered by integration harness.
Missing trip	Backend read-state returns not found; mutation ownership/missing-scope tests cover not-found-before-body parsing.	backend-rule	Medium	Add one focused browser/API assertion only if release reports need user-visible missing-trip behavior.
Missing/stale entity mutation	Region/place/area/segment backend tests cover missing IDs before body parsing. UI stale-delete/save failure handling is not proven.	backend-rule + missing	High	Pair backend stale-entity tests with one browser failed-save/delete-failure assertion that draft/row state is preserved.
Cross-trip entity IDs	Place cross-trip region, area cross-trip order, segment cross-trip order have backend coverage; region is mostly unknown/incomplete IDs.	backend-rule	Medium	Fill explicit region cross-trip/foreign-ID backend case if absent; browser coverage not needed beyond error feedback.
Dirty prompt keep/discard	Existing Playwright covers shared discard dialogs and keep/discard paths, often fixture-backed.	contract + mocked-only	Medium	Keep as frontend contract; add only if a real endpoint flow is already being added and can cheaply exercise dirty guard.
Clean cancel	Some clean target switch/cancel paths are covered; not uniformly across region/place/area/segment.	contract + missing	Medium	Add focused UI assertions that clean cancel closes without prompt and leaves persisted state unchanged.
Failed save preserves draft and shows error	Save & Exit tag failure is mocked; mutation feedback helpers exist; CRUD failed-save preservation is not proven.	mocked-only + missing	High	Batch with stale mutation coverage: failed create/update preserves draft fields and shows danger/error feedback.
Delete confirmation	UI confirmation paths exist, but mostly fixture/visual.	mocked-only	Medium	Keep frontend confirmation tests, but do not claim persistence.
Delete visual removal after success	Backend deletedIds/affected slices are strong; browser real deletion/removal is not proven for each entity.	backend-rule + mocked-only	High	Add one real endpoint delete visual-removal flow for region/place/area/segment, or fold into each CRUD real contract spec.
Delete failure feedback	Backend failure statuses exist through missing/auth tests; browser failure feedback is not meaningfully covered.	missing	High	Add mocked failure UI test per shared delete path or one per manager if error handling differs.
Region create	Backend proves create defaults/order slices; browser create outcome is missing.	backend-rule	Medium	Add real endpoint UI create/reload assertion.
Place create	Backend proves create/order/visit affected slices; current real browser smoke creates temporary data, but contract depth is limited.	backend-rule + integration	Medium	Strengthen to assert visible row plus reload/API reread, including Unassigned Places where relevant.
Area create	Backend proves create/defaults/order; browser create/save uses mocked mutation.	backend-rule + mocked-only	High	Replace one mocked area create-save path with real endpoint UI + reload/API assertion.
Segment create	Backend proves create/defaults/order; browser create/save uses mocked mutation.	backend-rule + mocked-only	High	Replace one mocked segment create-save path with real endpoint UI + reload/API assertion.
Defaults/temp IDs/focus/scroll/affected order	Backend proves affected order; UI temp IDs/focus/scroll are mostly component/fixture behavior.	backend-rule + mocked-only	Medium	Add assertions inside real create flows: draft has no persisted ID until save, saved row receives server ID/order, active editor focus/scroll remains sane.
Save & Exit	Currently supported through metadata surface; failure path is mocked. Full real save-exit persistence/navigation proof is weak.	proxy + mocked-only	Medium	Add real Save & Exit happy-path only if this is release-critical; otherwise label as metadata navigation behavior, not CRUD proof.
Route/navigation-away dirty protection	beforeunload/shared navigation guards exist; visit manage navigation has mocked/fulfilled route coverage.	contract + mocked-only	Medium	Clarify scope: in-app editor navigation guards are in scope; arbitrary browser/tab close remains manual/browser-platform limited.
Development Vite server smoke	Existing Playwright dev-run specs prove the dev-served editor shell/API route mounts.	contract	Low	Keep separate from production claims: proves local ASP.NET + Vite dev integration only.
Published-output production bundle smoke	No current automated published app smoke proves production assets mount.	missing	High	Keep asset-mode batch: npm run build, dotnet publish, run published Production app, assert shell/assets/Vue mount.
Map search Add Place: Unassigned default	Current #295-era specs cover selector/default behavior with mocked geocode.	proxy	Medium	Keep proxy label unless save goes through real create endpoint.
Map search Add Place: selected-region one-off add	Covered as UI selector workflow with mocked geocode; persistence not proven.	proxy	Medium	Add real save after mocked geocode handoff and assert target region row.
Map search Add Place: reset to Unassigned	Covered in Playwright UI behavior.	proxy	Medium	Pair with persistence test so reset behavior is not mistaken for saved contract.
Map search Add Place: pending marker	Covered as frontend map preview/pending marker behavior.	mocked-only	Low/Medium	Keep mocked/component-level; backend not relevant until Save Place.
Map search Add Place: save/reload persistence	Not proven end to end after search-add handoff.	missing	High	Add real create-place save/reload assertion from search-add draft.
Scope exclusions: import/export/backfill/public viewer/mobile/API	These are outside Trip Editor E2E unless the editor entry point directly depends on them.	out of scope	Low	Explicitly document as excluded; do not add Trip Editor E2E rows unless editor navigation or read/write contract depends on them.

Revised Fix Batches

1. Batch 1: relabel mocked/proxy claims and add failure-state truthfulness.

   • Include existing mocked mutation specs plus new labels for search-add proxy, confirmation-only, visual-only, and Save & Exit failure paths.

2. Batch 2: real endpoint CRUD contract coverage.

   • Highest priority: place move/reorder/create, area create/save/reorder/delete, segment create/route-save/reorder/delete, and region create/delete if not covered by browser-visible outcome.

3. Batch 3: error and stale-state UX.

   • Add failed save preserves draft, stale/missing entity mutation feedback, delete failure feedback, and clean cancel/dirty keep-discard assertions where current coverage is partial.

4. Batch 4: search-add after Trip Editor RC geosearch add-place workflow and place-edit parity regressions #295.

   • Prove Unassigned Places default, selected-region one-off add, reset-to-Unassigned, pending marker, and real Save Place persistence/reload. The persistence row is release-critical.

5. Batch 5: rich notes contract.

   • Backend sanitizer/persistence plus one real UI save/reload.

6. Batch 6: asset mode separation.

   • Keep Development Vite smoke and published-output Production smoke as separate proof types. Published-output remains high risk because it is currently missing.

Net Change

The added rows raise error-feedback/stale mutation and search-add persistence to the same priority tier as CRUD persistence. Published-output remains high priority, but should stay separate from CRUD contract work because it proves deployment packaging rather than editor mutation correctness.

[stef-k]

Batch 1 update: Trip Editor test-claim honesty

Implemented Batch 1 only. This did not add real endpoint CRUD coverage and did not change product behavior.

Changed:

• Added the durable Trip Editor test credibility matrix to docs/22-Testing.md.
• Documented the rule that Playwright mutation tests using page.route(...).fulfill(...) are not E2E CRUD proof.
• Documented that mocked mutation specs may prove frontend rendering, request shape, loading/error states, visual behavior, map adapter behavior, proxy/search UI behavior, or mocked response handling only.
• Documented that CRUD release proof requires backend-rule coverage plus real endpoint UI coverage, reload/API reread, or an explicit pairing.

Relabeled specs/comments:

• tests/e2e/trip-editor/tripEditorAreaEditing.spec.ts
• tests/e2e/trip-editor/tripEditorSegmentEditing.spec.ts
• tests/e2e/trip-editor/tripEditorPlaceReassignment.spec.ts
• tests/e2e/trip-editor/tripEditorRichNotes.spec.ts
• tests/e2e/trip-editor/tripEditorIconSelector.spec.ts
• tests/e2e/trip-editor/tripEditorMarkerParity.spec.ts
• tests/e2e/trip-editor/tripEditorPlaceCoordinateMapWork.spec.ts
• tests/e2e/trip-editor/tripEditorMapSearch.spec.ts
• tests/e2e/trip-editor/tripEditorRemainingParity.spec.ts

Validation:

• npx playwright test --config=playwright.config.ts --list passed; 106 tests listed.
• dotnet run --project tools/Wayfarer.LocCheck -- --warn 400 --fail 600 passed with warnings only on existing large Trip Editor files touched by label/comment edits.
• git diff --check passed; only normal CRLF working-copy warnings were printed.
• git status --short --untracked-files=all showed no untracked/generated artifacts before commit.
• npm run build skipped because no frontend source files changed.
• dotnet build skipped because no .NET source/tooling files changed.
• Full Trip Editor E2E was not run for this Batch 1 documentation/test-label-only change.

Remaining Batch 2+ work:

• Batch 2 real endpoint CRUD UI coverage remains pending for place move/reorder/create, area create/save/reorder/delete, segment create/route-save/reorder/delete, and region create/delete if browser-visible outcome proof is required.
• Batch 3 error/stale-state UX coverage remains pending.
• Batch 4 search-add real Save Place persistence/reload remains pending.
• Batch 5 rich notes backend sanitizer/persistence plus real UI save/reload remains pending.
• Batch 6 published-output Production bundle smoke remains pending.

[stef-k]

Batch 1 Complete

Merged PR #298: #298

Merge SHA: eb0802ad8898d128c4c499d0ebf9dcf029fcf171

Completed scope:

• Added Trip Editor test credibility matrix and testing policy to docs/22-Testing.md.
• Documented that mocked Playwright mutation responses are not E2E CRUD proof.
• Relabeled Trip Editor Playwright test names/comments so mocked/proxy specs are described as frontend rendering, request-shape, affected-slice handling, visual, map-adapter, or proxy behavior.
• No product behavior changes and no real endpoint CRUD coverage were included in this batch.

Validation before merge:

• GitHub test check passed.
• npx playwright test --config=playwright.config.ts --list passed with 106 tests listed.
• LOC check passed with warnings only for existing large Trip Editor/spec files touched by label/comment edits.
• git diff --check origin/main...HEAD passed.
• tracked artifact scan was clean.

Remaining #297 work:

• Batch 2: real endpoint CRUD contract coverage.
• Batch 3: stale/error/dirty/delete feedback and state preservation.
• Batch 4: search-add real persistence after Trip Editor RC geosearch add-place workflow and place-edit parity regressions #295.
• Batch 5: rich-notes persistence/sanitizer real contract.
• Batch 6: Development vs published production asset smoke.

[stef-k]

Batch 2 Complete

Merged PR #299: #299

Merge SHA: e7cdab389fc4dc4aade5029d9721524a5a136e6f

Completed scope:

• Added focused real endpoint CRUD contract coverage in tests/e2e/trip-editor/tripEditorRealCrudContracts.spec.ts.
• Region: create, reorder, delete with visible state and reload/API reread proof.
• Place: create, move normal region <-> Unassigned Places, reorder, delete with visible state and reload/API reread proof.
• Area: create/save, reorder, delete with visible state and reload/API reread proof.
• Segment: endpoint-focused create, route-save, reorder, delete with reload/API reread plus visible row/order/delete assertions.

Important claim boundary:

• Segment coverage proves real endpoint persistence and visible row/order/delete state.
• It does not claim full segment route map-work UI drawing coverage.
• Existing mocked specs remain for frontend rendering, request shape, Sortable/map-work draft behavior, rich notes UI, icon/marker visuals, and error/visual states.

Validation before merge:

• GitHub test check passed.
• Focused new spec passed.
• Segment focused rerun passed.
• Playwright list passed with 110 tests listed.
• dotnet build passed.
• dotnet test passed with 1537 tests.
• LOC check passed under hard cap; new spec warning accepted as cohesive Batch 2 real CRUD contract coverage.
• git diff --check passed.
• tracked artifact scan was clean.

Remaining #297 work:

• Batch 3: stale/error/dirty/delete feedback and state preservation.
• Batch 4: search-add real persistence after Trip Editor RC geosearch add-place workflow and place-edit parity regressions #295.
• Batch 5: rich-notes persistence/sanitizer real contract.
• Batch 6: Development vs published production asset smoke.