@nshiab/simple-data-analysis-core 2.1.6 → 2.1.8

package/esm/methods/paths.js

@@ -1,3 +1,4 @@
+import prepareGraphMetricOptions from "../helpers/prepareGraphMetricOptions.js";
 import { prepareGraphRouteEndpoints, prepareGraphRouteSql, validateGraphRouteInputs, } from "../helpers/prepareGraphRouteSql.js";
 import graphRouteResultSchema from "../helpers/graphRouteResultSchema.js";
 import graphRouteResultSelect from "../helpers/graphRouteResultSelect.js";
@@ -30,6 +31,7 @@ export default function paths(simpleTable, sourceColumn, targetColumn, edgeId, s
         typeof options.outputTable !== "boolean") {
         throw new TypeError("paths() options.outputTable must be a string or boolean.");
     }
+    const metric = prepareGraphMetricOptions(options, "paths()", false);
     const endpoints = prepareGraphRouteEndpoints(start, end, "paths()");
     const direction = options.direction ?? "outgoing";
     const temporalOptions = prepareGraphTemporalOptions(options, direction, "paths()");
@@ -50,7 +52,8 @@ export default function paths(simpleTable, sourceColumn, targetColumn, edgeId, s
             ? undefined
             : (input) => validateGraphTemporalEvents(input, temporalOptions, "paths()", parameters),
         values: (schema) => {
-            validateGraphRouteInputs(schema, sourceColumn, targetColumn, edgeId, endpoints, options.weight, "paths()");
+            const validated = validateGraphRouteInputs(schema, sourceColumn, targetColumn, edgeId, endpoints, options.weight, "paths()");
+            graphRouteResultSchema(schema, validated.distanceType, "paths()", metric.elapsedTime);
             const temporal = temporalOptions === undefined
                 ? undefined
                 : prepareGraphTemporalSql(schema, temporalOptions, "paths()");
@@ -58,22 +61,22 @@ export default function paths(simpleTable, sourceColumn, targetColumn, edgeId, s
                 ? endpoints.values.values
                 : [temporal.gapParameter, ...endpoints.values.values];
         },
-        buildSelect: (input, schema) => pathsSelect(input, schema, sourceColumn, targetColumn, edgeId, endpoints, direction, options.weight, temporalOptions),
+        buildSelect: (input, schema) => pathsSelect(input, schema, sourceColumn, targetColumn, edgeId, endpoints, direction, options.weight, temporalOptions, metric.elapsedTime),
         outputSchema: (schema) => {
             const validated = validateGraphRouteInputs(schema, sourceColumn, targetColumn, edgeId, endpoints, options.weight, "paths()");
             if (temporalOptions !== undefined) {
                 prepareGraphTemporalSql(schema, temporalOptions, "paths()");
             }
-            return graphRouteResultSchema(schema, validated.distanceType, "paths()");
+            return graphRouteResultSchema(schema, validated.distanceType, "paths()", metric.elapsedTime);
         },
     });
 }
