Merge branch 'main' into e2e-fixtures

.github/dependabot.yml

@@ -20,10 +20,22 @@ updates:
         update-types: ["version-update:semver-major"]
       - dependency-name: "@types/node"
         update-types: ["version-update:semver-major"]
-      # react-native is pinned by the Expo SDK — upgrade it via an Expo
+      # These packages are version-pinned by the Expo SDK (see
-      # SDK bump, not on its own. Community react-native-* libraries are
+      # expo/bundledNativeModules.json) — upgrade them via an Expo SDK
-      # intentionally NOT ignored here; they can be bumped independently.
+      # bump / `npx expo install --fix`, never on their own. Dependabot
+      # bumping them past the SDK's expected version broke the native
+      # build (expo-modules-core macro mismatch, June 2026) because CI
+      # never compiles native code. `react` stays unignored: the web
+      # apps own its version via the workspace catalog, and apps/mobile
+      # excludes it from expo version checks.
       - dependency-name: "react-native"
+      - dependency-name: "react-native-gesture-handler"
+      - dependency-name: "react-native-reanimated"
+      - dependency-name: "react-native-safe-area-context"
+      - dependency-name: "react-native-screens"
+      - dependency-name: "react-native-worklets"
+      - dependency-name: "@sentry/react-native"
+      - dependency-name: "jest-expo"
 
   - package-ecosystem: "github-actions"
     directory: "/"

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

@@ -4,8 +4,8 @@ import { unionAll } from "drizzle-orm/pg-core";
 import { getDb } from "./db.ts";
 import { activities, routes, syncImports, users, follows, remoteActors } from "@trails-cool/db/schema/journal";
 import type { Visibility } from "@trails-cool/db/schema/journal";
