diff --git a/.changeset/young-nails-type.md b/.changeset/young-nails-type.md
new file mode 100644
index 000000000..f17d12374
--- /dev/null
+++ b/.changeset/young-nails-type.md
@@ -0,0 +1,5 @@
+---
+'@getodk/web-forms': minor
+---
+
+Adds support for editing the coordinates in geoshape and geotrace question types.
diff --git a/packages/web-forms/e2e/test-cases/visual/all-question-types.test.ts-snapshots/geoshape-autoclose-polygon-chromium.png b/packages/web-forms/e2e/test-cases/visual/all-question-types.test.ts-snapshots/geoshape-autoclose-polygon-chromium.png
index 5e654b6cf..e8b15756f 100644
Binary files a/packages/web-forms/e2e/test-cases/visual/all-question-types.test.ts-snapshots/geoshape-autoclose-polygon-chromium.png and b/packages/web-forms/e2e/test-cases/visual/all-question-types.test.ts-snapshots/geoshape-autoclose-polygon-chromium.png differ
diff --git a/packages/web-forms/e2e/test-cases/visual/all-question-types.test.ts-snapshots/geoshape-autoclose-polygon-firefox.png b/packages/web-forms/e2e/test-cases/visual/all-question-types.test.ts-snapshots/geoshape-autoclose-polygon-firefox.png
index 670cc04fc..a304b6cc5 100644
Binary files a/packages/web-forms/e2e/test-cases/visual/all-question-types.test.ts-snapshots/geoshape-autoclose-polygon-firefox.png and b/packages/web-forms/e2e/test-cases/visual/all-question-types.test.ts-snapshots/geoshape-autoclose-polygon-firefox.png differ
diff --git a/packages/web-forms/e2e/test-cases/visual/all-question-types.test.ts-snapshots/geoshape-autoclose-polygon-webkit.png b/packages/web-forms/e2e/test-cases/visual/all-question-types.test.ts-snapshots/geoshape-autoclose-polygon-webkit.png
index d1896e73b..28ce08d7e 100644
Binary files a/packages/web-forms/e2e/test-cases/visual/all-question-types.test.ts-snapshots/geoshape-autoclose-polygon-webkit.png and b/packages/web-forms/e2e/test-cases/visual/all-question-types.test.ts-snapshots/geoshape-autoclose-polygon-webkit.png differ
diff --git a/packages/web-forms/e2e/test-cases/visual/all-question-types.test.ts-snapshots/geoshape-three-points-chromium.png b/packages/web-forms/e2e/test-cases/visual/all-question-types.test.ts-snapshots/geoshape-three-points-chromium.png
index c6dd5a86d..c7bf1ee90 100644
Binary files a/packages/web-forms/e2e/test-cases/visual/all-question-types.test.ts-snapshots/geoshape-three-points-chromium.png and b/packages/web-forms/e2e/test-cases/visual/all-question-types.test.ts-snapshots/geoshape-three-points-chromium.png differ
diff --git a/packages/web-forms/e2e/test-cases/visual/all-question-types.test.ts-snapshots/geoshape-three-points-firefox.png b/packages/web-forms/e2e/test-cases/visual/all-question-types.test.ts-snapshots/geoshape-three-points-firefox.png
index af48b2b8f..4cf6017b2 100644
Binary files a/packages/web-forms/e2e/test-cases/visual/all-question-types.test.ts-snapshots/geoshape-three-points-firefox.png and b/packages/web-forms/e2e/test-cases/visual/all-question-types.test.ts-snapshots/geoshape-three-points-firefox.png differ
diff --git a/packages/web-forms/e2e/test-cases/visual/all-question-types.test.ts-snapshots/geoshape-three-points-webkit.png b/packages/web-forms/e2e/test-cases/visual/all-question-types.test.ts-snapshots/geoshape-three-points-webkit.png
index 6efcfea7f..36afbcc5c 100644
Binary files a/packages/web-forms/e2e/test-cases/visual/all-question-types.test.ts-snapshots/geoshape-three-points-webkit.png and b/packages/web-forms/e2e/test-cases/visual/all-question-types.test.ts-snapshots/geoshape-three-points-webkit.png differ
diff --git a/packages/web-forms/e2e/test-cases/visual/all-question-types.test.ts-snapshots/geotrace-two-points-chromium.png b/packages/web-forms/e2e/test-cases/visual/all-question-types.test.ts-snapshots/geotrace-two-points-chromium.png
index ce75bbd31..c6e460a8e 100644
Binary files a/packages/web-forms/e2e/test-cases/visual/all-question-types.test.ts-snapshots/geotrace-two-points-chromium.png and b/packages/web-forms/e2e/test-cases/visual/all-question-types.test.ts-snapshots/geotrace-two-points-chromium.png differ
diff --git a/packages/web-forms/e2e/test-cases/visual/all-question-types.test.ts-snapshots/geotrace-two-points-firefox.png b/packages/web-forms/e2e/test-cases/visual/all-question-types.test.ts-snapshots/geotrace-two-points-firefox.png
index c021836f8..2d6576667 100644
Binary files a/packages/web-forms/e2e/test-cases/visual/all-question-types.test.ts-snapshots/geotrace-two-points-firefox.png and b/packages/web-forms/e2e/test-cases/visual/all-question-types.test.ts-snapshots/geotrace-two-points-firefox.png differ
diff --git a/packages/web-forms/e2e/test-cases/visual/all-question-types.test.ts-snapshots/geotrace-two-points-webkit.png b/packages/web-forms/e2e/test-cases/visual/all-question-types.test.ts-snapshots/geotrace-two-points-webkit.png
index 244b060df..e07f025ed 100644
Binary files a/packages/web-forms/e2e/test-cases/visual/all-question-types.test.ts-snapshots/geotrace-two-points-webkit.png and b/packages/web-forms/e2e/test-cases/visual/all-question-types.test.ts-snapshots/geotrace-two-points-webkit.png differ
diff --git a/packages/web-forms/src/components/common/IconSVG.vue b/packages/web-forms/src/components/common/IconSVG.vue
index c44935775..1d4fe26ab 100644
--- a/packages/web-forms/src/components/common/IconSVG.vue
+++ b/packages/web-forms/src/components/common/IconSVG.vue
@@ -12,6 +12,7 @@ import {
 	mdiChevronDown,
 	mdiChevronUp,
 	mdiClose,
+	mdiCogOutline,
 	mdiContentSave,
 	mdiCrosshairsGps,
 	mdiDotsVertical,
@@ -48,6 +49,7 @@ const iconMap: Record<string, string> = {
 	mdiChevronDown,
 	mdiChevronUp,
 	mdiClose,
+	mdiCogOutline,
 	mdiContentSave,
 	mdiCrosshairsGps,
 	mdiDotsVertical,
diff --git a/packages/web-forms/src/components/common/map/AsyncMap.vue b/packages/web-forms/src/components/common/map/AsyncMap.vue
index 1b29067f2..bcec021d1 100644
--- a/packages/web-forms/src/components/common/map/AsyncMap.vue
+++ b/packages/web-forms/src/components/common/map/AsyncMap.vue
@@ -4,21 +4,17 @@
  * This prevents unnecessary bloat in the main application bundle, reducing initial load times and improving performance.
  * Use dynamic imports instead (e.g., `await import(importPath)`) for lazy-loading these dependencies only when required.
  */
+import { createFeatureCollectionAndProps } from '@/components/common/map/geojson-parsers.ts';
+import type { Mode, SingleFeatureType } from '@/components/common/map/getModeConfig.ts';
 import type { SelectItem } from '@getodk/xforms-engine';
+import type { Feature } from 'geojson';
 import ProgressSpinner from 'primevue/progressspinner';
 import { computed, type DefineComponent, onMounted, shallowRef } from 'vue';
-import type { Mode } from '@/components/common/map/getModeConfig.ts';
-import {
-	createFeatureCollectionAndProps,
-	type Feature,
-} from '@/components/common/map/createFeatureCollectionAndProps.ts';
-
-type DrawFeatureType = 'shape' | 'trace';
 
 type MapBlockComponent = DefineComponent<{
 	featureCollection: { type: string; features: Feature[] };
 	disabled: boolean;
-	drawFeatureType?: DrawFeatureType;
+	singleFeatureType?: SingleFeatureType;
 	mode: Mode;
 	orderedExtraProps: Map<string, Array<[key: string, value: string]>>;
 	savedFeatureValue: Feature | undefined;
@@ -27,7 +23,7 @@ type MapBlockComponent = DefineComponent<{
 interface AsyncMapProps {
 	features?: readonly SelectItem[];
 	disabled: boolean;
-	drawFeatureType?: DrawFeatureType;
+	singleFeatureType?: SingleFeatureType;
 	mode: Mode;
 	savedFeatureValue: string | undefined;
 }
@@ -86,7 +82,7 @@ onMounted(loadMap);
 		<component
 			:is="mapComponent"
 			v-else
-			:draw-feature-type="drawFeatureType"
+			:single-feature-type="singleFeatureType"
 			:feature-collection="featureCollectionAndProps.featureCollection"
 			:mode="mode"
 			:ordered-extra-props="featureCollectionAndProps.orderedExtraPropsMap"
diff --git a/packages/web-forms/src/components/common/map/MapAdvancedPanel.vue b/packages/web-forms/src/components/common/map/MapAdvancedPanel.vue
new file mode 100644
index 000000000..36e710601
--- /dev/null
+++ b/packages/web-forms/src/components/common/map/MapAdvancedPanel.vue
@@ -0,0 +1,269 @@
+<script setup lang="ts">
+import IconSVG from '@/components/common/IconSVG.vue';
+import {
+	isNullLocation,
+	isValidLatitude,
+	isValidLongitude,
+	toGeoJsonCoordinateArray,
+} from '@/components/common/map/geojson-parsers.ts';
+import { fromLonLat } from 'ol/proj';
+import { computed, ref, watch } from 'vue';
+import type { Coordinate } from 'ol/coordinate';
+
+const props = defineProps<{
+	isOpen: boolean;
+	coordinates: Coordinate | null;
+}>();
+
+const emit = defineEmits(['open-paste-dialog', 'save']);
+
+const latitude = ref<number | undefined>();
+const longitude = ref<number | undefined>();
+const accuracy = ref<number | undefined>();
+const altitude = ref<number | undefined>();
+const disableInputs = computed(() => !props.coordinates?.length);
+const validLatitude = computed(() => {
+	return isValidLatitude(latitude.value) && !isNullLocation(latitude.value, longitude.value);
+});
+const validLongitude = computed(() => {
+	return isValidLongitude(longitude.value) && !isNullLocation(latitude.value, longitude.value);
+});
+
+watch(
+	() => props.coordinates,
+	(newVal) => {
+		if (newVal) {
+			[longitude.value, latitude.value, altitude.value, accuracy.value] = newVal;
+			return;
+		}
+		accuracy.value = undefined;
+		latitude.value = undefined;
+		altitude.value = undefined;
+		longitude.value = undefined;
+	},
+	{ immediate: true }
+);
+
+const updateVertex = () => {
+	if (!validLatitude.value || !validLongitude.value) {
+		return;
+	}
+
+	const newVertex = toGeoJsonCoordinateArray(
+		Number(longitude.value),
+		Number(latitude.value),
+		Number(altitude.value),
+		Number(accuracy.value)
+	) as Coordinate;
+
+	if (newVertex.length) {
+		emit('save', fromLonLat(newVertex));
+	}
+};
+</script>
+
+<template>
+	<transition name="panel">
+		<div v-if="isOpen" class="advanced-panel">
+			<div class="fields-container">
+				<div :class="{ 'field-error': !disableInputs && !validLongitude }" class="field-set">
+					<div class="input-wrap">
+						<!-- TODO: translations -->
+						<label for="longitude">Longitude</label>
+						<input
+							id="longitude"
+							v-model="longitude"
+							type="number"
+							:disabled="disableInputs"
+							@change="updateVertex"
+						>
+					</div>
+					<!-- TODO: translations -->
+					<p class="field-error-message">
+						Longitude is invalid
+					</p>
+				</div>
+				<div :class="{ 'field-error': !disableInputs && !validLatitude }" class="field-set">
+					<div class="input-wrap">
+						<!-- TODO: translations -->
+						<label for="latitude">Latitude</label>
+						<input
+							id="latitude"
+							v-model="latitude"
+							type="number"
+							:disabled="disableInputs"
+							@change="updateVertex"
+						>
+					</div>
+					<!-- TODO: translations -->
+					<p class="field-error-message">
+						Latitude is invalid
+					</p>
+				</div>
+				<div class="field-set">
+					<div class="input-wrap">
+						<!-- TODO: translations -->
+						<label for="altitude">Altitude</label>
+						<input
+							id="altitude"
+							v-model="altitude"
+							type="number"
+							:disabled="disableInputs"
+							@change="updateVertex"
+						>
+					</div>
+				</div>
+				<div class="field-set">
+					<div class="input-wrap">
+						<!-- TODO: translations -->
+						<label for="accuracy">Accuracy</label>
+						<input
+							id="accuracy"
+							v-model="accuracy"
+							type="number"
+							:disabled="disableInputs"
+							@change="updateVertex"
+						>
+					</div>
+				</div>
+			</div>
+
+			<a class="paste-location" @click="emit('open-paste-dialog')">
+				<IconSVG name="mdiFileOutline" size="sm" />
+				<!-- TODO: translations -->
+				<strong>Import data to replace location</strong>
+			</a>
+		</div>
+	</transition>
+</template>
+
+<style scoped lang="scss">
+.advanced-panel {
+	--odk-double-map-spacing: calc(var(--odk-map-controls-spacing) * 2);
+}
+
+.advanced-panel {
+	background: var(--odk-base-background-color);
+	border-top: 1px solid var(--odk-border-color);
+	display: flex;
+	flex-direction: column;
+	align-items: flex-start;
+	gap: 3px;
+}
+
+.fields-container {
+	display: flex;
+	flex-wrap: wrap;
+	gap: var(--odk-double-map-spacing);
+	padding: var(--odk-double-map-spacing) var(--odk-map-controls-spacing);
+
+	.field-set {
+		display: flex;
+		flex: 1 1 calc(50% - var(--odk-double-map-spacing));
+		flex-direction: column;
+	}
+
+	.input-wrap {
+		display: flex;
+		flex-direction: row;
+		border-radius: var(--odk-radius);
+		overflow: hidden;
+		background-color: var(--odk-muted-background-color);
+		height: 38px;
+		min-width: 250px;
+	}
+
+	label {
+		padding: var(--odk-map-controls-spacing);
+		background-color: var(--odk-light-background-color);
+		color: var(--odk-text-color);
+		font-weight: normal;
+		font-size: var(--odk-base-font-size);
+		border-radius: var(--odk-radius) 0 0 var(--odk-radius);
+		border: 1px solid var(--odk-border-color);
+		border-right: none;
+		display: flex;
+		align-items: center;
+		white-space: nowrap;
+		flex-basis: 110px;
+		flex-shrink: 0;
+		max-width: 150px;
+	}
+
+	input {
+		padding: var(--odk-map-controls-spacing);
+		width: 100%;
+		background-color: var(--odk-base-background-color);
+		border-radius: 0 var(--odk-radius) var(--odk-radius) 0;
+		border: 1px solid var(--odk-border-color);
+		font-size: var(--odk-base-font-size);
+		color: var(--odk-text-color);
+		-moz-appearance: textfield;
+
+		&:focus-visible {
+			outline: none;
+			outline-offset: unset;
+		}
+
+		&::-webkit-outer-spin-button,
+		&::-webkit-inner-spin-button {
+			appearance: none;
+			-webkit-appearance: none;
+			margin: 0;
+		}
+
+		&:disabled {
+			background-color: var(--odk-muted-background-color);
+			cursor: not-allowed;
+		}
+	}
+
+	.field-error-message {
+		margin: 8px 0 0 0;
+		color: var(--odk-error-text-color);
+		display: none;
+	}
+
+	.field-error {
+		.field-error-message {
+			display: block;
+		}
+
+		.input-wrap input {
+			border: 1px solid var(--odk-error-text-color);
+		}
+	}
+}
+
+.paste-location {
+	display: flex;
+	flex-direction: row;
+	align-items: center;
+	gap: 8px;
+	padding: var(--odk-double-map-spacing);
+	text-decoration: none;
+	cursor: pointer;
+	font-size: var(--odk-base-font-size);
+	color: var(--odk-text-color);
+}
+
+.panel-enter-active,
+.panel-leave-active {
+	transition:
+		max-height 0.6s ease-in-out,
+		opacity 0.6s ease-in-out;
+	overflow: hidden;
+}
+
+.panel-enter-from,
+.panel-leave-to {
+	max-height: 0;
+	opacity: 0;
+}
+
+.panel-enter-to,
+.panel-leave-from {
+	max-height: 300px;
+	opacity: 1;
+}
+</style>
diff --git a/packages/web-forms/src/components/common/map/MapBlock.vue b/packages/web-forms/src/components/common/map/MapBlock.vue
index 712658882..eecdd4925 100644
--- a/packages/web-forms/src/components/common/map/MapBlock.vue
+++ b/packages/web-forms/src/components/common/map/MapBlock.vue
@@ -5,16 +5,18 @@
  * load on demand. Avoids main bundle bloat.
  */
 import IconSVG from '@/components/common/IconSVG.vue';
-import type { Mode } from '@/components/common/map/getModeConfig.ts';
-import MapConfirm from '@/components/common/map/MapConfirm.vue';
+import { type Mode, type SingleFeatureType } from '@/components/common/map/getModeConfig.ts';
+import MapAdvancedPanel from '@/components/common/map/MapAdvancedPanel.vue';
+import MapConfirmDialog from '@/components/common/map/MapConfirmDialog.vue';
 import MapControls from '@/components/common/map/MapControls.vue';
 import MapProperties from '@/components/common/map/MapProperties.vue';
 import MapStatusBar from '@/components/common/map/MapStatusBar.vue';
+import MapUpdateCoordsDialog from '@/components/common/map/MapUpdateCoordsDialog.vue';
 import { STATES, useMapBlock } from '@/components/common/map/useMapBlock.ts';
-import { type DrawFeatureType } from '@/components/common/map/useMapInteractions.ts';
 import { QUESTION_HAS_ERROR } from '@/lib/constants/injection-keys.ts';
 import type { Feature, FeatureCollection } from 'geojson';
 import type { Coordinate } from 'ol/coordinate';
+import { toLonLat } from 'ol/proj';
 import Button from 'primevue/button';
 import Message from 'primevue/message';
 import { computed, type ComputedRef, inject, onMounted, onUnmounted, ref, watch } from 'vue';
@@ -22,7 +24,7 @@ import { computed, type ComputedRef, inject, onMounted, onUnmounted, ref, watch
 interface MapBlockProps {
 	featureCollection: FeatureCollection;
 	disabled: boolean;
-	drawFeatureType?: DrawFeatureType;
+	singleFeatureType?: SingleFeatureType;
 	mode: Mode;
 	orderedExtraProps: Map<string, Array<[string, string]>>;
 	savedFeatureValue: Feature | undefined;
@@ -32,7 +34,9 @@ const props = defineProps<MapBlockProps>();
 const emit = defineEmits(['save']);
 const mapElement = ref<HTMLElement | undefined>();
 const isFullScreen = ref(false);
+const isAdvancedPanelOpen = ref(false);
 const confirmDeleteAction = ref(false);
+const isUpdateCoordsDialogOpen = ref(false);
 const selectedVertex = ref<Coordinate | undefined>();
 const showErrorStyle = inject<ComputedRef<boolean>>(
 	QUESTION_HAS_ERROR,
@@ -40,13 +44,20 @@ const showErrorStyle = inject<ComputedRef<boolean>>(
 );
 
 const mapHandler = useMapBlock(
-	{ mode: props.mode, drawFeatureType: props.drawFeatureType },
+	{ mode: props.mode, singleFeatureType: props.singleFeatureType },
 	{
 		onFeaturePlacement: () => emitSavedFeature(),
 		onVertexSelect: (vertex) => (selectedVertex.value = vertex),
 	}
 );
 
+const advancedPanelCoords = computed<Coordinate | null>(() => {
+	if (!mapHandler.canOpenAdvancedPanel()) {
+		return null;
+	}
+	return selectedVertex.value?.length ? toLonLat(selectedVertex.value) : null;
+});
+
 const showSecondaryControls = computed(() => {
 	return !props.disabled && (mapHandler.canUndoChange() || mapHandler.canDeleteFeatureOrVertex());
 });
@@ -126,6 +137,16 @@ const undoLastChange = () => {
 	mapHandler.undoLastChange();
 	emitSavedFeature();
 };
+
+const updateFeatureCoords = (newCoords: Coordinate[] | Coordinate[][]) => {
+	mapHandler.updateFeatureCoordinates(newCoords);
+	emitSavedFeature();
+};
+
+const saveAdvancedPanelCoords = (newCoords: Coordinate) => {
+	mapHandler.updateVertexCoords(newCoords);
+	emitSavedFeature();
+};
 </script>
 
 <template>
@@ -167,15 +188,25 @@ const undoLastChange = () => {
 			</div>
 
 			<MapStatusBar
-				:draw-feature-type="drawFeatureType"
+				:can-open-advanced-panel="!disabled && mapHandler.canOpenAdvancedPanel()"
+				:can-remove="!disabled && mapHandler.canRemoveCurrentLocation()"
+				:can-view-details="mapHandler.canViewProperties()"
+				:single-feature-type="singleFeatureType"
+				:is-capturing="mapHandler.currentState.value === STATES.CAPTURING"
 				:saved-feature-value="savedFeatureValue"
 				:selected-vertex="selectedVertex"
-				:is-capturing="mapHandler.currentState.value === STATES.CAPTURING"
 				class="map-status-bar-component"
-				:can-remove="!disabled && mapHandler.canRemoveCurrentLocation()"
-				:can-view-details="mapHandler.canViewProperties()"
 				@discard="discardSavedFeature"
 				@view-details="mapHandler.selectSavedFeature"
+				@toggle-advanced-panel="isAdvancedPanelOpen = !isAdvancedPanelOpen"
+			/>
+
+			<MapAdvancedPanel
+				v-if="!disabled && mapHandler.canOpenAdvancedPanel()"
+				:is-open="isAdvancedPanelOpen"
+				:coordinates="advancedPanelCoords"
+				@open-paste-dialog="isUpdateCoordsDialogOpen = true"
+				@save="saveAdvancedPanelCoords"
 			/>
 
 			<MapProperties
@@ -201,11 +232,17 @@ const undoLastChange = () => {
 		</div>
 	</div>
 
-	<MapConfirm
+	<MapConfirmDialog
 		v-model:visible="confirmDeleteAction"
-		:draw-feature-type="drawFeatureType"
+		:single-feature-type="singleFeatureType"
 		@delete-feature="deleteFeature"
 	/>
+
+	<MapUpdateCoordsDialog
+		v-model:visible="isUpdateCoordsDialogOpen"
+		:single-feature-type="singleFeatureType"
+		@save="updateFeatureCoords"
+	/>
 </template>
 
 <style scoped lang="scss">
diff --git a/packages/web-forms/src/components/common/map/MapConfirm.vue b/packages/web-forms/src/components/common/map/MapConfirmDialog.vue
similarity index 73%
rename from packages/web-forms/src/components/common/map/MapConfirm.vue
rename to packages/web-forms/src/components/common/map/MapConfirmDialog.vue
index 2a8c39706..153075896 100644
--- a/packages/web-forms/src/components/common/map/MapConfirm.vue
+++ b/packages/web-forms/src/components/common/map/MapConfirmDialog.vue
@@ -1,13 +1,13 @@
 <script setup lang="ts">
 import {
-	DRAW_FEATURE_TYPES,
-	type DrawFeatureType,
-} from '@/components/common/map/useMapInteractions.ts';
+	SINGLE_FEATURE_TYPES,
+	type SingleFeatureType,
+} from '@/components/common/map/getModeConfig.ts';
 import Button from 'primevue/button';
 import Dialog from 'primevue/dialog';
 
 defineProps<{
-	drawFeatureType: DrawFeatureType | undefined;
+	singleFeatureType: SingleFeatureType | undefined;
 	visible: boolean;
 }>();
 
@@ -15,16 +15,22 @@ const emit = defineEmits(['update:visible', 'deleteFeature']);
 </script>
 
 <template>
-	<Dialog :visible="visible" modal class="map-block-dialog" :draggable="false" @update:visible="emit('update:visible', $event)">
+	<Dialog
+		:visible="visible"
+		modal
+		class="map-block-dialog"
+		:draggable="false"
+		@update:visible="emit('update:visible', $event)"
+	>
 		<template #header>
 			<!-- TODO: translations -->
-			<strong v-if="drawFeatureType === DRAW_FEATURE_TYPES.SHAPE">Delete entire shape?</strong>
+			<strong v-if="singleFeatureType === SINGLE_FEATURE_TYPES.SHAPE">Delete entire shape?</strong>
 			<strong v-else>Delete entire trace?</strong>
 		</template>
 
 		<template #default>
 			<!-- TODO: translations -->
-			<p v-if="drawFeatureType === DRAW_FEATURE_TYPES.SHAPE">
+			<p v-if="singleFeatureType === SINGLE_FEATURE_TYPES.SHAPE">
 				Are you sure you want to delete this entire shape and start over?
 			</p>
 			<p v-else>
diff --git a/packages/web-forms/src/components/common/map/MapStatusBar.vue b/packages/web-forms/src/components/common/map/MapStatusBar.vue
index 65b1d584f..24b3e402e 100644
--- a/packages/web-forms/src/components/common/map/MapStatusBar.vue
+++ b/packages/web-forms/src/components/common/map/MapStatusBar.vue
@@ -1,9 +1,9 @@
 <script setup lang="ts">
 import IconSVG from '@/components/common/IconSVG.vue';
 import {
-	DRAW_FEATURE_TYPES,
-	type DrawFeatureType,
-} from '@/components/common/map/useMapInteractions.ts';
+	SINGLE_FEATURE_TYPES,
+	type SingleFeatureType,
+} from '@/components/common/map/getModeConfig.ts';
 import { isCoordsEqual } from '@/components/common/map/vertex-geometry.ts';
 import { truncateDecimals } from '@/lib/format/truncate-decimals.ts';
 import type { Feature, LineString, Point, Polygon, Position } from 'geojson';
@@ -22,24 +22,25 @@ interface StatusDetails {
 const props = defineProps<{
 	savedFeatureValue: Feature | undefined;
 	selectedVertex: Coordinate | undefined;
-	drawFeatureType?: DrawFeatureType;
+	singleFeatureType?: SingleFeatureType;
 	isCapturing: boolean;
 	canRemove: boolean;
 	canViewDetails: boolean;
+	canOpenAdvancedPanel: boolean;
 }>();
 
-const emit = defineEmits(['view-details', 'discard']);
+const emit = defineEmits(['discard', 'toggle-advanced-panel', 'view-details']);
 
 const LINE_ICON = 'mdiVectorPolyline';
 const POLYGON_ICON = 'mdiVectorPolygon';
 
 const noSavedStatus = computed<StatusDetails>(() => {
 	// TODO: translations
-	if (props.drawFeatureType === DRAW_FEATURE_TYPES.TRACE) {
+	if (props.singleFeatureType === SINGLE_FEATURE_TYPES.TRACE) {
 		return { message: 'No trace saved', icon: LINE_ICON };
 	}
 
-	if (props.drawFeatureType === DRAW_FEATURE_TYPES.SHAPE) {
+	if (props.singleFeatureType === SINGLE_FEATURE_TYPES.SHAPE) {
 		return { message: 'No shape saved', icon: POLYGON_ICON };
 	}
 
@@ -66,18 +67,17 @@ const selectedVertexInfo = computed(() => {
 });
 
 const countPoints = (coords: Position | Position[] | Position[][] | undefined = []) => {
-	const isPoint = !props.drawFeatureType && coords?.length;
-	if (isPoint) {
+	if (props.singleFeatureType === SINGLE_FEATURE_TYPES.POINT && coords?.length) {
 		return 1;
 	}
 
-	if (props.drawFeatureType === DRAW_FEATURE_TYPES.TRACE) {
+	if (props.singleFeatureType === SINGLE_FEATURE_TYPES.TRACE) {
 		return coords.length;
 	}
 
 	const ring = coords[0];
 	if (
-		props.drawFeatureType === DRAW_FEATURE_TYPES.SHAPE &&
+		props.singleFeatureType === SINGLE_FEATURE_TYPES.SHAPE &&
 		Array.isArray(ring) &&
 		isCoordsEqual(ring[0] as [number, number], ring[ring.length - 1] as [number, number])
 	) {
@@ -87,8 +87,35 @@ const countPoints = (coords: Position | Position[] | Position[][] | undefined =
 	return 0;
 };
 
+const getSavedMessageForMultiFeature = (type: string) => {
+	const geometryType = type?.toLowerCase();
+	// TODO: translations
+	if (geometryType === 'point') {
+		return 'Point saved';
+	}
+
+	if (geometryType === 'linestring') {
+		return 'Trace saved';
+	}
+
+	if (geometryType === 'polygon') {
+		return 'Shape saved';
+	}
+
+	return 'Feature saved';
+};
+
 const savedStatus = computed<StatusDetails | null>(() => {
 	const geometry = props.savedFeatureValue?.geometry as LineString | Point | Polygon | undefined;
+	const expectAnyFeature = !props.singleFeatureType;
+	if (expectAnyFeature && geometry) {
+		return {
+			message: getSavedMessageForMultiFeature(geometry.type),
+			icon: 'mdiCheckCircle',
+			highlight: true,
+		};
+	}
+
 	const count = countPoints(geometry?.coordinates);
 	if (count === 0) {
 		return null;
@@ -96,11 +123,11 @@ const savedStatus = computed<StatusDetails | null>(() => {
 
 	// TODO: translations
 	const message = `${count} points saved`;
-	if (props.drawFeatureType === DRAW_FEATURE_TYPES.TRACE) {
+	if (props.singleFeatureType === SINGLE_FEATURE_TYPES.TRACE) {
 		return { message, icon: LINE_ICON };
 	}
 
-	if (props.drawFeatureType === DRAW_FEATURE_TYPES.SHAPE) {
+	if (props.singleFeatureType === SINGLE_FEATURE_TYPES.SHAPE) {
 		return { message, icon: POLYGON_ICON };
 	}
 
@@ -127,16 +154,18 @@ const savedStatus = computed<StatusDetails | null>(() => {
 				<IconSVG :name="savedStatus.icon" :variant="savedStatus.highlight ? 'success' : 'base'" />
 				<span>{{ savedStatus.message }}</span>
 			</div>
-			<Button v-if="canRemove" outlined severity="contrast" @click="emit('discard')">
-				<span>–</span>
-				<!-- TODO: translations -->
-				<span class="mobile-only">Remove</span>
-				<span class="desktop-only">Remove point</span>
-			</Button>
-			<Button v-if="canViewDetails" outlined severity="contrast" @click="emit('view-details')">
-				<!-- TODO: translations -->
-				<span>View details</span>
-			</Button>
+			<div class="map-status-buttons">
+				<Button v-if="canRemove" outlined severity="contrast" @click="emit('discard')">
+					<span>–</span>
+					<!-- TODO: translations -->
+					<span class="mobile-only">Remove</span>
+					<span class="desktop-only">Remove point</span>
+				</Button>
+				<Button v-if="canViewDetails" outlined severity="contrast" @click="emit('view-details')">
+					<!-- TODO: translations -->
+					<span>View details</span>
+				</Button>
+			</div>
 		</div>
 
 		<div v-else class="map-status-container">
@@ -146,10 +175,24 @@ const savedStatus = computed<StatusDetails | null>(() => {
 				<span>{{ noSavedStatus.message }}</span>
 			</div>
 		</div>
+
+		<Button
+			v-if="canOpenAdvancedPanel"
+			class="advanced-button"
+			outlined
+			severity="contrast"
+			@click="emit('toggle-advanced-panel')"
+		>
+			<IconSVG name="mdiCogOutline" />
+			<!-- TODO: translations -->
+			<span>Advanced</span>
+		</Button>
 	</div>
 </template>
 
 <style scoped lang="scss">
+@use 'primeflex/core/_variables.scss' as pf;
+
 .map-status-bar,
 .map-status-container,
 .map-status {
@@ -181,10 +224,25 @@ const savedStatus = computed<StatusDetails | null>(() => {
 	&:hover {
 		background: var(--odk-muted-background-color);
 	}
+
+	&:disabled {
+		cursor: not-allowed;
+	}
 }
 
 .map-status-spinner {
 	width: 20px;
 	height: 20px;
 }
+
+.map-status-buttons {
+	display: flex;
+	gap: var(--odk-map-controls-spacing);
+}
+
+@media screen and (max-width: #{pf.$sm}) {
+	.advanced-button span {
+		display: none;
+	}
+}
 </style>
diff --git a/packages/web-forms/src/components/common/map/MapUpdateCoordsDialog.vue b/packages/web-forms/src/components/common/map/MapUpdateCoordsDialog.vue
new file mode 100644
index 000000000..60cacbbf1
--- /dev/null
+++ b/packages/web-forms/src/components/common/map/MapUpdateCoordsDialog.vue
@@ -0,0 +1,306 @@
+<script setup lang="ts">
+import {
+	parseGeoJSONGeometry,
+	getGeometryFromJSON,
+} from '@/components/common/map/geojson-parsers.ts';
+import type { SingleFeatureType } from '@/components/common/map/getModeConfig.ts';
+import { getValidCoordinates } from '@/components/common/map/map-helpers.ts';
+import type { Geometry, LineString, Point, Polygon } from 'geojson';
+import Button from 'primevue/button';
+import Dialog from 'primevue/dialog';
+import Textarea from 'primevue/textarea';
+import IconSVG from '@/components/common/IconSVG.vue';
+import { ref, watch } from 'vue';
+
+const props = defineProps<{
+	visible: boolean;
+	singleFeatureType?: SingleFeatureType;
+}>();
+
+const emit = defineEmits(['update:visible', 'save']);
+
+const pasteValue = ref('');
+const fileInput = ref<HTMLInputElement | null>(null);
+const selectedFile = ref<File | null>(null);
+const isParsing = ref(false);
+const pasteError = ref<string | null>(null);
+const uploadError = ref<string | null>(null);
+
+const openFileChooser = () => {
+	reset();
+	fileInput.value?.click();
+};
+
+const selectFile = (event: Event) => {
+	const input = event.target as HTMLInputElement;
+	const file = input.files?.[0];
+	if (file) {
+		selectedFile.value = file;
+	}
+};
+
+const parseFileCoordinates = async (file: File): Promise<Geometry | undefined> => {
+	try {
+		const text = await file.text();
+		if (!text?.trim()?.length) {
+			// TODO: translations
+			setUploadErrorIfBlank('File is empty.');
+			return;
+		}
+
+		const fileName = file.name.toLowerCase();
+		if (fileName.endsWith('.geojson')) {
+			return getGeometryFromJSON(text);
+		}
+
+		// TODO: translations
+		setUploadErrorIfBlank('Unsupported file type. Please upload a .geojson file.');
+	} catch {
+		// TODO: translations
+		setUploadErrorIfBlank('Failed to parse file. Ensure it is a valid GeoJSON.');
+	}
+};
+
+const parsePastedValue = () => {
+	const value = pasteValue.value.trim();
+	if (!value.length) {
+		return;
+	}
+
+	return parseGeoJSONGeometry(value);
+};
+
+const save = async () => {
+	resetErrors();
+	isParsing.value = true;
+	let geometry;
+	if (selectedFile.value) {
+		geometry = await parseFileCoordinates(selectedFile.value);
+	} else if (pasteValue.value.length) {
+		geometry = parsePastedValue();
+	}
+
+	const coordinates = getValidCoordinates(
+		geometry as LineString | Point | Polygon | undefined,
+		props.singleFeatureType
+	);
+	isParsing.value = false;
+
+	// TODO: translations
+	const errorMessage = 'Incorrect geometry type.';
+	if (!coordinates?.length && selectedFile.value) {
+		setUploadErrorIfBlank(errorMessage);
+		return;
+	}
+
+	if (!coordinates?.length && pasteValue.value.length) {
+		setPasteErrorIfBlank(errorMessage);
+		return;
+	}
+
+	close();
+	emit('save', coordinates);
+};
+
+const close = () => {
+	reset();
+	emit('update:visible', false);
+};
+
+const reset = () => {
+	pasteValue.value = '';
+	isParsing.value = false;
+	resetSelectedFile();
+	resetErrors();
+};
+
+const resetSelectedFile = () => {
+	selectedFile.value = null;
+	if (fileInput.value) {
+		fileInput.value.value = '';
+	}
+};
+
+const resetErrors = () => {
+	pasteError.value = null;
+	uploadError.value = null;
+};
+
+const setUploadErrorIfBlank = (message: string) => (uploadError.value ??= message);
+
+const setPasteErrorIfBlank = (message: string) => (pasteError.value ??= message);
+
+watch(pasteValue, (newVal) => {
+	resetErrors();
+	if (newVal && selectedFile.value) {
+		resetSelectedFile();
+	}
+});
+</script>
+
+<template>
+	<Dialog
+		:visible="visible"
+		modal
+		class="map-paste-dialog"
+		:draggable="false"
+		@update:visible="emit('update:visible', $event)"
+		@after-hide="reset"
+	>
+		<template #header>
+			<!-- TODO: translations -->
+			<strong>Import data to replace location</strong>
+		</template>
+
+		<template #default>
+			<div class="dialog-field-container">
+				<!-- TODO: translations -->
+				<label for="paste-input">
+					<span>Paste data in ODK format</span>
+					<span
+						class="info-helper"
+						title="Enter as: Lat Long Alt Acc (e.g. 45.5 -122.6 15 2; 45.6 -122.7 12 3)"
+					>
+						&#9432;
+					</span>
+				</label>
+				<Textarea
+					id="paste-input"
+					v-model="pasteValue"
+					:disabled="isParsing"
+					auto-resize
+					rows="1"
+				/>
+				<p v-if="pasteError?.length" class="coords-error-message">
+					{{ pasteError }}
+				</p>
+			</div>
+
+			<div class="dialog-field-container">
+				<!-- TODO: translations -->
+				<label>Upload a GeoJSON file</label>
+				<!-- TODO: translations -->
+				<div v-if="selectedFile" class="file-added-container">
+					<IconSVG name="mdiFileOutline" />
+					<span class="file-name">{{ selectedFile.name }}</span>
+					<IconSVG class="clear-file" name="mdiClose" variant="muted" size="sm" @click="reset" />
+				</div>
+				<p v-if="uploadError?.length" class="coords-error-message">
+					{{ uploadError }}
+				</p>
+				<Button
+					class="upload-button"
+					outlined
+					severity="contrast"
+					:disabled="isParsing"
+					@click="openFileChooser"
+				>
+					<IconSVG name="mdiUpload" />
+					<!-- TODO: translations -->
+					<span>Upload file</span>
+				</Button>
+
+				<input
+					ref="fileInput"
+					type="file"
+					accept=".geojson,application/json"
+					@change="selectFile"
+				>
+			</div>
+		</template>
+
+		<template #footer>
+			<Button label="Save" :disabled="!selectedFile && !pasteValue.length" @click="save" />
+		</template>
+	</Dialog>
+</template>
+
+<style scoped lang="scss">
+.dialog-field-container {
+	display: flex;
+	flex-direction: column;
+	align-items: flex-start;
+	gap: 10px;
+
+	label {
+		font-size: var(--odk-base-font-size);
+		color: var(--odk-text-color);
+	}
+
+	input[type='file'] {
+		display: none;
+	}
+
+	.upload-button {
+		margin-top: 10px;
+	}
+
+	.info-helper {
+		font-size: var(--odk-hint-font-size);
+		font-weight: bold;
+		cursor: pointer;
+	}
+
+	#paste-input {
+		width: 100%;
+		padding: 10px;
+	}
+}
+
+.coords-error-message {
+	display: block;
+	color: var(--odk-error-text-color);
+	margin: 0;
+}
+
+.file-added-container {
+	display: flex;
+	align-items: center;
+	gap: 10px;
+	border: 1px solid var(--odk-border-color);
+	border-radius: var(--odk-radius);
+	padding: 10px;
+
+	.file-name {
+		flex: 1 1 100px;
+	}
+
+	.clear-file {
+		cursor: pointer;
+	}
+}
+</style>
+
+<style lang="scss">
+// Global overrides for this dialog
+.p-dialog.map-paste-dialog {
+	background: var(--odk-base-background-color);
+	border-radius: var(--odk-radius);
+	margin: 0 24px;
+	width: 550px;
+
+	.p-dialog-header {
+		padding: 15px 20px;
+		font-size: var(--odk-dialog-title-font-size);
+	}
+
+	.p-dialog-content {
+		display: flex;
+		flex-direction: column;
+		gap: 35px;
+		padding: 20px;
+	}
+
+	.p-dialog-footer button {
+		font-size: var(--odk-base-font-size);
+		&:disabled {
+			cursor: not-allowed;
+		}
+	}
+
+	button.p-button-secondary:focus-visible {
+		outline: none;
+		outline-offset: unset;
+	}
+}
+</style>
diff --git a/packages/web-forms/src/components/common/map/createFeatureCollectionAndProps.ts b/packages/web-forms/src/components/common/map/geojson-parsers.ts
similarity index 51%
rename from packages/web-forms/src/components/common/map/createFeatureCollectionAndProps.ts
rename to packages/web-forms/src/components/common/map/geojson-parsers.ts
index 2ef2355d9..757dd2c1c 100644
--- a/packages/web-forms/src/components/common/map/createFeatureCollectionAndProps.ts
+++ b/packages/web-forms/src/components/common/map/geojson-parsers.ts
@@ -1,4 +1,11 @@
+/**
+ * IMPORTANT: OpenLayers is not statically imported here to enable bundling them into a separate chunk.
+ * This prevents unnecessary bloat in the main application bundle, reducing initial load times and improving performance.
+ *
+ * This file is for GeoJSON logic, which should not use OpenLayers types directly.
+ */
 import type { SelectItem } from '@getodk/xforms-engine';
+import type { Feature, FeatureCollection, Geometry, LineString, Point, Polygon } from 'geojson';
 
 const PROPERTY_PREFIX = 'odk_'; // Avoids conflicts with OpenLayers (for example, geometry).
 
@@ -17,39 +24,69 @@ const RESERVED_MAP_PROPERTIES = [
 
 type Coordinates = [longitude: number, latitude: number];
 
-interface Geometry {
-	type: 'LineString' | 'Point' | 'Polygon';
-	coordinates: Coordinates | Coordinates[] | Coordinates[][];
-}
+// Longitude is first for GeoJSON and latitude is second.
+export const toGeoJsonCoordinateArray = (
+	longitude: number,
+	latitude: number,
+	altitude: number | null | undefined,
+	accuracy: number | null | undefined
+): number[] => {
+	const coords = [];
+	if (
+		isValidLatitude(latitude) &&
+		isValidLongitude(longitude) &&
+		!isNullLocation(latitude, longitude)
+	) {
+		coords.push(longitude, latitude);
+
+		if (isAccuracyProvided(accuracy)) {
+			coords.push(isAltitudeProvided(altitude) ? altitude! : 0, accuracy!);
+		} else if (isAltitudeProvided(altitude)) {
+			coords.push(altitude!);
+		}
+	}
 
-export interface Feature {
-	type: 'Feature';
-	geometry: Geometry;
-	properties: Record<string, string>;
-}
+	return coords;
+};
 
-const getGeoJSONCoordinates = (geometry: string): [Coordinates, ...Coordinates[]] | undefined => {
-	const coordinates: Coordinates[] = [];
-	for (const coord of geometry.split(';')) {
-		const [lat, lon] = coord.trim().split(/\s+/).map(Number);
+export const isNullLocation = (lat: number | null | undefined, lon: number | null | undefined) => {
+	return lat === 0 && lon === 0;
+};
 
-		const isNullLocation = lat === 0 && lon === 0;
-		const isValidLatitude = lat != null && !Number.isNaN(lat) && Math.abs(lat) <= 90;
-		const isValidLongitude = lon != null && !Number.isNaN(lon) && Math.abs(lon) <= 180;
+export const isValidLatitude = (lat: number | null | undefined) => {
+	return lat != null && Number.isFinite(lat) && Math.abs(lat) <= 90;
+};
+
+export const isValidLongitude = (lon: number | null | undefined) => {
+	return lon != null && Number.isFinite(lon) && Math.abs(lon) <= 180;
+};
+
+export const isAltitudeProvided = (alt: number | null | undefined) => {
+	return alt != null && Number.isFinite(alt);
+};
 
-		if (isNullLocation || !isValidLatitude || !isValidLongitude) {
+export const isAccuracyProvided = (acc: number | null | undefined) => {
+	return acc != null && Number.isFinite(acc);
+};
+
+const parseGeoJSONCoordinates = (geometry: string): [Coordinates, ...Coordinates[]] | undefined => {
+	const coordinates: Coordinates[] = [];
+	for (const coord of geometry.split(';')) {
+		const [lat, lon, alt, acc] = coord.trim().split(/\s+/).map(Number);
+		if (!isValidLatitude(lat) || !isValidLongitude(lon) || isNullLocation(lat, lon)) {
 			// eslint-disable-next-line no-console -- Skip silently to match Collect behaviour.
 			console.warn(`Invalid geo point coordinates: ${geometry}`);
 			return;
 		}
 
-		coordinates.push([lon, lat]);
+		const parsedCoords = toGeoJsonCoordinateArray(lon!, lat!, alt, acc) as Coordinates;
+		coordinates.push(parsedCoords);
 	}
 
 	return coordinates.length ? (coordinates as [Coordinates, ...Coordinates[]]) : undefined;
 };
 
-const getGeoJSONGeometry = (coords: [Coordinates, ...Coordinates[]]): Geometry => {
+const createGeoJSONGeometry = (coords: [Coordinates, ...Coordinates[]]): Geometry => {
 	if (coords.length === 1) {
 		return { type: 'Point', coordinates: coords[0] };
 	}
@@ -64,6 +101,13 @@ const getGeoJSONGeometry = (coords: [Coordinates, ...Coordinates[]]): Geometry =
 	return { type: 'LineString', coordinates: coords };
 };
 
+export const parseGeoJSONGeometry = (coords: string): Geometry | undefined => {
+	const parsedCoords = parseGeoJSONCoordinates(coords);
+	if (parsedCoords) {
+		return createGeoJSONGeometry(parsedCoords);
+	}
+};
+
 const normalizeODKFeature = (odkFeature: SelectItem | string) => {
 	if (typeof odkFeature === 'string') {
 		return {
@@ -113,7 +157,7 @@ export const createFeatureCollectionAndProps = (
 			return;
 		}
 
-		const geoJSONCoords = getGeoJSONCoordinates(geometry);
+		const geoJSONCoords = parseGeoJSONCoordinates(geometry);
 		if (!geoJSONCoords) {
 			// eslint-disable-next-line no-console -- Skip silently to match Collect behaviour.
 			console.warn(`Missing geo points for option: ${normalizedFeature.value}`);
@@ -122,7 +166,7 @@ export const createFeatureCollectionAndProps = (
 
 		features.push({
 			type: 'Feature',
-			geometry: getGeoJSONGeometry(geoJSONCoords),
+			geometry: createGeoJSONGeometry(geoJSONCoords),
 			properties: reservedProps,
 		});
 	});
@@ -132,3 +176,14 @@ export const createFeatureCollectionAndProps = (
 		orderedExtraPropsMap,
 	};
 };
+
+export const getGeometryFromJSON = (json: string): Geometry | undefined => {
+	try {
+		const geojson = JSON.parse(json) as FeatureCollection<LineString | Point | Polygon>;
+		return geojson?.features?.[0]?.geometry as Geometry | undefined;
+	} catch {
+		// eslint-disable-next-line no-console -- Skip silently to match createFeatureCollectionAndProps
+		console.warn('Invalid GeoJSON', json);
+		return;
+	}
+};
diff --git a/packages/web-forms/src/components/common/map/getModeConfig.ts b/packages/web-forms/src/components/common/map/getModeConfig.ts
index 56a43e489..29cb6e5a1 100644
--- a/packages/web-forms/src/components/common/map/getModeConfig.ts
+++ b/packages/web-forms/src/components/common/map/getModeConfig.ts
@@ -1,3 +1,8 @@
+/**
+ * IMPORTANT: OpenLayers and MapBlock are not statically imported here to enable bundling them into a separate chunk.
+ * This prevents unnecessary bloat in the main application bundle, reducing initial load times and improving performance.
+ */
+
 export const MODES = {
 	SELECT: 'select', // Used in Select one from map question type
 	LOCATION: 'location', // Used in Geopoint with "maps" appearance
@@ -6,6 +11,14 @@ export const MODES = {
 } as const;
 export type Mode = (typeof MODES)[keyof typeof MODES];
 
+// Used when loading a single feature from the map.
+export const SINGLE_FEATURE_TYPES = {
+	POINT: 'point',
+	SHAPE: 'shape',
+	TRACE: 'trace',
+} as const;
+export type SingleFeatureType = (typeof SINGLE_FEATURE_TYPES)[keyof typeof SINGLE_FEATURE_TYPES];
+
 export interface ModeCapabilities {
 	canDeleteFeature: boolean;
 	canLoadMultiFeatures: boolean;
@@ -15,6 +28,8 @@ export interface ModeCapabilities {
 	canShowMapOverlay: boolean;
 	canShowMapOverlayOnError: boolean;
 	canUndoLastChange: boolean;
+	canUpdateFeatureCoordinates: boolean;
+	canUpdateVertexCoordinates: boolean;
 	canViewProperties: boolean;
 }
 
@@ -46,6 +61,8 @@ export const getModeConfig = (mode: Mode): ModeConfig => {
 			canShowMapOverlay: false,
 			canShowMapOverlayOnError: false,
 			canUndoLastChange: false,
+			canUpdateFeatureCoordinates: false,
+			canUpdateVertexCoordinates: false,
 			canViewProperties: false,
 		},
 	} as const;
@@ -106,6 +123,8 @@ export const getModeConfig = (mode: Mode): ModeConfig => {
 				canDeleteFeature: true,
 				canSelectFeatureOrVertex: true,
 				canUndoLastChange: true,
+				canUpdateFeatureCoordinates: true,
+				canUpdateVertexCoordinates: true,
 			},
 		};
 	}
diff --git a/packages/web-forms/src/components/common/map/map-helpers.ts b/packages/web-forms/src/components/common/map/map-helpers.ts
index 7e2927a61..26ea6b43d 100644
--- a/packages/web-forms/src/components/common/map/map-helpers.ts
+++ b/packages/web-forms/src/components/common/map/map-helpers.ts
@@ -1,8 +1,38 @@
-import { getFlatCoordinates } from '@/components/common/map/vertex-geometry.ts';
+import {
+	SINGLE_FEATURE_TYPES,
+	type SingleFeatureType,
+} from '@/components/common/map/getModeConfig.ts';
+import { getFlatCoordinates, isCoordsEqual } from '@/components/common/map/vertex-geometry.ts';
 import type { Coordinate } from 'ol/coordinate';
 import type Feature from 'ol/Feature';
 import type { LineString, Point, Polygon } from 'ol/geom';
-import { toLonLat } from 'ol/proj';
+import { fromLonLat, toLonLat } from 'ol/proj';
+import type {
+	LineString as LineStringGeoJSON,
+	Point as PointGeoJSON,
+	Polygon as PolygonGeoJSON,
+} from 'geojson';
+
+// Latitude is first for ODK and longitude is second.
+export const toODKCoordinateArray = (
+	longitude: number,
+	latitude: number,
+	altitude: number | null | undefined,
+	accuracy: number | null | undefined
+): number[] => {
+	const coords = [];
+	if (Number.isFinite(latitude) && Number.isFinite(longitude)) {
+		coords.push(latitude, longitude);
+
+		if (Number.isFinite(accuracy)) {
+			coords.push(Number.isFinite(altitude) ? altitude! : 0, accuracy!);
+		} else if (Number.isFinite(altitude)) {
+			coords.push(altitude!);
+		}
+	}
+
+	return coords;
+};
 
 export const formatODKValue = (feature: Feature): string => {
 	const geometry = feature.getGeometry();
@@ -11,14 +41,14 @@ export const formatODKValue = (feature: Feature): string => {
 	}
 
 	const formatCoords = (coords: Coordinate) => {
-		const [longitude, latitude, altitude, accuracy] = toLonLat(coords);
-		return [latitude, longitude, altitude, accuracy].filter((item) => item != null).join(' ');
+		const parsedCoords = toLonLat(coords) as [number, number, number?, number?];
+		return toODKCoordinateArray(...parsedCoords).join(' ');
 	};
 
 	const featureType = geometry.getType();
 	if (featureType === 'Point') {
 		const coordinates = (geometry as Point).getCoordinates();
-		return coordinates ? formatCoords(coordinates) : '';
+		return coordinates?.length ? formatCoords(coordinates) : '';
 	}
 
 	const coordinates: Coordinate[] = getFlatCoordinates(geometry as LineString | Polygon);
@@ -33,3 +63,51 @@ export const isWebGLAvailable = () => {
 		return false;
 	}
 };
+
+/**
+ * Validates and transforms GeoJSON coordinates to the map default projection (OL's fromLonLat)
+ * based on the specific geometry type (Point, Trace, or Shape).
+ */
+export const getValidCoordinates = (
+	geometry: LineStringGeoJSON | PointGeoJSON | PolygonGeoJSON | undefined,
+	singleFeatureType: SingleFeatureType | undefined
+) => {
+	if (!geometry?.coordinates?.length) {
+		return;
+	}
+
+	const coords = geometry.coordinates as Coordinate | Coordinate[] | Coordinate[][];
+	if (
+		geometry.type === 'Point' &&
+		singleFeatureType === SINGLE_FEATURE_TYPES.POINT &&
+		!Array.isArray(coords[0])
+	) {
+		return fromLonLat(coords as Coordinate);
+	}
+
+	const hasRing = Array.isArray(coords[0]) && Array.isArray(coords[0][0]);
+	let flatCoords = (hasRing ? coords[0] : coords) as Coordinate[];
+	if (!flatCoords?.length) {
+		return;
+	}
+
+	flatCoords = flatCoords.map((c) => fromLonLat(c));
+	const isClosed = isCoordsEqual(flatCoords[0], flatCoords[flatCoords.length - 1]);
+	if (
+		geometry.type === 'LineString' &&
+		singleFeatureType === SINGLE_FEATURE_TYPES.TRACE &&
+		!isClosed &&
+		flatCoords.length >= 2
+	) {
+		return flatCoords;
+	}
+
+	if (
+		geometry.type === 'Polygon' &&
+		singleFeatureType === SINGLE_FEATURE_TYPES.SHAPE &&
+		isClosed &&
+		flatCoords.length >= 3
+	) {
+		return [flatCoords];
+	}
+};
diff --git a/packages/web-forms/src/components/common/map/useMapBlock.ts b/packages/web-forms/src/components/common/map/useMapBlock.ts
index 03e9e9d59..d05c0b8ee 100644
--- a/packages/web-forms/src/components/common/map/useMapBlock.ts
+++ b/packages/web-forms/src/components/common/map/useMapBlock.ts
@@ -1,4 +1,11 @@
-import { getModeConfig, type Mode, MODES } from '@/components/common/map/getModeConfig.ts';
+import { toGeoJsonCoordinateArray } from '@/components/common/map/geojson-parsers.ts';
+import {
+	getModeConfig,
+	type Mode,
+	MODES,
+	SINGLE_FEATURE_TYPES,
+	type SingleFeatureType,
+} from '@/components/common/map/getModeConfig.ts';
 import { formatODKValue, isWebGLAvailable } from '@/components/common/map/map-helpers.ts';
 import {
 	getDrawStyles,
@@ -16,7 +23,6 @@ import {
 	type UseMapFeatures,
 } from '@/components/common/map/useMapFeatures.ts';
 import {
-	type DrawFeatureType,
 	useMapInteractions,
 	type UseMapInteractions,
 } from '@/components/common/map/useMapInteractions.ts';
@@ -30,13 +36,14 @@ import {
 import {
 	deleteVertexFromFeature,
 	getVertexByIndex,
+	updateVertexCoordinate,
 } from '@/components/common/map/vertex-geometry.ts';
 import type { FeatureCollection, Feature as GeoJsonFeature } from 'geojson';
 import { Map, View } from 'ol';
 import { Attribution, Zoom } from 'ol/control';
 import type { Coordinate } from 'ol/coordinate';
 import Feature from 'ol/Feature';
-import { LineString, Point, Polygon } from 'ol/geom';
+import { LineString, Polygon, SimpleGeometry } from 'ol/geom';
 import TileLayer from 'ol/layer/Tile';
 import VectorLayer from 'ol/layer/Vector';
 import WebGLVectorLayer from 'ol/layer/WebGLVector';
@@ -59,12 +66,12 @@ export const ODK_VALUE_PROPERTY = 'odk_value';
 
 interface MapBlockConfig {
 	mode: Mode;
-	drawFeatureType?: DrawFeatureType;
+	singleFeatureType?: SingleFeatureType;
 }
 
 interface MapBlockEvents {
 	onFeaturePlacement: () => void;
-	onVertexSelect: (vertex: Coordinate) => void;
+	onVertexSelect: (vertex: Coordinate | undefined) => void;
 }
 
 export function useMapBlock(config: MapBlockConfig, events: MapBlockEvents) {
@@ -132,7 +139,7 @@ export function useMapBlock(config: MapBlockConfig, events: MapBlockEvents) {
 		mapInteractions = useMapInteractions(
 			mapInstance,
 			currentMode.capabilities,
-			config.drawFeatureType
+			config.singleFeatureType
 		);
 		mapFeatures = useMapFeatures(
 			mapInstance,
@@ -164,7 +171,7 @@ export function useMapBlock(config: MapBlockConfig, events: MapBlockEvents) {
 			return;
 		}
 
-		const feature = mapFeatures?.createFeature(savedFeatureValue);
+		const feature = mapFeatures?.createFeatureFromGeoJSON(savedFeatureValue);
 		loadAndSaveSingleFeature(feature);
 	};
 
@@ -206,6 +213,9 @@ export function useMapBlock(config: MapBlockConfig, events: MapBlockEvents) {
 	const updateAndSaveFeature = (feature: Feature) => {
 		feature.set(ODK_VALUE_PROPERTY, formatODKValue(feature));
 		mapFeatures?.saveFeature(feature);
+		// Refresh selected vertex.
+		const vertexIndex = feature.get(SELECTED_VERTEX_INDEX_PROPERTY) as number | undefined;
+		events.onVertexSelect(getVertexByIndex(feature, vertexIndex));
 	};
 
 	const handlePointPlacement = (feature: Feature) => {
@@ -230,6 +240,7 @@ export function useMapBlock(config: MapBlockConfig, events: MapBlockEvents) {
 		const coordsLeft = deleteVertexFromFeature(feature, vertexIndex);
 		if (coordsLeft > 0) {
 			updateAndSaveFeature(feature);
+			unselectFeature();
 			return;
 		}
 
@@ -267,6 +278,7 @@ export function useMapBlock(config: MapBlockConfig, events: MapBlockEvents) {
 			if (previousFeatureState) {
 				featuresSource.addFeature(previousFeatureState);
 				updateAndSaveFeature(previousFeatureState);
+				unselectFeature();
 			}
 		}
 	};
@@ -282,6 +294,61 @@ export function useMapBlock(config: MapBlockConfig, events: MapBlockEvents) {
 		mapFeatures?.findAndSaveFeature(featuresSource, savedFeature, true);
 	};
 
+	const updateVertexCoords = (newCoords: Coordinate) => {
+		if (!newCoords.length || !currentMode.capabilities.canUpdateVertexCoordinates) {
+			return;
+		}
+
+		const feature = mapFeatures?.getSavedFeature() as Feature<LineString | Polygon>;
+		const vertexIndex = feature?.get(SELECTED_VERTEX_INDEX_PROPERTY) as number;
+		if (vertexIndex === undefined) {
+			return;
+		}
+
+		mapInteractions?.pushUndoState(feature);
+		updateVertexCoordinate(feature, vertexIndex, newCoords);
+		updateAndSaveFeature(feature);
+		mapViewControls?.fitToAllFeatures(featuresSource);
+	};
+
+	const updateFeatureCoordinates = (newCoords: Coordinate[] | Coordinate[][]) => {
+		if (!newCoords.length || !currentMode.capabilities.canUpdateFeatureCoordinates) {
+			return;
+		}
+
+		const existingFeature = featuresSource.getFeatures()?.[0];
+		if (existingFeature) {
+			modifyExistingFeature(existingFeature, newCoords);
+		} else {
+			createNewFeature(newCoords);
+		}
+
+		mapViewControls?.fitToAllFeatures(featuresSource);
+	};
+
+	const createNewFeature = (coords: Coordinate[] | Coordinate[][]) => {
+		const newFeature = mapFeatures?.createFeatureFromType(config.singleFeatureType, coords);
+		if (!newFeature) {
+			return;
+		}
+
+		mapInteractions?.pushUndoState(null);
+		featuresSource.addFeature(newFeature);
+		updateAndSaveFeature(newFeature);
+	};
+
+	const modifyExistingFeature = (feature: Feature, coords: Coordinate[] | Coordinate[][]) => {
+		const geometry = feature.getGeometry() as SimpleGeometry | undefined;
+		if (!geometry) {
+			return;
+		}
+
+		mapInteractions?.pushUndoState(feature);
+		geometry.setCoordinates(coords, COORDINATE_LAYOUT_XYZM);
+		updateAndSaveFeature(feature);
+		unselectFeature();
+	};
+
 	const loadAndSaveSingleFeature = (feature: Feature | undefined) => {
 		if (!mapInstance || currentMode.capabilities.canLoadMultiFeatures || !feature) {
 			return;
@@ -317,20 +384,21 @@ export function useMapBlock(config: MapBlockConfig, events: MapBlockEvents) {
 			return;
 		}
 
-		const coords = [location.longitude, location.latitude];
-		if (location.altitude != null) {
-			coords.push(location.altitude);
-		}
+		const coords = toGeoJsonCoordinateArray(
+			location.longitude,
+			location.latitude,
+			location.altitude,
+			location.accuracy
+		);
+		const feature = mapFeatures?.createFeatureFromType(
+			SINGLE_FEATURE_TYPES.POINT,
+			fromLonLat(coords)
+		);
 
-		if (location.accuracy != null) {
-			coords.push(location.accuracy);
+		if (feature) {
+			feature.set(ODK_VALUE_PROPERTY, formatODKValue(feature));
+			loadAndSaveSingleFeature(feature);
 		}
-
-		const feature = new Feature({
-			geometry: new Point(fromLonLat(coords), COORDINATE_LAYOUT_XYZM),
-		});
-		feature.set(ODK_VALUE_PROPERTY, formatODKValue(feature));
-		loadAndSaveSingleFeature(feature);
 	};
 
 	const discardSavedFeature = () => {
@@ -345,7 +413,10 @@ export function useMapBlock(config: MapBlockConfig, events: MapBlockEvents) {
 		}
 	};
 
-	const unselectFeature = () => mapFeatures?.selectFeature(undefined);
+	const unselectFeature = () => {
+		mapFeatures?.selectFeature(undefined);
+		events.onVertexSelect(undefined);
+	};
 
 	const clearSavedFeature = () => mapFeatures?.saveFeature(undefined);
 
@@ -402,6 +473,16 @@ export function useMapBlock(config: MapBlockConfig, events: MapBlockEvents) {
 		return longPress && (dragFeature || dragFeatureAndVertex);
 	};
 
+	const canOpenAdvancedPanel = () => {
+		const { singleFeatureType: type } = config;
+		if (type !== SINGLE_FEATURE_TYPES.SHAPE && type !== SINGLE_FEATURE_TYPES.TRACE) {
+			return false;
+		}
+
+		const { canUpdateFeatureCoordinates, canUpdateVertexCoordinates } = currentMode.capabilities;
+		return canUpdateFeatureCoordinates || canUpdateVertexCoordinates;
+	};
+
 	const watchCurrentLocation = () => {
 		currentState.value = STATES.CAPTURING;
 
@@ -445,6 +526,8 @@ export function useMapBlock(config: MapBlockConfig, events: MapBlockEvents) {
 		initMap,
 		teardownMap,
 		updateFeatureCollection,
+		updateVertexCoords,
+		updateFeatureCoordinates,
 		setupMapInteractions,
 
 		isMapEmpty: () => featuresSource.isEmpty(),
@@ -473,6 +556,7 @@ export function useMapBlock(config: MapBlockConfig, events: MapBlockEvents) {
 
 		canLongPressAndDrag,
 		canViewProperties: () => currentMode.capabilities.canViewProperties,
+		canOpenAdvancedPanel,
 		shouldShowMapOverlay,
 	};
 }
diff --git a/packages/web-forms/src/components/common/map/useMapFeatures.ts b/packages/web-forms/src/components/common/map/useMapFeatures.ts
index dbf150316..d6da7082a 100644
--- a/packages/web-forms/src/components/common/map/useMapFeatures.ts
+++ b/packages/web-forms/src/components/common/map/useMapFeatures.ts
@@ -1,17 +1,30 @@
-import type { ModeCapabilities } from '@/components/common/map/getModeConfig.ts';
+import {
+	type ModeCapabilities,
+	SINGLE_FEATURE_TYPES,
+	type SingleFeatureType,
+} from '@/components/common/map/getModeConfig.ts';
 import { ODK_VALUE_PROPERTY } from '@/components/common/map/useMapBlock.ts';
-import type { UseMapViewControls } from '@/components/common/map/useMapViewControls.ts';
+import {
+	COORDINATE_LAYOUT_XYZM,
+	type UseMapViewControls,
+} from '@/components/common/map/useMapViewControls.ts';
 import type { FeatureCollection, Feature as GeoJsonFeature } from 'geojson';
 import { Map } from 'ol';
+import type { Coordinate } from 'ol/coordinate';
 import { intersects } from 'ol/extent';
 import Feature from 'ol/Feature';
 import GeoJSON from 'ol/format/GeoJSON';
+import { LineString, Point, Polygon } from 'ol/geom';
 import type WebGLVectorLayer from 'ol/layer/WebGLVector';
 import type VectorSource from 'ol/source/Vector';
 import { shallowRef, watch } from 'vue';
 
 export interface UseMapFeatures {
-	createFeature: (geoJsonFeature: GeoJsonFeature) => Feature | undefined;
+	createFeatureFromGeoJSON: (geoJsonFeature: GeoJsonFeature) => Feature | undefined;
+	createFeatureFromType: (
+		type: SingleFeatureType | undefined,
+		coords: Coordinate | Coordinate[] | Coordinate[][]
+	) => Feature | undefined;
 	findAndSaveFeature: (
 		source: VectorSource,
 		value: GeoJsonFeature | undefined,
@@ -45,7 +58,7 @@ export function useMapFeatures(
 	const selectedFeature = shallowRef<Feature | undefined>();
 	const savedFeature = shallowRef<Feature | undefined>();
 
-	const createFeature = (geoJsonFeature: GeoJsonFeature): Feature | undefined => {
+	const createFeatureFromGeoJSON = (geoJsonFeature: GeoJsonFeature): Feature | undefined => {
 		const feature: Feature | Feature[] = new GeoJSON().readFeature(geoJsonFeature, {
 			dataProjection: DEFAULT_GEOJSON_PROJECTION,
 			featureProjection: mapInstance.getView().getProjection(),
@@ -58,6 +71,27 @@ export function useMapFeatures(
 		return feature;
 	};
 
+	const createFeatureFromType = (
+		type: SingleFeatureType | undefined,
+		coords: Coordinate | Coordinate[] | Coordinate[][]
+	): Feature | undefined => {
+		if (type === SINGLE_FEATURE_TYPES.SHAPE) {
+			return new Feature({
+				geometry: new Polygon(coords as Coordinate[][], COORDINATE_LAYOUT_XYZM),
+			});
+		}
+
+		if (type === SINGLE_FEATURE_TYPES.TRACE) {
+			return new Feature({
+				geometry: new LineString(coords as Coordinate[], COORDINATE_LAYOUT_XYZM),
+			});
+		}
+
+		if (type === SINGLE_FEATURE_TYPES.POINT) {
+			return new Feature({ geometry: new Point(coords as Coordinate, COORDINATE_LAYOUT_XYZM) });
+		}
+	};
+
 	const loadAndSaveSingleFeature = (source: VectorSource, feature: Feature) => {
 		source.clear(true);
 		source.addFeature(feature);
@@ -174,7 +208,8 @@ export function useMapFeatures(
 	);
 
 	return {
-		createFeature,
+		createFeatureFromGeoJSON,
+		createFeatureFromType,
 		findAndSaveFeature,
 		getSavedFeature,
 		getSavedFeatureValue,
diff --git a/packages/web-forms/src/components/common/map/useMapInteractions.ts b/packages/web-forms/src/components/common/map/useMapInteractions.ts
index 659d72aae..88ce820b0 100644
--- a/packages/web-forms/src/components/common/map/useMapInteractions.ts
+++ b/packages/web-forms/src/components/common/map/useMapInteractions.ts
@@ -1,4 +1,8 @@
-import type { ModeCapabilities } from '@/components/common/map/getModeConfig.ts';
+import {
+	type ModeCapabilities,
+	SINGLE_FEATURE_TYPES,
+	type SingleFeatureType,
+} from '@/components/common/map/getModeConfig.ts';
 import { getPhantomPointStyle } from '@/components/common/map/map-styles.ts';
 import {
 	IS_SELECTED_PROPERTY,
@@ -23,12 +27,6 @@ import type { Pixel } from 'ol/pixel';
 import type VectorSource from 'ol/source/Vector';
 import { shallowRef } from 'vue';
 
-export const DRAW_FEATURE_TYPES = {
-	SHAPE: 'shape',
-	TRACE: 'trace',
-} as const;
-export type DrawFeatureType = (typeof DRAW_FEATURE_TYPES)[keyof typeof DRAW_FEATURE_TYPES];
-
 export interface UseMapInteractions {
 	hasUndoHistory: () => boolean;
 	popUndoState: () => Feature | null | undefined;
@@ -52,7 +50,7 @@ const SELECT_HIT_TOLERANCE = 15;
 export function useMapInteractions(
 	mapInstance: Map,
 	capabilities: ModeCapabilities,
-	drawFeatureType: DrawFeatureType | undefined
+	singleFeatureType: SingleFeatureType | undefined
 ): UseMapInteractions {
 	const currentLocationObserver = shallowRef<IntersectionObserver | undefined>();
 	const pointerInteraction = shallowRef<PointerInteraction | undefined>();
@@ -170,11 +168,11 @@ export function useMapInteractions(
 		resolution: number,
 		feature: Feature | undefined
 	) => {
-		if (drawFeatureType === DRAW_FEATURE_TYPES.SHAPE) {
+		if (singleFeatureType === SINGLE_FEATURE_TYPES.SHAPE) {
 			return addShapeVertex(resolution, coordinate, feature, LONG_PRESS_HIT_TOLERANCE);
 		}
 
-		if (drawFeatureType === DRAW_FEATURE_TYPES.TRACE) {
+		if (singleFeatureType === SINGLE_FEATURE_TYPES.TRACE) {
 			return addTraceVertex(resolution, coordinate, feature, LONG_PRESS_HIT_TOLERANCE);
 		}
 
@@ -191,7 +189,7 @@ export function useMapInteractions(
 		pushUndoState(feature ?? null);
 		const updatedFeature = resolveFeatureForLongPress(coordinate, resolution, feature)!;
 
-		if (!drawFeatureType && !source.isEmpty()) {
+		if (singleFeatureType === SINGLE_FEATURE_TYPES.POINT && !source.isEmpty()) {
 			source.clear(true);
 		}
 
diff --git a/packages/web-forms/src/components/common/map/useMapViewControls.ts b/packages/web-forms/src/components/common/map/useMapViewControls.ts
index e2cd8a269..88f385590 100644
--- a/packages/web-forms/src/components/common/map/useMapViewControls.ts
+++ b/packages/web-forms/src/components/common/map/useMapViewControls.ts
@@ -1,7 +1,8 @@
+import { toGeoJsonCoordinateArray } from '@/components/common/map/geojson-parsers.ts';
 import { Map, type View } from 'ol';
 import type { Coordinate } from 'ol/coordinate';
 import { easeOut } from 'ol/easing';
-import { getCenter } from 'ol/extent';
+import { getCenter, isEmpty as isExtendEmpty } from 'ol/extent';
 import Feature from 'ol/Feature';
 import { Point } from 'ol/geom';
 import VectorLayer from 'ol/layer/Vector';
@@ -67,7 +68,7 @@ export function useMapViewControls(mapInstance: Map): UseMapViewControls {
 		}
 
 		const extent = source.getExtent();
-		if (!extent?.length) {
+		if (isExtendEmpty(extent)) {
 			return;
 		}
 
@@ -243,12 +244,13 @@ export function useMapViewControls(mapInstance: Map): UseMapViewControls {
 				return;
 			}
 
-			const parsedCoords = fromLonLat([
+			const coords = toGeoJsonCoordinateArray(
 				newLocation.longitude,
 				newLocation.latitude,
-				newLocation.altitude ?? 0,
-				newLocation.accuracy,
-			]);
+				newLocation.altitude,
+				newLocation.accuracy
+			);
+			const parsedCoords = fromLonLat(coords);
 			userCurrentLocationFeature.value = new Feature({
 				geometry: new Point(parsedCoords, COORDINATE_LAYOUT_XYZM),
 			});
diff --git a/packages/web-forms/src/components/common/map/vertex-geometry.ts b/packages/web-forms/src/components/common/map/vertex-geometry.ts
index 926915816..07a863b4e 100644
--- a/packages/web-forms/src/components/common/map/vertex-geometry.ts
+++ b/packages/web-forms/src/components/common/map/vertex-geometry.ts
@@ -1,3 +1,4 @@
+import { COORDINATE_LAYOUT_XYZM } from '@/components/common/map/useMapViewControls.ts';
 import type { Coordinate } from 'ol/coordinate';
 import Feature from 'ol/Feature';
 import { Point, LineString, Polygon } from 'ol/geom';
@@ -116,7 +117,7 @@ export const addTraceVertex = (
 		coords.push(newVertex);
 	}
 
-	geometry?.setCoordinates(coords);
+	geometry?.setCoordinates(coords, COORDINATE_LAYOUT_XYZM);
 	return feature;
 };
 
@@ -156,7 +157,7 @@ export const addShapeVertex = (
 		ring.push([...firstVertex]);
 	}
 
-	geometry?.setCoordinates([ring]);
+	geometry?.setCoordinates([ring], COORDINATE_LAYOUT_XYZM);
 	return feature;
 };
 
@@ -223,8 +224,23 @@ export const deleteVertexFromFeature = (
 			geometry instanceof LineString
 				? deleteVertexFromLine(coords, index)
 				: deleteVertexFromPolygon(coords, index);
-		geometry.setCoordinates(updatedCoords as Coordinate[] & Coordinate[][]);
+		geometry.setCoordinates(updatedCoords as Coordinate[] & Coordinate[][], COORDINATE_LAYOUT_XYZM);
 	}
 
 	return coords.length;
 };
+
+export const updateVertexCoordinate = (
+	feature: Feature<LineString | Polygon> | undefined,
+	index: number,
+	newCoordinates: Coordinate
+) => {
+	const geometry = feature?.getGeometry();
+	const coords = getFlatCoordinates(geometry);
+
+	if (geometry && index >= 0 && index < coords.length) {
+		coords[index] = newCoordinates;
+		const updatedCoords = geometry instanceof LineString ? coords : [coords];
+		geometry.setCoordinates(updatedCoords as Coordinate[] & Coordinate[][], COORDINATE_LAYOUT_XYZM);
+	}
+};
diff --git a/packages/web-forms/src/components/form-elements/input/InputControl.vue b/packages/web-forms/src/components/form-elements/input/InputControl.vue
index d40fad993..85d0b362c 100644
--- a/packages/web-forms/src/components/form-elements/input/InputControl.vue
+++ b/packages/web-forms/src/components/form-elements/input/InputControl.vue
@@ -1,4 +1,5 @@
 <script setup lang="ts">
+import { SINGLE_FEATURE_TYPES } from '@/components/common/map/getModeConfig.ts';
 import ValidationMessage from '@/components/common/ValidationMessage.vue';
 import ControlText from '@/components/form-elements/ControlText.vue';
 import InputGeopoint from '@/components/form-elements/input/geopoint/InputGeopoint.vue';
@@ -40,10 +41,10 @@ const isFormEditMode = inject(IS_FORM_EDIT_MODE);
 			<InputGeopoint v-else :question="node" />
 		</template>
 		<template v-else-if="node.valueType === 'geoshape'">
-			<InputGeoMultiPoint :question="node" draw-feature-type="shape" />
+			<InputGeoMultiPoint :question="node" :single-feature-type="SINGLE_FEATURE_TYPES.SHAPE" />
 		</template>
 		<template v-else-if="node.valueType === 'geotrace'">
-			<InputGeoMultiPoint :question="node" draw-feature-type="trace" />
+			<InputGeoMultiPoint :question="node" :single-feature-type="SINGLE_FEATURE_TYPES.TRACE" />
 		</template>
 		<template v-else-if="node.valueType === 'date'">
 			<InputDate :question="node" />
diff --git a/packages/web-forms/src/components/form-elements/input/InputGeoMultiPoint.vue b/packages/web-forms/src/components/form-elements/input/InputGeoMultiPoint.vue
index 006cf8618..d61f86575 100644
--- a/packages/web-forms/src/components/form-elements/input/InputGeoMultiPoint.vue
+++ b/packages/web-forms/src/components/form-elements/input/InputGeoMultiPoint.vue
@@ -1,11 +1,11 @@
 <script setup lang="ts">
 import AsyncMap from '@/components/common/map/AsyncMap.vue';
-import { MODES } from '@/components/common/map/getModeConfig.ts';
+import { MODES, type SingleFeatureType } from '@/components/common/map/getModeConfig.ts';
 import type { GeoshapeInputNode, GeotraceInputNode } from '@getodk/xforms-engine';
 
 interface InputGeoMultiPointProps {
 	readonly question: GeoshapeInputNode | GeotraceInputNode;
-	readonly drawFeatureType: 'shape' | 'trace';
+	readonly singleFeatureType: SingleFeatureType;
 }
 
 defineProps<InputGeoMultiPointProps>();
@@ -14,9 +14,9 @@ defineProps<InputGeoMultiPointProps>();
 <template>
 	<AsyncMap
 		:disabled="question.currentState.readonly"
-		:draw-feature-type="drawFeatureType"
 		:mode="MODES.DRAW"
 		:saved-feature-value="question.currentState.instanceValue"
+		:single-feature-type="singleFeatureType"
 		@save="(value) => question.setValue(value ?? '')"
 	/>
 </template>
diff --git a/packages/web-forms/src/components/form-elements/input/InputGeopointWithMap.vue b/packages/web-forms/src/components/form-elements/input/InputGeopointWithMap.vue
index 0a6990d6e..81b159fe7 100644
--- a/packages/web-forms/src/components/form-elements/input/InputGeopointWithMap.vue
+++ b/packages/web-forms/src/components/form-elements/input/InputGeopointWithMap.vue
@@ -1,6 +1,6 @@
 <script setup lang="ts">
 import AsyncMap from '@/components/common/map/AsyncMap.vue';
-import { type Mode, MODES } from '@/components/common/map/getModeConfig.ts';
+import { type Mode, MODES, SINGLE_FEATURE_TYPES } from '@/components/common/map/getModeConfig.ts';
 import { IS_FORM_EDIT_MODE } from '@/lib/constants/injection-keys.ts';
 import type { GeopointInputNode } from '@getodk/xforms-engine';
 import { computed, inject, type ShallowRef } from 'vue';
@@ -32,6 +32,7 @@ const mode = computed<Mode | null>(() => {
 		:disabled="question.currentState.readonly"
 		:mode="mode"
 		:saved-feature-value="question.currentState.instanceValue"
+		:single-feature-type="SINGLE_FEATURE_TYPES.POINT"
 		@save="(value) => question.setValue(value ?? '')"
 	/>
 </template>
diff --git a/packages/web-forms/tests/components/common/map/createFeatureCollectionAndProps.test.ts b/packages/web-forms/tests/components/common/map/createFeatureCollectionAndProps.test.ts
deleted file mode 100644
index 6d92b6cb7..000000000
--- a/packages/web-forms/tests/components/common/map/createFeatureCollectionAndProps.test.ts
+++ /dev/null
@@ -1,617 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { createFeatureCollectionAndProps } from '@/components/common/map/createFeatureCollectionAndProps';
-import type { SelectItem } from '@getodk/xforms-engine';
-
-describe('createFeatureCollectionAndProps', () => {
-	const createSelectItem = (
-		value: string,
-		label: string | null,
-		geometry: string,
-		properties: Array<[string, string]> = []
-	): SelectItem => {
-		return {
-			value,
-			// @ts-expect-error light typing for test purposes
-			label: { asString: label ?? '' },
-			properties: [['geometry', geometry], ...properties],
-		};
-	};
-
-	it('converts a single ODK point to a GeoJSON Point feature', () => {
-		const odkFeatures: SelectItem[] = [
-			createSelectItem('point1', 'Point 1', '40.7128 -74.0060 100 5', [
-				['marker-color', '#ff0000'],
-			]),
-		];
-
-		const { featureCollection, orderedExtraPropsMap } =
-			createFeatureCollectionAndProps(odkFeatures);
-
-		expect(featureCollection).toEqual({
-			type: 'FeatureCollection',
-			features: [
-				{
-					type: 'Feature',
-					geometry: {
-						type: 'Point',
-						coordinates: [-74.006, 40.7128],
-					},
-					properties: {
-						odk_label: 'Point 1',
-						odk_value: 'point1',
-						odk_geometry: '40.7128 -74.0060 100 5',
-						'odk_marker-color': '#ff0000',
-					},
-				},
-			],
-		});
-
-		expect(orderedExtraPropsMap).toEqual(new Map());
-	});
-
-	it('converts an ODK trace to a GeoJSON LineString feature', () => {
-		const odkFeatures: SelectItem[] = [
-			createSelectItem('trace1', 'Trace 1', '40.7128 -74.0060 100 5;40.7129 -74.0061 100 5', [
-				['stroke', '#0000ff'],
-			]),
-		];
-
-		const { featureCollection, orderedExtraPropsMap } =
-			createFeatureCollectionAndProps(odkFeatures);
-
-		expect(featureCollection).toEqual({
-			type: 'FeatureCollection',
-			features: [
-				{
-					type: 'Feature',
-					geometry: {
-						type: 'LineString',
-						coordinates: [
-							[-74.006, 40.7128],
-							[-74.0061, 40.7129],
-						],
-					},
-					properties: {
-						odk_label: 'Trace 1',
-						odk_value: 'trace1',
-						odk_geometry: '40.7128 -74.0060 100 5;40.7129 -74.0061 100 5',
-						odk_stroke: '#0000ff',
-					},
-				},
-			],
-		});
-
-		expect(orderedExtraPropsMap).toEqual(new Map());
-	});
-
-	it('converts an ODK shape to a GeoJSON Polygon feature', () => {
-		const odkFeatures: SelectItem[] = [
-			createSelectItem(
-				'shape1',
-				'Shape 1',
-				'40.7128 -74.0060 100 5;40.7129 -74.0061 100 5;40.7128 -74.0060 100 5',
-				[['fill', '#00ff00']]
-			),
-		];
-
-		const { featureCollection, orderedExtraPropsMap } =
-			createFeatureCollectionAndProps(odkFeatures);
-
-		expect(featureCollection).toEqual({
-			type: 'FeatureCollection',
-			features: [
-				{
-					type: 'Feature',
-					geometry: {
-						type: 'Polygon',
-						coordinates: [
-							[
-								[-74.006, 40.7128],
-								[-74.0061, 40.7129],
-								[-74.006, 40.7128],
-							],
-						],
-					},
-					properties: {
-						odk_label: 'Shape 1',
-						odk_value: 'shape1',
-						odk_geometry: '40.7128 -74.0060 100 5;40.7129 -74.0061 100 5;40.7128 -74.0060 100 5',
-						odk_fill: '#00ff00',
-					},
-				},
-			],
-		});
-
-		expect(orderedExtraPropsMap).toEqual(new Map());
-	});
-
-	it('skips features with invalid ODK geometry and logs warning', () => {
-		// eslint-disable-next-line @typescript-eslint/no-empty-function
-		vi.spyOn(console, 'warn').mockImplementation(() => {});
-		const odkFeatures: SelectItem[] = [
-			createSelectItem('invalid1', 'Invalid 1', 'invalid-geometry', []),
-			createSelectItem('point1', 'Point 1', '40.7128 -74.0060 100 5', []),
-		];
-
-		const { featureCollection, orderedExtraPropsMap } =
-			createFeatureCollectionAndProps(odkFeatures);
-
-		expect(featureCollection).toEqual({
-			type: 'FeatureCollection',
-			features: [
-				{
-					type: 'Feature',
-					geometry: {
-						type: 'Point',
-						coordinates: [-74.006, 40.7128],
-					},
-					properties: {
-						odk_label: 'Point 1',
-						odk_value: 'point1',
-						odk_geometry: '40.7128 -74.0060 100 5',
-					},
-				},
-			],
-		});
-
-		// eslint-disable-next-line no-console
-		expect(console.warn).toHaveBeenCalledWith(
-			expect.stringContaining('Invalid geo point coordinates: invalid-geometry')
-		);
-		expect(orderedExtraPropsMap).toEqual(new Map());
-	});
-
-	it('skips features with empty ODK geometry and logs warning', () => {
-		// eslint-disable-next-line @typescript-eslint/no-empty-function
-		vi.spyOn(console, 'warn').mockImplementation(() => {});
-		const odkFeatures: SelectItem[] = [
-			createSelectItem('empty1', 'Empty 1', '', [['marker-color', '#ff0000']]),
-			createSelectItem('point1', 'Point 1', '40.7128 -74.0060 100 5', []),
-		];
-
-		const { featureCollection, orderedExtraPropsMap } =
-			createFeatureCollectionAndProps(odkFeatures);
-
-		expect(featureCollection).toEqual({
-			type: 'FeatureCollection',
-			features: [
-				{
-					type: 'Feature',
-					geometry: {
-						type: 'Point',
-						coordinates: [-74.006, 40.7128],
-					},
-					properties: {
-						odk_label: 'Point 1',
-						odk_value: 'point1',
-						odk_geometry: '40.7128 -74.0060 100 5',
-					},
-				},
-			],
-		});
-
-		// eslint-disable-next-line no-console
-		expect(console.warn).toHaveBeenCalledWith(
-			expect.stringContaining('Missing or empty geometry for option: empty1')
-		);
-		expect(orderedExtraPropsMap).toEqual(new Map());
-	});
-
-	it('handles undefined odkFeatures input', () => {
-		const { featureCollection, orderedExtraPropsMap } = createFeatureCollectionAndProps(undefined);
-
-		expect(featureCollection).toEqual({
-			type: 'FeatureCollection',
-			features: [],
-		});
-		expect(orderedExtraPropsMap).toEqual(new Map());
-	});
-
-	it('handles empty odkFeatures array', () => {
-		const odkFeatures: SelectItem[] = [];
-
-		const { featureCollection, orderedExtraPropsMap } =
-			createFeatureCollectionAndProps(odkFeatures);
-
-		expect(featureCollection).toEqual({
-			type: 'FeatureCollection',
-			features: [],
-		});
-		expect(orderedExtraPropsMap).toEqual(new Map());
-	});
-
-	it('handles non-reserved properties in orderedExtraPropsMap', () => {
-		const odkFeatures: SelectItem[] = [
-			createSelectItem('point1', 'Point 1', '40.7128 -74.0060 100 5', [
-				['marker-color', '#ff0000'],
-				['custom-prop', 'value1'],
-				['another-prop', 'value2'],
-			]),
-		];
-
-		const { featureCollection, orderedExtraPropsMap } =
-			createFeatureCollectionAndProps(odkFeatures);
-
-		expect(featureCollection).toEqual({
-			type: 'FeatureCollection',
-			features: [
-				{
-					type: 'Feature',
-					geometry: {
-						type: 'Point',
-						coordinates: [-74.006, 40.7128],
-					},
-					properties: {
-						odk_label: 'Point 1',
-						odk_value: 'point1',
-						odk_geometry: '40.7128 -74.0060 100 5',
-						'odk_marker-color': '#ff0000',
-					},
-				},
-			],
-		});
-
-		expect(orderedExtraPropsMap).toEqual(
-			new Map([
-				[
-					'point1',
-					[
-						['custom-prop', 'value1'],
-						['another-prop', 'value2'],
-					],
-				],
-			])
-		);
-	});
-
-	it('removes reserved properties of Entities in orderedExtraPropsMap', () => {
-		const odkFeatures: SelectItem[] = [
-			createSelectItem('point1', 'Point 1', '40.7128 -74.0060 100 5', [
-				['__version', 'v34.29.7'],
-				['clinic-name', 'New Hope Clinic'],
-				['__trunkVersion', 'v1.1.1'],
-				['__clinic-id', '123456'],
-				['__branchId', 'id-abc'],
-				['another-prop', 'value2'],
-			]),
-		];
-
-		const { featureCollection, orderedExtraPropsMap } =
-			createFeatureCollectionAndProps(odkFeatures);
-
-		expect(featureCollection).toEqual({
-			type: 'FeatureCollection',
-			features: [
-				{
-					type: 'Feature',
-					geometry: {
-						type: 'Point',
-						coordinates: [-74.006, 40.7128],
-					},
-					properties: {
-						odk___branchId: 'id-abc',
-						odk___trunkVersion: 'v1.1.1',
-						odk___version: 'v34.29.7',
-						odk_geometry: '40.7128 -74.0060 100 5',
-						odk_label: 'Point 1',
-						odk_value: 'point1',
-					},
-				},
-			],
-		});
-
-		expect(orderedExtraPropsMap).toEqual(
-			new Map([
-				[
-					'point1',
-					[
-						['clinic-name', 'New Hope Clinic'],
-						['__clinic-id', '123456'],
-						['another-prop', 'value2'],
-					],
-				],
-			])
-		);
-	});
-
-	it('handles null label in ODK features', () => {
-		const odkFeatures: SelectItem[] = [
-			createSelectItem('point1', null, '40.7128 -74.0060 100 5', [['marker-color', '#ff0000']]),
-		];
-
-		const { featureCollection, orderedExtraPropsMap } =
-			createFeatureCollectionAndProps(odkFeatures);
-
-		expect(featureCollection).toEqual({
-			type: 'FeatureCollection',
-			features: [
-				{
-					type: 'Feature',
-					geometry: {
-						type: 'Point',
-						coordinates: [-74.006, 40.7128],
-					},
-					properties: {
-						odk_label: '',
-						odk_value: 'point1',
-						odk_geometry: '40.7128 -74.0060 100 5',
-						'odk_marker-color': '#ff0000',
-					},
-				},
-			],
-		});
-
-		expect(orderedExtraPropsMap).toEqual(new Map());
-	});
-
-	it('handles invalid ODK coordinates (out of range)', () => {
-		// eslint-disable-next-line @typescript-eslint/no-empty-function
-		vi.spyOn(console, 'warn').mockImplementation(() => {});
-		const odkFeatures: SelectItem[] = [
-			createSelectItem('invalid1', 'Invalid 1', '100 -200 100 5', []),
-			createSelectItem('point1', 'Point 1', '40.7128 -74.0060 100 5', []),
-		];
-
-		const { featureCollection, orderedExtraPropsMap } =
-			createFeatureCollectionAndProps(odkFeatures);
-
-		expect(featureCollection).toEqual({
-			type: 'FeatureCollection',
-			features: [
-				{
-					type: 'Feature',
-					geometry: {
-						type: 'Point',
-						coordinates: [-74.006, 40.7128],
-					},
-					properties: {
-						odk_label: 'Point 1',
-						odk_value: 'point1',
-						odk_geometry: '40.7128 -74.0060 100 5',
-					},
-				},
-			],
-		});
-
-		// eslint-disable-next-line no-console
-		expect(console.warn).toHaveBeenCalledWith(
-			expect.stringContaining('Invalid geo point coordinates: 100 -200 100 5')
-		);
-		expect(orderedExtraPropsMap).toEqual(new Map());
-	});
-
-	it('handles partial ODK point format (missing altitude/accuracy)', () => {
-		const odkFeatures: SelectItem[] = [
-			createSelectItem('point1', 'Point 1', '40.7128 -74.0060', [['marker-color', '#ff0000']]),
-		];
-
-		const { featureCollection, orderedExtraPropsMap } =
-			createFeatureCollectionAndProps(odkFeatures);
-
-		expect(featureCollection).toEqual({
-			type: 'FeatureCollection',
-			features: [
-				{
-					type: 'Feature',
-					geometry: {
-						type: 'Point',
-						coordinates: [-74.006, 40.7128],
-					},
-					properties: {
-						odk_label: 'Point 1',
-						odk_value: 'point1',
-						odk_geometry: '40.7128 -74.0060',
-						'odk_marker-color': '#ff0000',
-					},
-				},
-			],
-		});
-
-		expect(orderedExtraPropsMap).toEqual(new Map());
-	});
-
-	it('handles ODK point with extra whitespace', () => {
-		const odkFeatures: SelectItem[] = [
-			createSelectItem('point1', 'Point 1', '  40.7128   -74.0060  100  5  ', [
-				['marker-color', '#ff0000'],
-			]),
-		];
-
-		const { featureCollection, orderedExtraPropsMap } =
-			createFeatureCollectionAndProps(odkFeatures);
-
-		expect(featureCollection).toEqual({
-			type: 'FeatureCollection',
-			features: [
-				{
-					type: 'Feature',
-					geometry: {
-						type: 'Point',
-						coordinates: [-74.006, 40.7128],
-					},
-					properties: {
-						odk_label: 'Point 1',
-						odk_value: 'point1',
-						odk_geometry: '40.7128   -74.0060  100  5',
-						'odk_marker-color': '#ff0000',
-					},
-				},
-			],
-		});
-
-		expect(orderedExtraPropsMap).toEqual(new Map());
-	});
-
-	it('converts multiple ODK features (Point, LineString, Polygon, invalid) to a GeoJSON FeatureCollection', () => {
-		// eslint-disable-next-line @typescript-eslint/no-empty-function
-		vi.spyOn(console, 'warn').mockImplementation(() => {});
-		const odkFeatures: SelectItem[] = [
-			createSelectItem('point1', 'Point 1', '40.7128 -74.0060 100 5', [
-				['marker-color', '#ff0000'],
-				['custom-prop', 'value1'],
-			]),
-			createSelectItem('trace1', 'Trace 1', '40.7128 -74.0060 100 5;40.7129 -74.0061 100 5', [
-				['stroke', '#0000ff'],
-			]),
-			createSelectItem(
-				'shape1',
-				'Shape 1',
-				'40.7128 -74.0060 100 5;40.7129 -74.0061 100 5;40.7128 -74.0060 100 5',
-				[
-					['fill', '#00ff00'],
-					['another-prop', 'value2'],
-				]
-			),
-			createSelectItem('invalid1', 'Invalid 1', 'invalid-geometry', []),
-		];
-
-		const { featureCollection, orderedExtraPropsMap } =
-			createFeatureCollectionAndProps(odkFeatures);
-
-		expect(featureCollection).toEqual({
-			type: 'FeatureCollection',
-			features: [
-				{
-					type: 'Feature',
-					geometry: {
-						type: 'Point',
-						coordinates: [-74.006, 40.7128],
-					},
-					properties: {
-						odk_label: 'Point 1',
-						odk_value: 'point1',
-						odk_geometry: '40.7128 -74.0060 100 5',
-						'odk_marker-color': '#ff0000',
-					},
-				},
-				{
-					type: 'Feature',
-					geometry: {
-						type: 'LineString',
-						coordinates: [
-							[-74.006, 40.7128],
-							[-74.0061, 40.7129],
-						],
-					},
-					properties: {
-						odk_label: 'Trace 1',
-						odk_value: 'trace1',
-						odk_geometry: '40.7128 -74.0060 100 5;40.7129 -74.0061 100 5',
-						odk_stroke: '#0000ff',
-					},
-				},
-				{
-					type: 'Feature',
-					geometry: {
-						type: 'Polygon',
-						coordinates: [
-							[
-								[-74.006, 40.7128],
-								[-74.0061, 40.7129],
-								[-74.006, 40.7128],
-							],
-						],
-					},
-					properties: {
-						odk_label: 'Shape 1',
-						odk_value: 'shape1',
-						odk_geometry: '40.7128 -74.0060 100 5;40.7129 -74.0061 100 5;40.7128 -74.0060 100 5',
-						odk_fill: '#00ff00',
-					},
-				},
-			],
-		});
-
-		expect(orderedExtraPropsMap).toEqual(
-			new Map([
-				['point1', [['custom-prop', 'value1']]],
-				['shape1', [['another-prop', 'value2']]],
-			])
-		);
-
-		// eslint-disable-next-line no-console
-		expect(console.warn).toHaveBeenCalledWith(
-			expect.stringContaining('Invalid geo point coordinates: invalid-geometry')
-		);
-	});
-
-	it('converts string ODK features to a GeoJSON FeatureCollection', () => {
-		// eslint-disable-next-line @typescript-eslint/no-empty-function
-		vi.spyOn(console, 'warn').mockImplementation(() => {});
-		const odkFeatures: string[] = [
-			'40.7128 -74.0060 100 5',
-			'40.7128 -74.0060 100 5;40.7129 -74.0061 100 5',
-			'40.7128 -74.0060 100 5;40.7129 -74.0061 100 5;40.7128 -74.0060 100 5',
-			'', // invalid feature
-			'40.7128', // invalid feature
-			'abc', // invalid feature
-		];
-
-		const { featureCollection, orderedExtraPropsMap } =
-			createFeatureCollectionAndProps(odkFeatures);
-
-		expect(featureCollection).toEqual({
-			type: 'FeatureCollection',
-			features: [
-				{
-					type: 'Feature',
-					geometry: {
-						type: 'Point',
-						coordinates: [-74.006, 40.7128],
-					},
-					properties: {
-						odk_label: '40.7128 -74.0060 100 5',
-						odk_value: '40.7128 -74.0060 100 5',
-						odk_geometry: '40.7128 -74.0060 100 5',
-					},
-				},
-				{
-					type: 'Feature',
-					geometry: {
-						type: 'LineString',
-						coordinates: [
-							[-74.006, 40.7128],
-							[-74.0061, 40.7129],
-						],
-					},
-					properties: {
-						odk_label: '40.7128 -74.0060 100 5;40.7129 -74.0061 100 5',
-						odk_value: '40.7128 -74.0060 100 5;40.7129 -74.0061 100 5',
-						odk_geometry: '40.7128 -74.0060 100 5;40.7129 -74.0061 100 5',
-					},
-				},
-				{
-					type: 'Feature',
-					geometry: {
-						type: 'Polygon',
-						coordinates: [
-							[
-								[-74.006, 40.7128],
-								[-74.0061, 40.7129],
-								[-74.006, 40.7128],
-							],
-						],
-					},
-					properties: {
-						odk_label: '40.7128 -74.0060 100 5;40.7129 -74.0061 100 5;40.7128 -74.0060 100 5',
-						odk_value: '40.7128 -74.0060 100 5;40.7129 -74.0061 100 5;40.7128 -74.0060 100 5',
-						odk_geometry: '40.7128 -74.0060 100 5;40.7129 -74.0061 100 5;40.7128 -74.0060 100 5',
-					},
-				},
-			],
-		});
-
-		expect(orderedExtraPropsMap).toEqual(new Map());
-
-		// eslint-disable-next-line no-console
-		expect(console.warn).toHaveBeenCalledWith('Missing or empty geometry for option: ');
-		// eslint-disable-next-line no-console
-		expect(console.warn).toHaveBeenCalledWith('Invalid geo point coordinates: 40.7128');
-		// eslint-disable-next-line no-console
-		expect(console.warn).toHaveBeenCalledWith('Missing geo points for option: 40.7128');
-		// eslint-disable-next-line no-console
-		expect(console.warn).toHaveBeenCalledWith('Invalid geo point coordinates: abc');
-		// eslint-disable-next-line no-console
-		expect(console.warn).toHaveBeenCalledWith('Missing geo points for option: abc');
-	});
-});
diff --git a/packages/web-forms/tests/components/common/map/geojson-parsers.test.ts b/packages/web-forms/tests/components/common/map/geojson-parsers.test.ts
new file mode 100644
index 000000000..a0d941b42
--- /dev/null
+++ b/packages/web-forms/tests/components/common/map/geojson-parsers.test.ts
@@ -0,0 +1,739 @@
+import { describe, it, expect, vi } from 'vitest';
+import {
+	createFeatureCollectionAndProps,
+	parseGeoJSONGeometry,
+	getGeometryFromJSON,
+	toGeoJsonCoordinateArray,
+} from '@/components/common/map/geojson-parsers.ts';
+import type { SelectItem } from '@getodk/xforms-engine';
+
+describe('GeoJson Parsers', () => {
+	describe('createFeatureCollectionAndProps', () => {
+		const createSelectItem = (
+			value: string,
+			label: string | null,
+			geometry: string,
+			properties: Array<[string, string]> = []
+		): SelectItem => {
+			return {
+				value,
+				// @ts-expect-error light typing for test purposes
+				label: { asString: label ?? '' },
+				properties: [['geometry', geometry], ...properties],
+			};
+		};
+
+		it('converts a single ODK point to a GeoJSON Point feature', () => {
+			const odkFeatures: SelectItem[] = [
+				createSelectItem('point1', 'Point 1', '40.7128 -74.0060 100 5', [
+					['marker-color', '#ff0000'],
+				]),
+			];
+
+			const { featureCollection, orderedExtraPropsMap } =
+				createFeatureCollectionAndProps(odkFeatures);
+
+			expect(featureCollection).toEqual({
+				type: 'FeatureCollection',
+				features: [
+					{
+						type: 'Feature',
+						geometry: {
+							type: 'Point',
+							coordinates: [-74.006, 40.7128, 100, 5],
+						},
+						properties: {
+							odk_label: 'Point 1',
+							odk_value: 'point1',
+							odk_geometry: '40.7128 -74.0060 100 5',
+							'odk_marker-color': '#ff0000',
+						},
+					},
+				],
+			});
+
+			expect(orderedExtraPropsMap).toEqual(new Map());
+		});
+
+		it('converts an ODK trace to a GeoJSON LineString feature', () => {
+			const odkFeatures: SelectItem[] = [
+				createSelectItem('trace1', 'Trace 1', '40.7128 -74.0060;40.7129 -74.0061 0 25', [
+					['stroke', '#0000ff'],
+				]),
+			];
+
+			const { featureCollection, orderedExtraPropsMap } =
+				createFeatureCollectionAndProps(odkFeatures);
+
+			expect(featureCollection).toEqual({
+				type: 'FeatureCollection',
+				features: [
+					{
+						type: 'Feature',
+						geometry: {
+							type: 'LineString',
+							coordinates: [
+								[-74.006, 40.7128],
+								[-74.0061, 40.7129, 0, 25],
+							],
+						},
+						properties: {
+							odk_label: 'Trace 1',
+							odk_value: 'trace1',
+							odk_geometry: '40.7128 -74.0060;40.7129 -74.0061 0 25',
+							odk_stroke: '#0000ff',
+						},
+					},
+				],
+			});
+
+			expect(orderedExtraPropsMap).toEqual(new Map());
+		});
+
+		it('converts an ODK shape to a GeoJSON Polygon feature', () => {
+			const odkFeatures: SelectItem[] = [
+				createSelectItem(
+					'shape1',
+					'Shape 1',
+					'40.7128 -74.0060 1300;40.7129 -74.0061 1400 6;40.7128 -74.0060',
+					[['fill', '#00ff00']]
+				),
+			];
+
+			const { featureCollection, orderedExtraPropsMap } =
+				createFeatureCollectionAndProps(odkFeatures);
+
+			expect(featureCollection).toEqual({
+				type: 'FeatureCollection',
+				features: [
+					{
+						type: 'Feature',
+						geometry: {
+							type: 'Polygon',
+							coordinates: [
+								[
+									[-74.006, 40.7128, 1300],
+									[-74.0061, 40.7129, 1400, 6],
+									[-74.006, 40.7128],
+								],
+							],
+						},
+						properties: {
+							odk_label: 'Shape 1',
+							odk_value: 'shape1',
+							odk_geometry: '40.7128 -74.0060 1300;40.7129 -74.0061 1400 6;40.7128 -74.0060',
+							odk_fill: '#00ff00',
+						},
+					},
+				],
+			});
+
+			expect(orderedExtraPropsMap).toEqual(new Map());
+		});
+
+		it('skips features with invalid ODK geometry and logs warning', () => {
+			// eslint-disable-next-line @typescript-eslint/no-empty-function
+			vi.spyOn(console, 'warn').mockImplementation(() => {});
+			const odkFeatures: SelectItem[] = [
+				createSelectItem('invalid1', 'Invalid 1', 'invalid-geometry', []),
+				createSelectItem('point1', 'Point 1', '40.7128 -74.0060 100 5', []),
+			];
+
+			const { featureCollection, orderedExtraPropsMap } =
+				createFeatureCollectionAndProps(odkFeatures);
+
+			expect(featureCollection).toEqual({
+				type: 'FeatureCollection',
+				features: [
+					{
+						type: 'Feature',
+						geometry: {
+							type: 'Point',
+							coordinates: [-74.006, 40.7128, 100, 5],
+						},
+						properties: {
+							odk_label: 'Point 1',
+							odk_value: 'point1',
+							odk_geometry: '40.7128 -74.0060 100 5',
+						},
+					},
+				],
+			});
+
+			// eslint-disable-next-line no-console
+			expect(console.warn).toHaveBeenCalledWith(
+				expect.stringContaining('Invalid geo point coordinates: invalid-geometry')
+			);
+			expect(orderedExtraPropsMap).toEqual(new Map());
+		});
+
+		it('skips features with empty ODK geometry and logs warning', () => {
+			// eslint-disable-next-line @typescript-eslint/no-empty-function
+			vi.spyOn(console, 'warn').mockImplementation(() => {});
+			const odkFeatures: SelectItem[] = [
+				createSelectItem('empty1', 'Empty 1', '', [['marker-color', '#ff0000']]),
+				createSelectItem('point1', 'Point 1', '40.7128 -74.0060 100 5', []),
+			];
+
+			const { featureCollection, orderedExtraPropsMap } =
+				createFeatureCollectionAndProps(odkFeatures);
+
+			expect(featureCollection).toEqual({
+				type: 'FeatureCollection',
+				features: [
+					{
+						type: 'Feature',
+						geometry: {
+							type: 'Point',
+							coordinates: [-74.006, 40.7128, 100, 5],
+						},
+						properties: {
+							odk_label: 'Point 1',
+							odk_value: 'point1',
+							odk_geometry: '40.7128 -74.0060 100 5',
+						},
+					},
+				],
+			});
+
+			// eslint-disable-next-line no-console
+			expect(console.warn).toHaveBeenCalledWith(
+				expect.stringContaining('Missing or empty geometry for option: empty1')
+			);
+			expect(orderedExtraPropsMap).toEqual(new Map());
+		});
+
+		it('handles undefined odkFeatures input', () => {
+			const { featureCollection, orderedExtraPropsMap } =
+				createFeatureCollectionAndProps(undefined);
+
+			expect(featureCollection).toEqual({
+				type: 'FeatureCollection',
+				features: [],
+			});
+			expect(orderedExtraPropsMap).toEqual(new Map());
+		});
+
+		it('handles empty odkFeatures array', () => {
+			const odkFeatures: SelectItem[] = [];
+
+			const { featureCollection, orderedExtraPropsMap } =
+				createFeatureCollectionAndProps(odkFeatures);
+
+			expect(featureCollection).toEqual({
+				type: 'FeatureCollection',
+				features: [],
+			});
+			expect(orderedExtraPropsMap).toEqual(new Map());
+		});
+
+		it('handles non-reserved properties in orderedExtraPropsMap', () => {
+			const odkFeatures: SelectItem[] = [
+				createSelectItem('point1', 'Point 1', '40.7128 -74.0060 100 5', [
+					['marker-color', '#ff0000'],
+					['custom-prop', 'value1'],
+					['another-prop', 'value2'],
+				]),
+			];
+
+			const { featureCollection, orderedExtraPropsMap } =
+				createFeatureCollectionAndProps(odkFeatures);
+
+			expect(featureCollection).toEqual({
+				type: 'FeatureCollection',
+				features: [
+					{
+						type: 'Feature',
+						geometry: {
+							type: 'Point',
+							coordinates: [-74.006, 40.7128, 100, 5],
+						},
+						properties: {
+							odk_label: 'Point 1',
+							odk_value: 'point1',
+							odk_geometry: '40.7128 -74.0060 100 5',
+							'odk_marker-color': '#ff0000',
+						},
+					},
+				],
+			});
+
+			expect(orderedExtraPropsMap).toEqual(
+				new Map([
+					[
+						'point1',
+						[
+							['custom-prop', 'value1'],
+							['another-prop', 'value2'],
+						],
+					],
+				])
+			);
+		});
+
+		it('removes reserved properties of Entities in orderedExtraPropsMap', () => {
+			const odkFeatures: SelectItem[] = [
+				createSelectItem('point1', 'Point 1', '40.7128 -74.0060 100 5', [
+					['__version', 'v34.29.7'],
+					['clinic-name', 'New Hope Clinic'],
+					['__trunkVersion', 'v1.1.1'],
+					['__clinic-id', '123456'],
+					['__branchId', 'id-abc'],
+					['another-prop', 'value2'],
+				]),
+			];
+
+			const { featureCollection, orderedExtraPropsMap } =
+				createFeatureCollectionAndProps(odkFeatures);
+
+			expect(featureCollection).toEqual({
+				type: 'FeatureCollection',
+				features: [
+					{
+						type: 'Feature',
+						geometry: {
+							type: 'Point',
+							coordinates: [-74.006, 40.7128, 100, 5],
+						},
+						properties: {
+							odk___branchId: 'id-abc',
+							odk___trunkVersion: 'v1.1.1',
+							odk___version: 'v34.29.7',
+							odk_geometry: '40.7128 -74.0060 100 5',
+							odk_label: 'Point 1',
+							odk_value: 'point1',
+						},
+					},
+				],
+			});
+
+			expect(orderedExtraPropsMap).toEqual(
+				new Map([
+					[
+						'point1',
+						[
+							['clinic-name', 'New Hope Clinic'],
+							['__clinic-id', '123456'],
+							['another-prop', 'value2'],
+						],
+					],
+				])
+			);
+		});
+
+		it('handles null label in ODK features', () => {
+			const odkFeatures: SelectItem[] = [
+				createSelectItem('point1', null, '40.7128 -74.0060 100 5', [['marker-color', '#ff0000']]),
+			];
+
+			const { featureCollection, orderedExtraPropsMap } =
+				createFeatureCollectionAndProps(odkFeatures);
+
+			expect(featureCollection).toEqual({
+				type: 'FeatureCollection',
+				features: [
+					{
+						type: 'Feature',
+						geometry: {
+							type: 'Point',
+							coordinates: [-74.006, 40.7128, 100, 5],
+						},
+						properties: {
+							odk_label: '',
+							odk_value: 'point1',
+							odk_geometry: '40.7128 -74.0060 100 5',
+							'odk_marker-color': '#ff0000',
+						},
+					},
+				],
+			});
+
+			expect(orderedExtraPropsMap).toEqual(new Map());
+		});
+
+		it('handles invalid ODK coordinates (out of range)', () => {
+			// eslint-disable-next-line @typescript-eslint/no-empty-function
+			vi.spyOn(console, 'warn').mockImplementation(() => {});
+			const odkFeatures: SelectItem[] = [
+				createSelectItem('invalid1', 'Invalid 1', '100 -200 100 5', []),
+				createSelectItem('point1', 'Point 1', '40.7128 -74.0060 100 5', []),
+			];
+
+			const { featureCollection, orderedExtraPropsMap } =
+				createFeatureCollectionAndProps(odkFeatures);
+
+			expect(featureCollection).toEqual({
+				type: 'FeatureCollection',
+				features: [
+					{
+						type: 'Feature',
+						geometry: {
+							type: 'Point',
+							coordinates: [-74.006, 40.7128, 100, 5],
+						},
+						properties: {
+							odk_label: 'Point 1',
+							odk_value: 'point1',
+							odk_geometry: '40.7128 -74.0060 100 5',
+						},
+					},
+				],
+			});
+
+			// eslint-disable-next-line no-console
+			expect(console.warn).toHaveBeenCalledWith(
+				expect.stringContaining('Invalid geo point coordinates: 100 -200 100 5')
+			);
+			expect(orderedExtraPropsMap).toEqual(new Map());
+		});
+
+		it('handles partial ODK point format (missing altitude/accuracy)', () => {
+			const odkFeatures: SelectItem[] = [
+				createSelectItem('point1', 'Point 1', '40.7128 -74.0060', [['marker-color', '#ff0000']]),
+			];
+
+			const { featureCollection, orderedExtraPropsMap } =
+				createFeatureCollectionAndProps(odkFeatures);
+
+			expect(featureCollection).toEqual({
+				type: 'FeatureCollection',
+				features: [
+					{
+						type: 'Feature',
+						geometry: {
+							type: 'Point',
+							coordinates: [-74.006, 40.7128],
+						},
+						properties: {
+							odk_label: 'Point 1',
+							odk_value: 'point1',
+							odk_geometry: '40.7128 -74.0060',
+							'odk_marker-color': '#ff0000',
+						},
+					},
+				],
+			});
+
+			expect(orderedExtraPropsMap).toEqual(new Map());
+		});
+
+		it('handles ODK point with extra whitespace', () => {
+			const odkFeatures: SelectItem[] = [
+				createSelectItem('point1', 'Point 1', '  40.7128   -74.0060  100  5  ', [
+					['marker-color', '#ff0000'],
+				]),
+			];
+
+			const { featureCollection, orderedExtraPropsMap } =
+				createFeatureCollectionAndProps(odkFeatures);
+
+			expect(featureCollection).toEqual({
+				type: 'FeatureCollection',
+				features: [
+					{
+						type: 'Feature',
+						geometry: {
+							type: 'Point',
+							coordinates: [-74.006, 40.7128, 100, 5],
+						},
+						properties: {
+							odk_label: 'Point 1',
+							odk_value: 'point1',
+							odk_geometry: '40.7128   -74.0060  100  5',
+							'odk_marker-color': '#ff0000',
+						},
+					},
+				],
+			});
+
+			expect(orderedExtraPropsMap).toEqual(new Map());
+		});
+
+		it('converts multiple ODK features (Point, LineString, Polygon, invalid) to a GeoJSON FeatureCollection', () => {
+			// eslint-disable-next-line @typescript-eslint/no-empty-function
+			vi.spyOn(console, 'warn').mockImplementation(() => {});
+			const odkFeatures: SelectItem[] = [
+				createSelectItem('point1', 'Point 1', '40.7128 -74.0060 100 5', [
+					['marker-color', '#ff0000'],
+					['custom-prop', 'value1'],
+				]),
+				createSelectItem('trace1', 'Trace 1', '40.7128 -74.0060;40.7129 -74.0061', [
+					['stroke', '#0000ff'],
+				]),
+				createSelectItem(
+					'shape1',
+					'Shape 1',
+					'40.7128 -74.0060 100 5;40.7129 -74.0061 0 0;40.7128 -74.0060 0 12',
+					[
+						['fill', '#00ff00'],
+						['another-prop', 'value2'],
+					]
+				),
+				createSelectItem('invalid1', 'Invalid 1', 'invalid-geometry', []),
+			];
+
+			const { featureCollection, orderedExtraPropsMap } =
+				createFeatureCollectionAndProps(odkFeatures);
+
+			expect(featureCollection).toEqual({
+				type: 'FeatureCollection',
+				features: [
+					{
+						type: 'Feature',
+						geometry: {
+							type: 'Point',
+							coordinates: [-74.006, 40.7128, 100, 5],
+						},
+						properties: {
+							odk_label: 'Point 1',
+							odk_value: 'point1',
+							odk_geometry: '40.7128 -74.0060 100 5',
+							'odk_marker-color': '#ff0000',
+						},
+					},
+					{
+						type: 'Feature',
+						geometry: {
+							type: 'LineString',
+							coordinates: [
+								[-74.006, 40.7128],
+								[-74.0061, 40.7129],
+							],
+						},
+						properties: {
+							odk_label: 'Trace 1',
+							odk_value: 'trace1',
+							odk_geometry: '40.7128 -74.0060;40.7129 -74.0061',
+							odk_stroke: '#0000ff',
+						},
+					},
+					{
+						type: 'Feature',
+						geometry: {
+							type: 'Polygon',
+							coordinates: [
+								[
+									[-74.006, 40.7128, 100, 5],
+									[-74.0061, 40.7129, 0, 0],
+									[-74.006, 40.7128, 0, 12],
+								],
+							],
+						},
+						properties: {
+							odk_label: 'Shape 1',
+							odk_value: 'shape1',
+							odk_geometry: '40.7128 -74.0060 100 5;40.7129 -74.0061 0 0;40.7128 -74.0060 0 12',
+							odk_fill: '#00ff00',
+						},
+					},
+				],
+			});
+
+			expect(orderedExtraPropsMap).toEqual(
+				new Map([
+					['point1', [['custom-prop', 'value1']]],
+					['shape1', [['another-prop', 'value2']]],
+				])
+			);
+
+			// eslint-disable-next-line no-console
+			expect(console.warn).toHaveBeenCalledWith(
+				expect.stringContaining('Invalid geo point coordinates: invalid-geometry')
+			);
+		});
+
+		it('converts string ODK features to a GeoJSON FeatureCollection', () => {
+			// eslint-disable-next-line @typescript-eslint/no-empty-function
+			vi.spyOn(console, 'warn').mockImplementation(() => {});
+			const odkFeatures: string[] = [
+				'40.7128 -74.0060 100 5',
+				'40.7128 -74.0060 100 5;40.7129 -74.0061 100 5',
+				'40.7128 -74.0060 100 5;40.7129 -74.0061 100 5;40.7128 -74.0060 100 5',
+				'', // invalid feature
+				'40.7128', // invalid feature
+				'abc', // invalid feature
+			];
+
+			const { featureCollection, orderedExtraPropsMap } =
+				createFeatureCollectionAndProps(odkFeatures);
+
+			expect(featureCollection).toEqual({
+				type: 'FeatureCollection',
+				features: [
+					{
+						type: 'Feature',
+						geometry: {
+							type: 'Point',
+							coordinates: [-74.006, 40.7128, 100, 5],
+						},
+						properties: {
+							odk_label: '40.7128 -74.0060 100 5',
+							odk_value: '40.7128 -74.0060 100 5',
+							odk_geometry: '40.7128 -74.0060 100 5',
+						},
+					},
+					{
+						type: 'Feature',
+						geometry: {
+							type: 'LineString',
+							coordinates: [
+								[-74.006, 40.7128, 100, 5],
+								[-74.0061, 40.7129, 100, 5],
+							],
+						},
+						properties: {
+							odk_label: '40.7128 -74.0060 100 5;40.7129 -74.0061 100 5',
+							odk_value: '40.7128 -74.0060 100 5;40.7129 -74.0061 100 5',
+							odk_geometry: '40.7128 -74.0060 100 5;40.7129 -74.0061 100 5',
+						},
+					},
+					{
+						type: 'Feature',
+						geometry: {
+							type: 'Polygon',
+							coordinates: [
+								[
+									[-74.006, 40.7128, 100, 5],
+									[-74.0061, 40.7129, 100, 5],
+									[-74.006, 40.7128, 100, 5],
+								],
+							],
+						},
+						properties: {
+							odk_label: '40.7128 -74.0060 100 5;40.7129 -74.0061 100 5;40.7128 -74.0060 100 5',
+							odk_value: '40.7128 -74.0060 100 5;40.7129 -74.0061 100 5;40.7128 -74.0060 100 5',
+							odk_geometry: '40.7128 -74.0060 100 5;40.7129 -74.0061 100 5;40.7128 -74.0060 100 5',
+						},
+					},
+				],
+			});
+
+			expect(orderedExtraPropsMap).toEqual(new Map());
+
+			// eslint-disable-next-line no-console
+			expect(console.warn).toHaveBeenCalledWith('Missing or empty geometry for option: ');
+			// eslint-disable-next-line no-console
+			expect(console.warn).toHaveBeenCalledWith('Invalid geo point coordinates: 40.7128');
+			// eslint-disable-next-line no-console
+			expect(console.warn).toHaveBeenCalledWith('Missing geo points for option: 40.7128');
+			// eslint-disable-next-line no-console
+			expect(console.warn).toHaveBeenCalledWith('Invalid geo point coordinates: abc');
+			// eslint-disable-next-line no-console
+			expect(console.warn).toHaveBeenCalledWith('Missing geo points for option: abc');
+		});
+	});
+
+	describe('parseGeoJSONGeometry', () => {
+		it('returns undefined for empty string', () => {
+			vi.spyOn(console, 'warn').mockImplementation(() => false);
+			expect(parseGeoJSONGeometry('')).toBeUndefined();
+			// eslint-disable-next-line no-console
+			expect(console.warn).toHaveBeenCalledWith(
+				expect.stringContaining('Invalid geo point coordinates: ')
+			);
+		});
+
+		it('returns undefined for invalid coordinates', () => {
+			vi.spyOn(console, 'warn').mockImplementation(() => false);
+			expect(parseGeoJSONGeometry('abc def')).toBeUndefined();
+			// eslint-disable-next-line no-console
+			expect(console.warn).toHaveBeenCalledWith(
+				expect.stringContaining('Invalid geo point coordinates: ')
+			);
+		});
+
+		it('returns Point for single valid coordinate', () => {
+			expect(parseGeoJSONGeometry('40.7128 -74.0060 100 5')).toEqual({
+				type: 'Point',
+				coordinates: [-74.006, 40.7128, 100, 5],
+			});
+		});
+
+		it('returns LineString for multiple valid coordinates', () => {
+			expect(parseGeoJSONGeometry('40.7128 -74.0060;40.7129 -74.0061')).toEqual({
+				type: 'LineString',
+				coordinates: [
+					[-74.006, 40.7128],
+					[-74.0061, 40.7129],
+				],
+			});
+		});
+
+		it('returns Polygon for multiple closed coordinates', () => {
+			expect(parseGeoJSONGeometry('40.7128 -74.0060;40.7129 -74.0061;40.7128 -74.0060')).toEqual({
+				type: 'Polygon',
+				coordinates: [
+					[
+						[-74.006, 40.7128],
+						[-74.0061, 40.7129],
+						[-74.006, 40.7128],
+					],
+				],
+			});
+		});
+	});
+
+	describe('toGeoJsonCoordinateArray', () => {
+		it('returns longitude and latitude only when altitude and accuracy were not provided', () => {
+			const result = toGeoJsonCoordinateArray(2.2945, 48.8584, null, null);
+			expect(result).toEqual([2.2945, 48.8584]);
+		});
+
+		it('returns coordinates with altitude', () => {
+			const result = toGeoJsonCoordinateArray(2.2945, 48.8584, 170, null);
+			expect(result).toEqual([2.2945, 48.8584, 170]);
+		});
+
+		it('returns coordinates with accuracy and defaults altitude to 0', () => {
+			const result = toGeoJsonCoordinateArray(2.2945, 48.8584, null, 5);
+			expect(result).toEqual([2.2945, 48.8584, 0, 5]);
+		});
+
+		it('returns coordinates with altitude and accuracy', () => {
+			const result = toGeoJsonCoordinateArray(2.2945, 48.8584, 170, 5);
+			expect(result).toEqual([2.2945, 48.8584, 170, 5]);
+		});
+	});
+
+	describe('getGeometryFromJSON', () => {
+		it('returns the geometry of the first feature for a valid GeoJSON', () => {
+			const text = JSON.stringify({
+				type: 'FeatureCollection',
+				features: [
+					{
+						type: 'Feature',
+						geometry: {
+							type: 'Point',
+							coordinates: [-74.006, 40.7128, 100, 5],
+						},
+					},
+				],
+			});
+			expect(getGeometryFromJSON(text)).toEqual({
+				type: 'Point',
+				coordinates: [-74.006, 40.7128, 100, 5],
+			});
+		});
+
+		it('returns undefined for an invalid GeoJSON', () => {
+			const empty = JSON.stringify({
+				type: 'FeatureCollection',
+				features: [],
+			});
+			expect(getGeometryFromJSON(empty)).toBeUndefined();
+
+			const noGeometry = JSON.stringify({
+				type: 'FeatureCollection',
+				features: [
+					{
+						type: 'Feature',
+					},
+				],
+			});
+			expect(getGeometryFromJSON(noGeometry)).toBeUndefined();
+
+			const invalidJson = 'abc';
+			expect(getGeometryFromJSON(invalidJson)).toBeUndefined();
+		});
+	});
+});
diff --git a/packages/web-forms/tests/components/common/map/getModeConfig.test.ts b/packages/web-forms/tests/components/common/map/getModeConfig.test.ts
index 9c5c05ace..98c65bf24 100644
--- a/packages/web-forms/tests/components/common/map/getModeConfig.test.ts
+++ b/packages/web-forms/tests/components/common/map/getModeConfig.test.ts
@@ -22,6 +22,8 @@ describe('getModeConfig', () => {
 				canShowMapOverlayOnError: false,
 				canUndoLastChange: false,
 				canDeleteFeature: false,
+				canUpdateFeatureCoordinates: false,
+				canUpdateVertexCoordinates: false,
 			},
 		});
 	});
@@ -46,6 +48,8 @@ describe('getModeConfig', () => {
 				canShowMapOverlayOnError: true,
 				canUndoLastChange: false,
 				canDeleteFeature: false,
+				canUpdateFeatureCoordinates: false,
+				canUpdateVertexCoordinates: false,
 			},
 		});
 	});
@@ -70,6 +74,8 @@ describe('getModeConfig', () => {
 				canShowMapOverlayOnError: false,
 				canUndoLastChange: false,
 				canDeleteFeature: false,
+				canUpdateFeatureCoordinates: false,
+				canUpdateVertexCoordinates: false,
 			},
 		});
 	});
@@ -94,6 +100,8 @@ describe('getModeConfig', () => {
 				canShowMapOverlayOnError: false,
 				canUndoLastChange: true,
 				canDeleteFeature: true,
+				canUpdateFeatureCoordinates: true,
+				canUpdateVertexCoordinates: true,
 			},
 		});
 	});
@@ -119,6 +127,8 @@ describe('getModeConfig', () => {
 				canShowMapOverlayOnError: false,
 				canUndoLastChange: false,
 				canDeleteFeature: false,
+				canUpdateFeatureCoordinates: false,
+				canUpdateVertexCoordinates: false,
 			},
 		});
 	});
diff --git a/packages/web-forms/tests/components/common/map/map-helpers.test.ts b/packages/web-forms/tests/components/common/map/map-helpers.test.ts
index cfebda3a9..c66420904 100644
--- a/packages/web-forms/tests/components/common/map/map-helpers.test.ts
+++ b/packages/web-forms/tests/components/common/map/map-helpers.test.ts
@@ -1,4 +1,9 @@
-import { formatODKValue } from '@/components/common/map/map-helpers.ts';
+import { SINGLE_FEATURE_TYPES } from '@/components/common/map/getModeConfig.ts';
+import {
+	formatODKValue,
+	getValidCoordinates,
+	toODKCoordinateArray,
+} from '@/components/common/map/map-helpers.ts';
 import { COORDINATE_LAYOUT_XYZM } from '@/components/common/map/useMapViewControls.ts';
 import Feature from 'ol/Feature';
 import { LineString, Point, Polygon } from 'ol/geom';
@@ -64,4 +69,128 @@ describe('Map Helpers', () => {
 			expect(formatODKValue(feature)).toBe('0 0; 0 1; 1 1; 0 0');
 		});
 	});
+
+	describe('toODKCoordinateArray', () => {
+		it('returns longitude and latitude only when altitude and accuracy were not provided', () => {
+			const result = toODKCoordinateArray(2.2945, 48.8584, null, null);
+			expect(result).toEqual([48.8584, 2.2945]);
+		});
+
+		it('returns coordinates with altitude', () => {
+			const result = toODKCoordinateArray(2.2945, 48.8584, 170, null);
+			expect(result).toEqual([48.8584, 2.2945, 170]);
+		});
+
+		it('returns coordinates with accuracy and defaults altitude to 0', () => {
+			const result = toODKCoordinateArray(2.2945, 48.8584, null, 5);
+			expect(result).toEqual([48.8584, 2.2945, 0, 5]);
+		});
+
+		it('returns coordinates with altitude and accuracy', () => {
+			const result = toODKCoordinateArray(2.2945, 48.8584, 170, 5);
+			expect(result).toEqual([48.8584, 2.2945, 170, 5]);
+		});
+	});
+
+	describe('getValidCoordinates', () => {
+		it('returns undefined for invalid geometry', () => {
+			expect(getValidCoordinates(undefined, undefined)).toBeUndefined();
+			// @ts-expect-error - skip type check for testing purposes
+			expect(getValidCoordinates({ type: 'Point' }, undefined)).toBeUndefined();
+			expect(getValidCoordinates({ type: 'Point', coordinates: [] }, undefined)).toBeUndefined();
+		});
+
+		it('returns projected coordinates for a valid Point', () => {
+			const geometry = { type: 'Point', coordinates: [2.2945, 48.8584] };
+			// @ts-expect-error - skip type check for testing purposes
+			expect(getValidCoordinates(geometry, SINGLE_FEATURE_TYPES.POINT)).toEqual(
+				fromLonLat([2.2945, 48.8584])
+			);
+		});
+
+		it('returns projected coordinates for a valid LineString', () => {
+			const geometry = {
+				type: 'LineString',
+				coordinates: [
+					[2.2945, 48.8584],
+					[2.3522, 48.8606],
+				],
+			};
+			const expected = [fromLonLat([2.2945, 48.8584]), fromLonLat([2.3522, 48.8606])];
+			// @ts-expect-error - skip type check for testing purposes
+			expect(getValidCoordinates(geometry, SINGLE_FEATURE_TYPES.TRACE)).toEqual(expected);
+		});
+
+		it('returns undefined for LineString with length < 2', () => {
+			const geometry = { type: 'LineString', coordinates: [[2.2945, 48.8584]] };
+			// @ts-expect-error - skip type check for testing purposes
+			expect(getValidCoordinates(geometry, SINGLE_FEATURE_TYPES.TRACE)).toBeUndefined();
+		});
+
+		it('returns undefined for closed LineString', () => {
+			const geometry = {
+				type: 'LineString',
+				coordinates: [
+					[2.2945, 48.8584],
+					[2.3522, 48.8606],
+					[2.2945, 48.8584],
+				],
+			};
+			// @ts-expect-error - skip type check for testing purposes
+			expect(getValidCoordinates(geometry, SINGLE_FEATURE_TYPES.TRACE)).toBeUndefined();
+		});
+
+		it('returns projected coordinates for a valid Polygon', () => {
+			const geometry = {
+				type: 'Polygon',
+				coordinates: [
+					[
+						[2.2945, 48.8584],
+						[2.3522, 48.8606],
+						[2.3324, 48.8572],
+						[2.2945, 48.8584],
+					],
+				],
+			};
+			const expected = [
+				[
+					fromLonLat([2.2945, 48.8584]),
+					fromLonLat([2.3522, 48.8606]),
+					fromLonLat([2.3324, 48.8572]),
+					fromLonLat([2.2945, 48.8584]),
+				],
+			];
+			// @ts-expect-error - skip type check for testing purposes
+			expect(getValidCoordinates(geometry, SINGLE_FEATURE_TYPES.SHAPE)).toEqual(expected);
+		});
+
+		it('returns undefined for Polygon with length < 3', () => {
+			const geometry = {
+				type: 'Polygon',
+				coordinates: [
+					[
+						[2.2945, 48.8584],
+						[2.2945, 48.8584],
+					],
+				],
+			};
+			// @ts-expect-error - skip type check for testing purposes
+			expect(getValidCoordinates(geometry, SINGLE_FEATURE_TYPES.SHAPE)).toBeUndefined();
+		});
+
+		it('returns undefined for open Polygon', () => {
+			const geometry = {
+				type: 'Polygon',
+				coordinates: [
+					[
+						[2.2945, 48.8584],
+						[2.3522, 48.8606],
+						[2.3324, 48.8572],
+					],
+				],
+			};
+			// @ts-expect-error - skip type check for testing purposes
+			expect(getValidCoordinates(geometry, SINGLE_FEATURE_TYPES.SHAPE)).toBeUndefined();
+		});
+	});
 });