-function pathsSelect(input, schema, source, target, edgeId, routeEndpoints, direction, weight, temporalOptions) {
+function pathsSelect(input, schema, source, target, edgeId, routeEndpoints, direction, weight, temporalOptions, elapsedTime) {
     const route = prepareGraphRouteSql(input, schema, source, target, edgeId, routeEndpoints, weight, "paths()");
     const prepared = route.traversal;
     if (temporalOptions !== undefined) {
         const temporal = prepareGraphTemporalSql(schema, temporalOptions, "paths()");
-        return temporalPathsSelect(route, direction, temporal);
+        return temporalPathsSelect(route, direction, temporal, elapsedTime);
     }
     const distanceType = route.distanceType;
     const q = quoteIdentifier;
@@ -166,7 +169,7 @@ function pathsSelect(input, schema, source, target, edgeId, routeEndpoints, dire
     )
     ${graphRouteResultSelect(rankedRelation, route.input, route.edgeIdColumn)}`;
 }
-function temporalPathsSelect(route, direction, temporal) {
+function temporalPathsSelect(route, direction, temporal, elapsedTime) {
     const prepared = route.traversal;
     const distanceType = route.distanceType;
     const q = quoteIdentifier;
@@ -197,12 +200,16 @@ function temporalPathsSelect(route, direction, temporal) {
     const edgeKey = `${q("edges")}.${q("__edge_key")}`;
     const candidateDistance = `CAST(${q("routes")}.${q("distance")} + ${edgeCost} AS ${distanceType})`;
     const gap = `${q("settings")}.${q("__gap")}`;
-    const step = (distance) => `struct_pack(
+    const firstAnchor = temporal.journeyAnchor("edges", direction);
+    const anchor = `${q("routes")}.${q("__journey_anchor")}`;
+    const step = (distance, journeyAnchor) => `struct_pack(
           ${q("edgeId")} := ${q("edges")}.${q("__edge_id")},
           ${q("source")} := ${q("edges")}.${q("__from")},
           ${q("target")} := ${edgeTo},
           ${q("weight")} := ${edgeCost},
-          ${q("distance")} := ${distance}
+          ${q("distance")} := ${distance}${elapsedTime
+        ? `, ${q("elapsedTimeMs")} := ${temporal.elapsedMilliseconds(temporal.journeyElapsed("edges", journeyAnchor, direction))}`
+        : ""}
         )`;
     return `WITH RECURSIVE ${settingsRelation} AS MATERIALIZED (
       SELECT CAST(? AS HUGEINT) AS ${q("__gap")}
@@ -241,14 +248,14 @@ function temporalPathsSelect(route, direction, temporal) {
     ), ${routesRelation}(
       ${q("node")}, ${q("__node_key")}, ${q("__visited")},
       ${q("__edge_keys")}, ${q("steps")}, ${q("distance")},
-      ${q("__event_id")}, ${q("__event_start")}, ${q("__event_end")}
+      ${q("__event_id")}, ${q("__event_start")}, ${q("__event_end")}${elapsedTime ? `, ${q("__journey_anchor")}` : ""}
     ) AS (
       SELECT ${edgeTo}, ${edgeToKey},
         [${q("__start_key")}, ${edgeToKey}], [${edgeKey}],
-        [${step(edgeCost)}], ${edgeCost},
+        [${step(edgeCost, firstAnchor)}], ${edgeCost},
         ${q("edges")}.${q("__event_id")},
         ${q("edges")}.${q("__event_start")},
-        ${q("edges")}.${q("__event_end")}
+        ${q("edges")}.${q("__event_end")}${elapsedTime ? `, ${firstAnchor}` : ""}
       FROM ${endpointRelation}
       INNER JOIN ${edgesRelation} AS ${q("edges")}
         ON ${q("__start_key")} = ${edgeFromKey}
@@ -259,10 +266,10 @@ function temporalPathsSelect(route, direction, temporal) {
       SELECT ${edgeTo}, ${edgeToKey},
         list_append(${q("routes")}.${q("__visited")}, ${edgeToKey}),
         list_append(${q("routes")}.${q("__edge_keys")}, ${edgeKey}),
-        list_append(${q("routes")}.${q("steps")}, ${step(candidateDistance)}),
+        list_append(${q("routes")}.${q("steps")}, ${step(candidateDistance, anchor)}),
         ${candidateDistance}, ${q("edges")}.${q("__event_id")},
         ${q("edges")}.${q("__event_start")},
-        ${q("edges")}.${q("__event_end")}
+        ${q("edges")}.${q("__event_end")}${elapsedTime ? `, ${anchor}` : ""}
       FROM ${routesRelation} AS ${q("routes")}
       INNER JOIN ${edgesRelation} AS ${q("edges")}
         ON ${q("routes")}.${q("__node_key")} = ${edgeFromKey}
@@ -283,5 +290,5 @@ function temporalPathsSelect(route, direction, temporal) {
           AS ${q("pathId")}, ${q("steps")}
       FROM ${completeRelation}
     )
-    ${graphRouteResultSelect(rankedRelation, route.input, route.edgeIdColumn)}`;
+    ${graphRouteResultSelect(rankedRelation, route.input, route.edgeIdColumn, false, elapsedTime)}`;
 }

package/esm/methods/shortestPath.d.ts

@@ -6,6 +6,8 @@ type ShortestPathOptions = GraphTemporalOptions & {
     direction?: GraphDirection;
     outputTable?: string | boolean;
     weight?: string;
+    elapsedTime?: boolean;
+    minimize?: "steps" | "weight" | "elapsedTime";
 };
 export default function shortestPath(simpleTable: SimpleTable, sourceColumn: string, targetColumn: string, edgeId: string, start: GraphId, end: GraphId, options?: ShortestPathOptions): SimpleTable;
 export {};

package/esm/methods/shortestPath.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shortestPath.d.ts","sourceRoot":"","sources":["../../src/methods/shortestPath.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAGvD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kCAAkC,CAAC;AAShE,OAAgC,EAC9B,KAAK,oBAAoB,EAG1B,MAAM,uCAAuC,CAAC;AAC/C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qCAAqC,CAAC;AAK1E,KAAK,mBAAmB,GAAG,oBAAoB,GAAG;IAChD,SAAS,CAAC,EAAE,cAAc,CAAC;IAC3B,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IAC/B,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,MAAM,CAAC,OAAO,UAAU,YAAY,CAClC,WAAW,EAAE,WAAW,EACxB,YAAY,EAAE,MAAM,EACpB,YAAY,EAAE,MAAM,EACpB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,OAAO,EACd,GAAG,EAAE,OAAO,EACZ,OAAO,GAAE,mBAAwB,GAChC,WAAW,CAmHb"}
+{"version":3,"file":"shortestPath.d.ts","sourceRoot":"","sources":["../../src/methods/shortestPath.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAMvD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kCAAkC,CAAC;AAShE,OAAgC,EAC9B,KAAK,oBAAoB,EAG1B,MAAM,uCAAuC,CAAC;AAC/C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qCAAqC,CAAC;AAK1E,KAAK,mBAAmB,GAAG,oBAAoB,GAAG;IAChD,SAAS,CAAC,EAAE,cAAc,CAAC;IAC3B,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IAC/B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,QAAQ,CAAC,EAAE,OAAO,GAAG,QAAQ,GAAG,aAAa,CAAC;CAC/C,CAAC;AAEF,MAAM,CAAC,OAAO,UAAU,YAAY,CAClC,WAAW,EAAE,WAAW,EACxB,YAAY,EAAE,MAAM,EACpB,YAAY,EAAE,MAAM,EACpB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,OAAO,EACd,GAAG,EAAE,OAAO,EACZ,OAAO,GAAE,mBAAwB,GAChC,WAAW,CAyHb"}

package/esm/methods/shortestPath.js

@@ -1,4 +1,5 @@
 import buildGraphTemporalCostStateSql from "../helpers/buildGraphTemporalCostStateSql.js";
+import prepareGraphMetricOptions from "../helpers/prepareGraphMetricOptions.js";
 import { prepareGraphRouteEndpoints, prepareGraphRouteSql, validateGraphRouteInputs, } from "../helpers/prepareGraphRouteSql.js";
 import graphRouteResultSchema from "../helpers/graphRouteResultSchema.js";
 import graphRouteResultSelect from "../helpers/graphRouteResultSelect.js";
@@ -31,6 +32,7 @@ export default function shortestPath(simpleTable, sourceColumn, targetColumn, ed
         typeof options.outputTable !== "boolean") {
         throw new TypeError("shortestPath() options.outputTable must be a string or boolean.");
     }
+    const metrics = prepareGraphMetricOptions(options, "shortestPath()", true);
     const endpoints = prepareGraphRouteEndpoints(start, end, "shortestPath()");
     const direction = options.direction ?? "outgoing";
     const temporalOptions = prepareGraphTemporalOptions(options, direction, "shortestPath()");
@@ -51,7 +53,7 @@ export default function shortestPath(simpleTable, sourceColumn, targetColumn, ed
             ? undefined
             : (input) => validateGraphTemporalEvents(input, temporalOptions, "shortestPath()", parameters),
         values: (schema) => {
-            validateGraphRouteInputs(schema, sourceColumn, targetColumn, edgeId, endpoints, options.weight, "shortestPath()");
+            validateGraphRouteInputs(schema, sourceColumn, targetColumn, edgeId, endpoints, options.weight, "shortestPath()", options.weight !== undefined);
             const temporal = temporalOptions === undefined
                 ? undefined
                 : prepareGraphTemporalSql(schema, temporalOptions, "shortestPath()");
@@ -59,29 +61,30 @@ export default function shortestPath(simpleTable, sourceColumn, targetColumn, ed
                 ? endpoints.values.values
                 : [temporal.gapParameter, ...endpoints.values.values];
         },
-        buildSelect: (input, schema) => shortestPathSelect(input, schema, sourceColumn, targetColumn, edgeId, endpoints, direction, options.weight, temporalOptions),
+        buildSelect: (input, schema) => shortestPathSelect(input, schema, sourceColumn, targetColumn, edgeId, endpoints, direction, options.weight, temporalOptions, metrics),
         outputSchema: (schema) => {
-            const validated = validateGraphRouteInputs(schema, sourceColumn, targetColumn, edgeId, endpoints, options.weight, "shortestPath()");
+            const validated = validateGraphRouteInputs(schema, sourceColumn, targetColumn, edgeId, endpoints, options.weight, "shortestPath()", options.weight !== undefined);
             if (temporalOptions !== undefined) {
                 prepareGraphTemporalSql(schema, temporalOptions, "shortestPath()");
             }
-            return graphRouteResultSchema(schema, validated.distanceType, "shortestPath()");
+            return graphRouteResultSchema(schema, validated.distanceType, "shortestPath()", metrics.elapsedTime, options.weight !== undefined);
         },
     });
 }
-function shortestPathSelect(input, schema, source, target, edgeId, routeEndpoints, direction, weight, temporalOptions) {
-    const route = prepareGraphRouteSql(input, schema, source, target, edgeId, routeEndpoints, weight, "shortestPath()");
+function shortestPathSelect(input, schema, source, target, edgeId, routeEndpoints, direction, weight, temporalOptions, metrics) {
+    const route = prepareGraphRouteSql(input, schema, source, target, edgeId, routeEndpoints, weight, "shortestPath()", weight !== undefined);
     const prepared = route.traversal;
     if (temporalOptions !== undefined) {
         const temporal = prepareGraphTemporalSql(schema, temporalOptions, "shortestPath()");
-        return temporalShortestPathSelect(route, direction, temporal);
+        return temporalShortestPathSelect(route, direction, temporal, metrics, weight !== undefined);
     }
     const distanceType = route.distanceType;
     // Exact shortest routes have optimal prefixes. Floating addition can erase
     // a prefix-cost difference later, so retain all simple prefixes up to the
     // best complete cost before selecting the full-route ties.
-    const floating = route.weightType === "FLOAT" ||
-        route.weightType === "DOUBLE";
+    const floating = metrics.minimize === "weight" &&
+        (route.weightType === "FLOAT" || route.weightType === "DOUBLE");
+    const metricType = metrics.minimize === "steps" ? "BIGINT" : distanceType;
     const relations = prepared.relationNames([
         "graph_route_endpoints",
         "graph_edges",
@@ -107,8 +110,17 @@ function shortestPathSelect(input, schema, source, target, edgeId, routeEndpoint
     const edgeToKey = `${q("edges")}.${q("__to_key")}`;
     const edgeTo = `${q("edges")}.${q("__to")}`;
     const edgeCost = `${q("edges")}.${q("__weight")}`;
+    const edgeMetric = metrics.minimize === "steps"
+        ? "CAST(1 AS BIGINT)"
+        : edgeCost;
     const routeDistance = `${q("routes")}.${q("distance")}`;
     const candidateDistance = `CAST(${routeDistance} + ${edgeCost} AS ${distanceType})`;
+    const routeMetric = metrics.minimize === "steps"
+        ? `len(${q("routes")}.${q("steps")})`
+        : routeDistance;
+    const candidateMetric = metrics.minimize === "steps"
+        ? `${routeMetric} + 1`
+        : candidateDistance;
     return `WITH RECURSIVE ${endpointRelation}(
       ${q("start")}, ${q("end")}, ${q("__start_key")}, ${q("__end_key")}
     ) AS (
@@ -140,13 +152,13 @@ function shortestPathSelect(input, schema, source, target, edgeId, routeEndpoint
       ${q("node")}, ${q("__node_key")}, ${q("distance")}
     ) USING KEY(${q("__node_key")}) AS (
       SELECT ${q("start")}, ${q("__start_key")},
-        CAST(0 AS ${distanceType})
+        CAST(0 AS ${metricType})
       FROM ${endpointRelation}
       INNER JOIN ${toEndRelation}
         ON ${q("__start_key")} = ${q("__key")}
       UNION
       SELECT ${edgeTo}, ${edgeToKey},
-        MIN(CAST(${q("reached")}.${q("distance")} + ${edgeCost} AS ${distanceType}))
+        MIN(CAST(${q("reached")}.${q("distance")} + ${edgeMetric} AS ${metricType}))
       FROM ${distancesRelation} AS ${q("reached")}
       INNER JOIN ${edgesRelation} AS ${q("edges")}
         ON ${q("reached")}.${q("__node_key")} = ${edgeFromKey}
@@ -156,7 +168,7 @@ function shortestPathSelect(input, schema, source, target, edgeId, routeEndpoint
         ON ${edgeToKey} = ${q("best")}.${q("__node_key")}
       GROUP BY ${edgeTo}, ${edgeToKey}, ${q("best")}.${q("distance")}
       HAVING ${q("best")}.${q("distance")} IS NULL
-        OR MIN(CAST(${q("reached")}.${q("distance")} + ${edgeCost} AS ${distanceType})) < ${q("best")}.${q("distance")}
+        OR MIN(CAST(${q("reached")}.${q("distance")} + ${edgeMetric} AS ${metricType})) < ${q("best")}.${q("distance")}
     ), ${bestTotalRelation} AS (
       SELECT ${q("distances")}.${q("distance")}
       FROM ${distancesRelation} AS ${q("distances")}
@@ -195,23 +207,23 @@ function shortestPathSelect(input, schema, source, target, edgeId, routeEndpoint
       WHERE ${q("routes")}.${q("__node_key")} <> ${q("__end_key")}
         AND NOT list_contains(${q("routes")}.${q("__visited")}, ${edgeToKey})
         AND ${floating
-        ? `${candidateDistance} <= ${q("best_total")}.${q("distance")}`
-        : `${candidateDistance} = ${q("best_prefix")}.${q("distance")}`}
+        ? `${candidateMetric} <= ${q("best_total")}.${q("distance")}`
+        : `${candidateMetric} = ${q("best_prefix")}.${q("distance")}`}
     ), ${shortestRelation} AS (
       SELECT ${q("__edge_keys")}, ${q("steps")}
-      FROM ${routesRelation}
+      FROM ${routesRelation} AS ${q("routes")}
       CROSS JOIN ${endpointRelation}
       CROSS JOIN ${bestTotalRelation} AS ${q("best_total")}
       WHERE ${q("__node_key")} = ${q("__end_key")}
-        AND ${routesRelation}.${q("distance")} = ${q("best_total")}.${q("distance")}
+        AND ${routeMetric} = ${q("best_total")}.${q("distance")}
     ), ${rankedRelation} AS (
       SELECT CAST(row_number() OVER (ORDER BY ${q("__edge_keys")}) - 1 AS BIGINT) AS ${q("pathId")},
         ${q("steps")}
       FROM ${shortestRelation}
     )
-    ${graphRouteResultSelect(rankedRelation, route.input, route.edgeIdColumn)}`;
+    ${graphRouteResultSelect(rankedRelation, route.input, route.edgeIdColumn, false, false, weight !== undefined)}`;
 }
-function temporalShortestPathSelect(route, direction, temporal) {
+function temporalShortestPathSelect(route, direction, temporal, metrics, includeTotal) {
     const prepared = route.traversal;
     const q = quoteIdentifier;
     const startsSelect = `SELECT ${q("start")},
@@ -219,10 +231,12 @@ function temporalShortestPathSelect(route, direction, temporal) {
       FROM (SELECT ${route.endpointValue} AS ${q("start")}) AS ${q("values")}`;
     // Non-negative weights and no maximum gap let cycles be removed from walks.
     // Their optimum bounds simple routes; retain separate histories for all ties.
-    const costs = buildGraphTemporalCostStateSql(prepared, startsSelect, direction, temporal, route.distanceType, route.edgeWeight, [
-        `${route.typedEdgeId} AS ${q("__edge_id")}`,
-        `${route.edgeKey} AS ${q("__edge_key")}`,
-    ]);
+    const costs = metrics.minimize === "elapsedTime"
+        ? buildElapsedShortestPathCostSql(route, startsSelect, direction, temporal)
+        : buildGraphTemporalCostStateSql(prepared, startsSelect, direction, temporal, route.distanceType, route.edgeWeight, [
+            `${route.typedEdgeId} AS ${q("__edge_id")}`,
+            `${route.edgeKey} AS ${q("__edge_key")}`,
+        ], metrics.minimize === "steps" ? "steps" : "weight");
     const relations = prepared.relationNames([
         "graph_route_endpoints",
         "graph_nodes",
@@ -248,12 +262,33 @@ function temporalShortestPathSelect(route, direction, temporal) {
     const routeDistance = `${q("routes")}.${q("distance")}`;
     const candidateDistance = `CAST(${routeDistance} + ${edgeCost} AS ${route.distanceType})`;
     const gap = `${q("settings")}.${q("__gap")}`;
-    const step = (distance) => `struct_pack(
+    const firstAnchor = temporal.journeyAnchor("edges", direction);
+    const routeAnchor = `${q("routes")}.${q("__journey_anchor")}`;
+    const firstElapsed = temporal.journeyElapsed("edges", firstAnchor, direction);
+    const candidateElapsed = temporal.journeyElapsed("edges", routeAnchor, direction);
+    const firstMetric = metrics.minimize === "steps"
+        ? "1"
+        : metrics.minimize === "elapsedTime"
+            ? firstElapsed
+            : edgeCost;
+    const routeMetric = metrics.minimize === "steps"
+        ? `len(${q("routes")}.${q("steps")})`
+        : metrics.minimize === "elapsedTime"
+            ? `${q("routes")}.${q("__elapsed")}`
+            : routeDistance;
+    const candidateMetric = metrics.minimize === "steps"
+        ? `${routeMetric} + 1`
+        : metrics.minimize === "elapsedTime"
+            ? candidateElapsed
+            : candidateDistance;
+    const step = (distance, elapsed) => `struct_pack(
           ${q("edgeId")} := ${q("edges")}.${q("__edge_id")},
           ${q("source")} := ${q("edges")}.${q("__from")},
           ${q("target")} := ${edgeTo},
           ${q("weight")} := ${edgeCost},
-          ${q("distance")} := ${distance}
+          ${q("distance")} := ${distance}${metrics.elapsedTime
+        ? `, ${q("elapsedTimeMs")} := ${temporal.elapsedMilliseconds(elapsed)}`
+        : ""}
         )`;
     return `${costs.withClause}, ${endpointRelation}(
       ${q("start")}, ${q("end")}, ${q("__start_key")}, ${q("__end_key")}
@@ -278,44 +313,44 @@ function temporalShortestPathSelect(route, direction, temporal) {
       INNER JOIN ${edgesRelation} AS ${q("edges")}
         ON ${q("reached")}.${q("__key")} = ${edgeToKey}
     ), ${bestTotalRelation} AS (
-      SELECT MIN(${q("costs")}.${q("distance")}) AS ${q("distance")}
+      SELECT MIN(${q("costs")}.${q(metrics.minimize === "steps" ? "steps" : "distance")}) AS ${q("distance")}
       FROM ${costs.costRelation} AS ${q("costs")}
       INNER JOIN ${endpointRelation}
         ON ${q("costs")}.${q("__node_key")} = ${q("__end_key")}
     ), ${routesRelation}(
       ${q("node")}, ${q("__node_key")}, ${q("__visited")},
       ${q("__edge_keys")}, ${q("steps")}, ${q("distance")},
-      ${q("__event_id")}, ${q("__event_start")}, ${q("__event_end")}
+      ${q("__event_id")}, ${q("__event_start")}, ${q("__event_end")}${metrics.elapsedTime ? `, ${q("__journey_anchor")}, ${q("__elapsed")}` : ""}
     ) AS (
       SELECT ${edgeTo}, ${edgeToKey},
         [${q("__start_key")}, ${edgeToKey}], [${edgeKey}],
-        [${step(edgeCost)}], ${edgeCost},
+        [${step(edgeCost, firstElapsed)}], ${edgeCost},
         ${q("edges")}.${q("__event_id")},
         ${q("edges")}.${q("__event_start")},
-        ${q("edges")}.${q("__event_end")}
+        ${q("edges")}.${q("__event_end")}${metrics.elapsedTime ? `, ${firstAnchor}, ${firstElapsed}` : ""}
       FROM ${endpointRelation}
       INNER JOIN ${edgesRelation} AS ${q("edges")}
         ON ${q("__start_key")} = ${edgeFromKey}
       INNER JOIN ${toEndRelation} AS ${q("can_reach_end")}
         ON ${edgeToKey} = ${q("can_reach_end")}.${q("__key")}
       INNER JOIN ${bestTotalRelation} AS ${q("best_total")}
-        ON ${edgeCost} <= ${q("best_total")}.${q("distance")}
+        ON ${firstMetric} <= ${q("best_total")}.${q("distance")}
       WHERE ${q("__start_key")} <> ${edgeToKey}
       UNION ALL
       SELECT ${edgeTo}, ${edgeToKey},
         list_append(${q("routes")}.${q("__visited")}, ${edgeToKey}),
         list_append(${q("routes")}.${q("__edge_keys")}, ${edgeKey}),
-        list_append(${q("routes")}.${q("steps")}, ${step(candidateDistance)}),
+        list_append(${q("routes")}.${q("steps")}, ${step(candidateDistance, candidateElapsed)}),
         ${candidateDistance}, ${q("edges")}.${q("__event_id")},
         ${q("edges")}.${q("__event_start")},
-        ${q("edges")}.${q("__event_end")}
+        ${q("edges")}.${q("__event_end")}${metrics.elapsedTime ? `, ${routeAnchor}, ${candidateElapsed}` : ""}
       FROM ${routesRelation} AS ${q("routes")}
       INNER JOIN ${edgesRelation} AS ${q("edges")}
         ON ${q("routes")}.${q("__node_key")} = ${edgeFromKey}
       INNER JOIN ${toEndRelation} AS ${q("can_reach_end")}
         ON ${edgeToKey} = ${q("can_reach_end")}.${q("__key")}
       INNER JOIN ${bestTotalRelation} AS ${q("best_total")}
-        ON ${candidateDistance} <= ${q("best_total")}.${q("distance")}
+        ON ${candidateMetric} <= ${q("best_total")}.${q("distance")}
       CROSS JOIN ${endpointRelation}
       CROSS JOIN ${costs.settingsRelation} AS ${q("settings")}
       WHERE ${q("routes")}.${q("__node_key")} <> ${q("__end_key")}
@@ -327,11 +362,97 @@ function temporalShortestPathSelect(route, direction, temporal) {
       CROSS JOIN ${endpointRelation}
       CROSS JOIN ${bestTotalRelation} AS ${q("best_total")}
       WHERE ${q("__node_key")} = ${q("__end_key")}
-        AND ${routeDistance} = ${q("best_total")}.${q("distance")}
+        AND ${routeMetric} = ${q("best_total")}.${q("distance")}
     ), ${rankedRelation} AS (
       SELECT CAST(row_number() OVER (ORDER BY ${q("__edge_keys")}) - 1 AS BIGINT)
           AS ${q("pathId")}, ${q("steps")}
       FROM ${shortestRelation}
     )
-    ${graphRouteResultSelect(rankedRelation, route.input, route.edgeIdColumn)}`;
+    ${graphRouteResultSelect(rankedRelation, route.input, route.edgeIdColumn, false, metrics.elapsedTime, includeTotal)}`;
+}
+// At the same physical event a later departure (or earlier incoming arrival)
+// dominates every future elapsed duration. Keyed improvements find the optimum
+// without enumerating route histories; reconstruction still retains all ties.
+function buildElapsedShortestPathCostSql(route, startsSelect, direction, temporal) {
+    const prepared = route.traversal;
+    const q = quoteIdentifier;
+    const relations = prepared.relationNames([
+        "graph_starts",
+        "graph_temporal_settings",
+        "graph_event_rows",
+        "graph_edges",
+        "graph_cost_states",
+    ]);
+    const startsRelation = relations.graph_starts;
+    const settingsRelation = relations.graph_temporal_settings;
+    const eventRowsRelation = relations.graph_event_rows;
+    const edgesRelation = relations.graph_edges;
+    const costRelation = relations.graph_cost_states;
+    const start = `${q("starts")}.${q("start")}`;
+    const startKey = `${q("starts")}.${q("__key")}`;
+    const reachedStart = `${q("reached")}.${q("start")}`;
+    const reachedStartKey = `${q("reached")}.${q("__start_key")}`;
+    const reachedNodeKey = `${q("reached")}.${q("__node_key")}`;
+    const edgeTo = `${q("edges")}.${q("__to")}`;
+    const edgeToKey = `${q("edges")}.${q("__to_key")}`;
+    const edgeFromKey = `${q("edges")}.${q("__from_key")}`;
+    const eventId = `${q("edges")}.${q("__event_id")}`;
+    const eventStart = `${q("edges")}.${q("__event_start")}`;
+    const eventEnd = `${q("edges")}.${q("__event_end")}`;
+    const bestDistance = `${q("best")}.${q("distance")}`;
+    const gap = `${q("settings")}.${q("__gap")}`;
+    const firstAnchor = temporal.journeyAnchor("edges", direction);
+    const reachedAnchor = `${q("reached")}.${q("__journey_anchor")}`;
+    const firstElapsed = temporal.journeyElapsed("edges", firstAnchor, direction);
+    const candidateDistance = temporal.journeyElapsed("edges", reachedAnchor, direction);
+    const bestAnchor = `${direction === "outgoing" ? "MAX" : "MIN"}(${reachedAnchor})`;
+    return {
+        costRelation,
+        edgesRelation,
+        settingsRelation,
+        startsRelation,
+        withClause: `WITH RECURSIVE ${settingsRelation} AS MATERIALIZED (
+      SELECT CAST(? AS HUGEINT) AS ${q("__gap")}
+    ), ${eventRowsRelation} AS MATERIALIZED (
+      ${prepared.edges(direction, [
+            `${route.edgeWeight} AS ${q("__weight")}`,
+            `${route.typedEdgeId} AS ${q("__edge_id")}`,
+            `${route.edgeKey} AS ${q("__edge_key")}`,
+            ...temporal.eventSelections("edges"),
+        ])}
+    ), ${edgesRelation} AS MATERIALIZED (
+      SELECT *
+      FROM ${eventRowsRelation} AS ${q("events")}
+      WHERE ${temporal.eventValidity("events")}
+    ), ${startsRelation} AS MATERIALIZED (
+      ${startsSelect}
+    ), ${costRelation}(
+      ${q("start")}, ${q("node")},
+      ${q("__start_key")}, ${q("__node_key")},
+      ${q("__event_id")}, ${q("__event_start")}, ${q("__event_end")},
+      ${q("distance")}, ${q("__journey_anchor")}
+    ) USING KEY(${q("__start_key")}, ${q("__event_id")}) AS (
+      SELECT ${start}, ${edgeTo}, ${startKey}, ${edgeToKey},
+        ${eventId}, ${eventStart}, ${eventEnd}, ${firstElapsed}, ${firstAnchor}
+      FROM ${startsRelation} AS ${q("starts")}
+      INNER JOIN ${edgesRelation} AS ${q("edges")}
+        ON ${startKey} = ${edgeFromKey}
+      UNION
+      SELECT ${reachedStart}, ${edgeTo}, ${reachedStartKey}, ${edgeToKey},
+        ${eventId}, ${eventStart}, ${eventEnd},
+        MIN(${candidateDistance}) AS ${q("distance")}, ${bestAnchor}
+      FROM ${costRelation} AS ${q("reached")}
+      INNER JOIN ${edgesRelation} AS ${q("edges")}
+        ON ${reachedNodeKey} = ${edgeFromKey}
+      CROSS JOIN ${settingsRelation} AS ${q("settings")}
+      LEFT JOIN recurring.${costRelation} AS ${q("best")}
+        ON ${reachedStartKey} = ${q("best")}.${q("__start_key")}
+        AND ${eventId} = ${q("best")}.${q("__event_id")}
+      WHERE ${temporal.transition("reached", "edges", direction, gap)}
+      GROUP BY ${reachedStart}, ${edgeTo}, ${reachedStartKey}, ${edgeToKey},
+        ${eventId}, ${eventStart}, ${eventEnd}, ${bestDistance}
+      HAVING ${bestDistance} IS NULL OR
+        MIN(${candidateDistance}) < ${bestDistance}
+    )`,
+    };
 }