-import { validateGpx, writeGeom } from "./gpx-save.server.ts";
+import { processGpx, writeGeom } from "./gpx-save.server.ts";
-import type { GpxData } from "./gpx-save.server.ts";
+import type { ProcessedGpx } from "./gpx-save.server.ts";
 import { enqueueOptional } from "./boss.server.ts";
 import type { OwnedRef } from "./ownership.server.ts";
 import {
@@ -70,7 +70,7 @@ export async function createActivity(ownerId: string, input: ActivityInput) {
   const db = getDb();
   const id = randomUUID();
 
-  let parsed: GpxData | null = null;
+  let processed: ProcessedGpx | null = null;
   let distance: number | null = input.distance ?? null;
   let elevationGain: number | null = null;
   let elevationLoss: number | null = null;
@@ -78,13 +78,12 @@ export async function createActivity(ownerId: string, input: ActivityInput) {
   const duration: number | null = input.duration ?? null;
 
   if (input.gpx) {
-    parsed = await validateGpx(input.gpx);
+    processed = await processGpx(input.gpx);
-    distance = parsed.distance || distance;
+    // GPX-derived distance wins unless it is zero; caller input is the fallback
-    elevationGain = parsed.elevation.gain;
+    distance = processed.stats.distance || distance;
-    elevationLoss = parsed.elevation.loss;
+    elevationGain = processed.stats.elevationGain;
-    if (!startedAt && parsed.tracks[0]?.[0]?.time) {
+    elevationLoss = processed.stats.elevationLoss;
-      startedAt = new Date(parsed.tracks[0][0].time);
+    startedAt = startedAt ?? processed.stats.startTime;
-    }
   }
 
   await db.transaction(async (tx) => {
@@ -104,9 +103,8 @@ export async function createActivity(ownerId: string, input: ActivityInput) {
       ...(input.synthetic ? { synthetic: true } : {}),
     });
 
-    if (input.gpx && parsed) {
+    if (input.gpx && processed) {
-      const coords = parsed.tracks.flat().map((p) => [p.lon, p.lat] as [number, number]);
+      await writeGeom(tx, id, "activities", processed.coords);
-      await writeGeom(tx, id, "activities", coords);
     }
   });
 
@@ -332,8 +330,7 @@ export async function createRouteFromActivity(ownedActivity: OwnedRef): Promise<
     .where(and(eq(activities.id, activityId), eq(activities.ownerId, ownerId)));
   if (!activity?.gpx) return null;
 
-  const parsed = await validateGpx(activity.gpx);
+  const { coords } = await processGpx(activity.gpx);
-  const coords = parsed.tracks.flat().map((p) => [p.lon, p.lat] as [number, number]);
   const routeId = randomUUID();
 
   await db.transaction(async (tx) => {

apps/journal/app/lib/demo-bot.server.ts

@@ -6,7 +6,7 @@ import { getDb } from "./db.ts";
 import { activities, routes, users } from "@trails-cool/db/schema/journal";
 import { createRoute } from "./routes.server.ts";
 import { createActivity } from "./activities.server.ts";
-import { validateGpx } from "./gpx-save.server.ts";
+import { processGpx } from "./gpx-save.server.ts";
 import { TERMS_VERSION } from "./legal.ts";
 import { logger } from "./logger.server.ts";
 import {
@@ -649,10 +649,8 @@ export async function generateOneWalk(
   const name = templateName(now, locale, persona);
   const description = templateDescription(now, locale, persona);
 
-  const parsed = await validateGpx(result.gpx);
+  const { stats } = await processGpx(result.gpx);
-  const distance = parsed.distance;
+  const { distance, elevationGain, elevationLoss } = stats;
-  const elevationGain = parsed.elevation.gain;
-  const elevationLoss = parsed.elevation.loss;
 
   if (!distance || distance < 500) return null;
 

apps/journal/app/lib/gpx-save.server.test.ts

@@ -1,5 +1,6 @@
 import { describe, it, expect } from "vitest";
-import { validateGpx, GpxValidationError } from "./gpx-save.server.ts";
+import { generateGpx } from "@trails-cool/gpx";
+import { processGpx, validateGpx, GpxValidationError } from "./gpx-save.server.ts";
 
 const VALID_GPX = `<?xml version="1.0" encoding="UTF-8"?>
 <gpx version="1.1" xmlns="http://www.topografix.com/GPX/1/1">
@@ -84,3 +85,68 @@ describe("validateGpx", () => {
     expect(err.name).toBe("GpxValidationError");
   });
 });
+
+const TIMED_GPX = `<?xml version="1.0" encoding="UTF-8"?>
+<gpx version="1.1" xmlns="http://www.topografix.com/GPX/1/1">
+  <metadata><desc>An alpine loop</desc></metadata>
+  <trk>
+    <trkseg>
+      <trkpt lat="47.0" lon="8.0"><ele>500</ele><time>2026-06-01T08:00:00Z</time></trkpt>
+      <trkpt lat="47.1" lon="8.1"><ele>520</ele><time>2026-06-01T09:00:00Z</time></trkpt>
+    </trkseg>
+  </trk>
+</gpx>`;
+
+describe("processGpx", () => {
+  it("extracts coords in [lon, lat] PostGIS axis order", async () => {
+    const { coords } = await processGpx(VALID_GPX);
+    expect(coords).toEqual([
+      [8.0, 47.0],
+      [8.1, 47.1],
+      [8.2, 47.2],
+    ]);
+  });
+
+  it("derives distance, elevation, description, and start time", async () => {
+    const { stats } = await processGpx(TIMED_GPX);
+    expect(stats.distance).toBeGreaterThan(0);
+    expect(stats.elevationGain).not.toBeNull();
+    expect(stats.elevationLoss).not.toBeNull();
+    expect(stats.description).toBe("An alpine loop");
+    expect(stats.startTime).toEqual(new Date("2026-06-01T08:00:00Z"));
+  });
+
+  it("returns null startTime and empty dayBreaks when absent", async () => {
+    const { stats } = await processGpx(VALID_GPX);
+    expect(stats.startTime).toBeNull();
+    expect(stats.dayBreaks).toEqual([]);
+  });
+
+  it("derives dayBreaks from day-break waypoints (round-trip via generateGpx)", async () => {
+    const gpx = generateGpx({
+      name: "Multi-day",
+      waypoints: [
+        { lat: 47.0, lon: 8.0, name: "Start" },
+        { lat: 47.1, lon: 8.1, name: "Hut", isDayBreak: true },
+        { lat: 47.2, lon: 8.2, name: "End" },
+      ],
+      tracks: [[
+        { lat: 47.0, lon: 8.0 },
+        { lat: 47.1, lon: 8.1 },
+        { lat: 47.2, lon: 8.2 },
+      ]],
+    });
+
+    const { stats } = await processGpx(gpx);
+    expect(stats.dayBreaks).toEqual([1]);
+  });
+
+  it("propagates GpxValidationError from validation", async () => {
+    await expect(processGpx(ONE_POINT_GPX)).rejects.toThrow(GpxValidationError);
+  });
+
+  it("returns the parsed GpxData so callers never re-parse", async () => {
+    const { parsed } = await processGpx(VALID_GPX);
+    expect(parsed.tracks.flat()).toHaveLength(3);
+  });
+});

apps/journal/app/lib/gpx-save.server.ts

@@ -45,6 +45,51 @@ export async function validateGpx(gpx: string): Promise<GpxData> {
   return parsed;
 }
 
+export interface GpxStats {
+  distance: number | null;
+  elevationGain: number | null;
+  elevationLoss: number | null;
+  /** Indices of waypoints flagged as day breaks. */
+  dayBreaks: number[];
+  /** GPX-level description, when present. */
+  description?: string;
+  /** Timestamp of the first track point, when present. */
+  startTime: Date | null;
+}
+
+export interface ProcessedGpx {
+  parsed: GpxData;
+  /** [lon, lat] pairs in PostGIS axis order, ready for writeGeom. */
+  coords: Array<[number, number]>;
+  stats: GpxStats;
+}
+
+/**
+ * The validate-and-derive step every GPX save starts with: parse +
+ * validate (throws GpxValidationError), extract the geometry
+ * coordinates, and derive the stats rows store. Callers own the
+ * precedence between these derived stats and caller-supplied ones —
+ * routes let explicit input win wholesale, activities prefer the GPX
+ * distance unless it is zero.
+ */
+export async function processGpx(gpx: string): Promise<ProcessedGpx> {
+  const parsed = await validateGpx(gpx);
+  return {
+    parsed,
+    coords: parsed.tracks.flat().map((p) => [p.lon, p.lat] as [number, number]),
+    stats: {
+      distance: parsed.distance ?? null,
+      elevationGain: parsed.elevation.gain ?? null,
+      elevationLoss: parsed.elevation.loss ?? null,
+      dayBreaks: parsed.waypoints
+        .map((w, i) => (w.isDayBreak ? i : -1))
+        .filter((i) => i >= 0),
+      description: parsed.description,
+      startTime: parsed.tracks[0]?.[0]?.time ? new Date(parsed.tracks[0][0].time) : null,
+    },
+  };
+}
+
 type Tx = Parameters<Parameters<Database["transaction"]>[0]>[0];
 
 /**

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

@@ -4,8 +4,8 @@ import { getDb } from "./db.ts";
 import { routes, routeVersions } from "@trails-cool/db/schema/journal";
 import type { Visibility } from "@trails-cool/db/schema/journal";
 import { sql } from "drizzle-orm";
-import { validateGpx, writeGeom } from "./gpx-save.server.ts";
+import { processGpx, writeGeom } from "./gpx-save.server.ts";
-import type { GpxData } from "./gpx-save.server.ts";
+import type { ProcessedGpx } from "./gpx-save.server.ts";
 import type { OwnedRef } from "./ownership.server.ts";
 
 export interface RouteInput {
@@ -26,21 +26,17 @@ export async function createRoute(ownerId: string, input: RouteInput) {
   const db = getDb();
   const id = randomUUID();
 
-  let parsed: GpxData | null = null;
+  let processed: ProcessedGpx | null = null;
   let distance: number | null = input.distance ?? null;
   let elevationGain: number | null = input.elevationGain ?? null;
   let elevationLoss: number | null = input.elevationLoss ?? null;
   let dayBreaks: number[] = input.dayBreaks ?? [];
 
   if (input.gpx) {
-    parsed = await validateGpx(input.gpx);
+    processed = await processGpx(input.gpx);
-    // Only compute stats from GPX if not pre-supplied by caller
+    // Only use GPX-derived stats if not pre-supplied by caller
     if (input.distance === undefined) {
-      const stats = computeRouteStats(parsed);
+      ({ distance, elevationGain, elevationLoss, dayBreaks } = processed.stats);
-      distance = stats.distance;
-      elevationGain = stats.elevationGain;
-      elevationLoss = stats.elevationLoss;
-      dayBreaks = stats.dayBreaks;
     }
   }
 
@@ -60,9 +56,8 @@ export async function createRoute(ownerId: string, input: RouteInput) {
       ...(input.synthetic ? { synthetic: true } : {}),
     });
 
-    if (input.gpx && parsed) {
+    if (input.gpx && processed) {
-      const coords = parsed.tracks.flat().map((p) => [p.lon, p.lat] as [number, number]);
+      await writeGeom(tx, id, "routes", processed.coords);
-      await writeGeom(tx, id, "routes", coords);
 
       await tx.insert(routeVersions).values({
         id: randomUUID(),
@@ -135,9 +130,9 @@ export async function updateRoute(route: OwnedRef, input: Partial<RouteInput>) {
   const { id, ownerId } = route;
   const db = getDb();
 
-  let parsed: GpxData | null = null;
+  let processed: ProcessedGpx | null = null;
   if (input.gpx) {
-    parsed = await validateGpx(input.gpx);
+    processed = await processGpx(input.gpx);
   }
 
   const updateData: Record<string, unknown> = { updatedAt: new Date() };
@@ -145,8 +140,8 @@ export async function updateRoute(route: OwnedRef, input: Partial<RouteInput>) {
   if (input.description !== undefined) updateData.description = input.description;
   if (input.visibility !== undefined) updateData.visibility = input.visibility;
 
-  if (input.gpx && parsed) {
+  if (input.gpx && processed) {
-    const stats = computeRouteStats(parsed);
+    const { stats } = processed;
     updateData.gpx = input.gpx;
     updateData.distance = stats.distance;
     updateData.elevationGain = stats.elevationGain;
@@ -163,9 +158,8 @@ export async function updateRoute(route: OwnedRef, input: Partial<RouteInput>) {
       .set(updateData)
       .where(and(eq(routes.id, id), eq(routes.ownerId, ownerId)));
 
-    if (input.gpx && parsed) {
+    if (input.gpx && processed) {
-      const coords = parsed.tracks.flat().map((p) => [p.lon, p.lat] as [number, number]);
+      await writeGeom(tx, id, "routes", processed.coords);
-      await writeGeom(tx, id, "routes", coords);
 
       const existingVersions = await tx
         .select()
@@ -197,19 +191,6 @@ export async function deleteRoute(route: OwnedRef) {
   return result.length > 0;
 }
 
-function computeRouteStats(gpxData: GpxData) {
-  const dayBreaks = gpxData.waypoints
-    .map((w, i) => (w.isDayBreak ? i : -1))
-    .filter((i) => i >= 0);
-  return {
-    distance: gpxData.distance,
-    elevationGain: gpxData.elevation.gain,
-    elevationLoss: gpxData.elevation.loss,
-    dayBreaks,
-    description: gpxData.description,
-  };
-}
-
 async function getGeojson(table: "routes" | "activities", id: string): Promise<string | null> {
   try {
     const db = getDb();

apps/mobile/package.json

@@ -41,7 +41,7 @@
     "@trails-cool/map-core": "workspace:*",
     "@trails-cool/sentry-config": "workspace:*",
     "@trails-cool/types": "workspace:*",
-    "expo": "~56.0.4",
+    "expo": "~56.0.9",
     "expo-constants": "~56.0.17",
     "expo-crypto": "~56.0.4",
     "expo-dev-client": "~56.0.19",
@@ -62,10 +62,10 @@
     "react": "catalog:",
     "react-native": "0.85.3",
     "react-native-gesture-handler": "^2.31.2",
-    "react-native-reanimated": "^4.4.1",
+    "react-native-reanimated": "^4.3.1",
-    "react-native-safe-area-context": "~5.8.0",
+    "react-native-safe-area-context": "~5.7.0",
     "react-native-screens": "~4.25.2",
-    "react-native-worklets": "0.9.1",
+    "react-native-worklets": "0.8.3",
     "use-latest-callback": "^0.3.4",
     "zod": "^4.4.3"
   },