Remove sync parseGpx, use parseGpxAsync everywhere

parseGpx (sync) needs browser DOMParser which doesn't exist on the
server — it silently failed in every server-side caller. Removed the
export and migrated all callers to parseGpxAsync. Updated tests.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

apps/journal/app/lib/activities.server.ts

@@ -23,8 +23,7 @@ export async function createActivity(ownerId: string, input: ActivityInput) {
   if (input.gpx) {
     try {
       const gpxData = await parseGpxAsync(input.gpx);
-      const profile = gpxData.elevation.profile;
+      distance = gpxData.distance || null;
-      distance = profile.length > 0 ? Math.round(profile[profile.length - 1]!.distance) : null;
       elevationGain = gpxData.elevation.gain;
       elevationLoss = gpxData.elevation.loss;
 

apps/journal/app/lib/routes.server.ts

@@ -145,11 +145,7 @@ async function computeRouteStats(gpxString: string) {
   try {
     const gpxData = await parseGpxAsync(gpxString);
     return {
-      distance: Math.round(
+      distance: gpxData.distance,
-        gpxData.elevation.profile.length > 0
-          ? gpxData.elevation.profile[gpxData.elevation.profile.length - 1]!.distance
-          : 0,
-      ),
       elevationGain: gpxData.elevation.gain,
       elevationLoss: gpxData.elevation.loss,
     };

apps/planner/app/routes/new.tsx

@@ -1,7 +1,7 @@
 import { redirect, data } from "react-router";
 import type { Route } from "./+types/new";
 import { createSession, initializeSessionWithWaypoints } from "~/lib/sessions";
-import { parseGpx } from "@trails-cool/gpx";
+import { parseGpxAsync } from "@trails-cool/gpx";
 import { checkRateLimit } from "~/lib/rate-limit";
 
 export async function loader({ request }: Route.LoaderArgs) {
@@ -35,7 +35,7 @@ export async function loader({ request }: Route.LoaderArgs) {
   if (gpxEncoded) {
     try {
       const gpx = decodeURIComponent(gpxEncoded);
-      const gpxData = parseGpx(gpx);
+      const gpxData = await parseGpxAsync(gpx);
       initializeSessionWithWaypoints(session.id, gpxData.waypoints);
     } catch {
       // Continue with empty session if GPX is invalid

packages/gpx/src/generate.test.ts

@@ -1,6 +1,6 @@
 import { describe, it, expect } from "vitest";
 import { generateGpx } from "./generate.ts";
-import { parseGpx } from "./parse.ts";
+import { parseGpxAsync } from "./parse.ts";
 
 describe("generateGpx", () => {
   it("generates valid GPX with name", () => {
@@ -36,13 +36,13 @@ describe("generateGpx", () => {
     expect(gpx).toContain("Route <A> & B");
   });
 
-  it("produces round-trippable GPX", () => {
+  it("produces round-trippable GPX", async () => {
     const original = generateGpx({
       name: "Round Trip",
       waypoints: [{ lat: 52.52, lon: 13.405, name: "Start" }],
       tracks: [[{ lat: 52.52, lon: 13.405, ele: 34 }, { lat: 48.137, lon: 11.576, ele: 519 }]],
     });
-    const parsed = parseGpx(original);
+    const parsed = await parseGpxAsync(original);
     expect(parsed.name).toBe("Round Trip");
     expect(parsed.waypoints).toHaveLength(1);
     expect(parsed.waypoints[0]!.name).toBe("Start");

packages/gpx/src/index.ts

@@ -1,3 +1,3 @@
-export { parseGpx, parseGpxAsync } from "./parse.ts";
+export { parseGpxAsync } from "./parse.ts";
 export { generateGpx } from "./generate.ts";
 export type { GpxData, TrackPoint, ElevationProfile } from "./types.ts";

packages/gpx/src/parse.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect } from "vitest";
-import { parseGpx } from "./parse.ts";
+import { parseGpxAsync } from "./parse.ts";
 
 const sampleGpx = `<?xml version="1.0" encoding="UTF-8"?>
 <gpx version="1.1" creator="test" xmlns="http://www.topografix.com/GPX/1/1">
@@ -15,42 +15,50 @@ const sampleGpx = `<?xml version="1.0" encoding="UTF-8"?>
   </trk>
 </gpx>`;
 
-describe("parseGpx", () => {
+describe("parseGpxAsync", () => {
-  it("parses route name", () => {
+  it("parses route name", async () => {
-    const result = parseGpx(sampleGpx);
+    const result = await parseGpxAsync(sampleGpx);
     expect(result.name).toBe("Test Route");
   });
 
-  it("parses waypoints with lat, lon, and name", () => {
+  it("parses waypoints with lat, lon, and name", async () => {
-    const result = parseGpx(sampleGpx);
+    const result = await parseGpxAsync(sampleGpx);
     expect(result.waypoints).toHaveLength(2);
     expect(result.waypoints[0]).toEqual({ lat: 52.52, lon: 13.405, name: "Berlin" });
     expect(result.waypoints[1]).toEqual({ lat: 48.137, lon: 11.576, name: "Munich" });
   });
 
-  it("parses track points with elevation", () => {
+  it("parses track points with elevation", async () => {
-    const result = parseGpx(sampleGpx);
+    const result = await parseGpxAsync(sampleGpx);
     expect(result.tracks).toHaveLength(1);
     expect(result.tracks[0]).toHaveLength(3);
     expect(result.tracks[0]![0]).toEqual({ lat: 52.52, lon: 13.405, ele: 34, time: undefined });
   });
 
-  it("computes elevation gain and loss", () => {
+  it("computes elevation gain and loss", async () => {
-    const result = parseGpx(sampleGpx);
+    const result = await parseGpxAsync(sampleGpx);
     expect(result.elevation.gain).toBeGreaterThan(0);
     expect(result.elevation.loss).toBe(0); // monotonically increasing elevation
     expect(result.elevation.gain).toBe(485); // 113-34 + 519-113
   });
 
-  it("builds elevation profile", () => {
+  it("builds elevation profile", async () => {
-    const result = parseGpx(sampleGpx);
+    const result = await parseGpxAsync(sampleGpx);
     expect(result.elevation.profile).toHaveLength(3);
     expect(result.elevation.profile[0]!.distance).toBe(0);
     expect(result.elevation.profile[0]!.elevation).toBe(34);
     expect(result.elevation.profile[2]!.distance).toBeGreaterThan(0);
   });
 
-  it("throws on invalid XML", () => {
+  it("computes total distance independently of elevation", async () => {
-    expect(() => parseGpx("not xml at all <<<<")).toThrow("Invalid GPX XML");
+    const result = await parseGpxAsync(sampleGpx);
+    expect(result.distance).toBeGreaterThan(0);
+    // Berlin to Munich is ~500km, our 3-point track should be in that range
+    expect(result.distance).toBeGreaterThan(400_000);
+    expect(result.distance).toBeLessThan(600_000);
+  });
+
+  it("throws on invalid XML", async () => {
+    await expect(parseGpxAsync("not xml at all <<<<")).rejects.toThrow();
   });
 });

packages/gpx/src/parse.ts

@@ -15,7 +15,7 @@ async function getDOMParser(): Promise<typeof DOMParser> {
   return _LinkedDOMParser;
 }
 
-export function parseGpx(xml: string): GpxData {
+function parseGpx(xml: string): GpxData {
   // Synchronous path for browser
   if (typeof DOMParser !== "undefined") {
     return parseGpxWithParser(new DOMParser(), xml);
@@ -46,9 +46,9 @@ function parseGpxWithParser(parser: DOMParser, xml: string): GpxData {
   const name = doc.querySelector("metadata > name")?.textContent ?? undefined;
   const waypoints = parseWaypoints(doc);
   const tracks = parseTracks(doc);
-  const elevation = computeElevation(tracks);
+  const { totalDistance, ...elevation } = computeElevation(tracks);
 
-  return { name, waypoints, tracks, elevation };
+  return { name, waypoints, tracks, distance: totalDistance, elevation };
 }
 
 function parseWaypoints(doc: Document): Waypoint[] {
@@ -85,7 +85,7 @@ function parseTracks(doc: Document): TrackPoint[][] {
   return tracks;
 }
 
-function computeElevation(tracks: TrackPoint[][]): GpxData["elevation"] {
+function computeElevation(tracks: TrackPoint[][]): GpxData["elevation"] & { totalDistance: number } {
   let gain = 0;
   let loss = 0;
   const profile: ElevationProfile[] = [];
@@ -112,7 +112,7 @@ function computeElevation(tracks: TrackPoint[][]): GpxData["elevation"] {
     }
   }
 
-  return { gain: Math.round(gain), loss: Math.round(loss), profile };
+  return { totalDistance: Math.round(totalDistance), gain: Math.round(gain), loss: Math.round(loss), profile };
 }
 
 /** Haversine distance between two points in meters */

packages/gpx/src/types.ts

@@ -18,6 +18,8 @@ export interface GpxData {
   name?: string;
   waypoints: Waypoint[];
   tracks: TrackPoint[][];
+  /** Total distance in meters (haversine, works with or without elevation data) */
+  distance: number;
   elevation: {
     gain: number;
     loss: number;