@autobusal/routes-order 1.34.3 → 1.34.4

package/CHANGELOG.md

@@ -1,3 +1,15 @@
+## 1.34.4 - 2026-08-29
+
+- The date strip and the search-again panel WRITE THE SEARCH INTO THE URL, so a refresh keeps the chosen day and a shared link opens the results it was copied from (audit A3-02f).
+
+- A results URL carrying a real return date is read as a round trip whatever its type segment says - it used to sell a one-way silently (audit A3-07c).
+
+- An agent's checkout previews what the card will actually be charged: the seller's own commission is stated as its own line and the surcharge is computed on the NET, the same base obtapi charges on. An agent was shown 67.05 against a 60.67 charge (audit A4-07).
+
+- An invalid coupon says so, inline and announced - a code that did not exist reached no handler at all, so the commonest case (a typo) changed nothing on screen (audit A3-10c).
+
+- The details expander gains the ITINERARY and a line on cancellation and changes; the quick-pick chips format the duration instead of printing a bare "04:30" that reads as a departure time (audit A3-02h, A3-02j).
+
 ## 1.34.3 - 2026-08-29
 
 - Staff sellers (agent/subagent/operator/employee/admin) get an OPTIONAL passenger email box at checkout, so a counter-sold ticket reaches the passenger instead of only the seller and operator (audit A4-05, owner decision). obtapi already read {type}{i}_email/_notify_email; it now validates them too.

package/Checkout/Checkout.tsx

@@ -1,5 +1,6 @@
 import { useCallback, useState, useEffect } from 'react';
 import { TFunction } from 'i18next';
+import { useQueryClient } from '@tanstack/react-query';
 import { useForm } from 'react-hook-form';
 import { useNavigate } from 'react-router-dom';
 import { RiShoppingCartLine } from 'react-icons/ri';
@@ -24,7 +25,7 @@ import { CouponData } from '@autobusal/providers/types/orders';
 import { TotalData } from '../types';
 import { useUserStore } from '@autobusal/providers/stores/user';
 import { useGetSettings } from '@autobusal/providers/services';
-import { usePostOrder, useGetFlex, useGetPayments, useGetSavedPassengers } from '../services';
+import { usePostOrder, useGetFlex, useGetPayments, useGetSavedPassengers, useGetComission } from '../services';
 import { addon as commerceAddon, beginCheckout, stash } from '@autobusal/providers/Setup/commerce';
 import { item as commerceItem } from '../commerce';
 import { error as notifyError } from '@autobusal/utilities';
@@ -100,6 +101,10 @@ const Checkout = ({ values, step1, step2, step3, isPartner, t, onStore, onBack }
   const passenger = useForm<PersonData>();
   const billing = useForm<BillingData>();
 
+  // Claude - 2026-08-29 (audit A3-08c): to re-ask for the seat map after a
+  // refusal, so a seat taken while this form was open stops looking free
+  const queryClient = useQueryClient();
+
   const [ coupon, setCoupon ] = useState<CouponData | undefined>(undefined);
   const [ total, setTotal ] = useState<TotalData>(getTotal(step2, step3));
   const [ action, setAction ] = useState<string | undefined>(undefined);
@@ -179,6 +184,61 @@ const Checkout = ({ values, step1, step2, step3, isPartner, t, onStore, onBack }
   const busFrom = useBusOccupied(step1.departure, step2.id as number);
   const busTo = useBusOccupied(step1._return, step3?.id as (number | undefined));
 
+  /*
+   * Claude - 2026-08-29 (audit A3-08c, low)
+   *
+   * A SEAT SOMEBODY ELSE HAS TAKEN STOPS BEING "YOURS".
+   *
+   * The chosen-seat badge was pure local state in ChooseSeat, so when a
+   * booking was refused because the seat had gone, the button went on
+   * reading "You have chosen seat 7" until the buyer happened to reopen the
+   * map - and pressing Pay again simply failed again for the same reason.
+   *
+   * Driven by the OCCUPANCY rather than by the error message: the reply is a
+   * localised sentence in one of fifteen languages and matching on its text
+   * would be a guess, while "is this seat taken now" is a fact and answers
+   * the case where a seat sells while the buyer is still filling the form.
+   *
+   * `reset` is a remount key for the passenger block, which is what makes
+   * ChooseSeat re-read its default - it owns `selected` internally and has
+   * no other way to be told. The typed passenger details survive: they live
+   * in the react-hook-form state outside this block, not in the inputs.
+   */
+  const [ seatsReset, setSeatsReset ] = useState<number>(0);
+
+  useEffect(() => {
+    const values = passenger.getValues() as Record<string, unknown>;
+
+    const gone = Object.keys(values).filter(field => {
+      const leg = /_s([dr])$/.exec(field);
+
+      if (!leg) {
+        return false;
+      }
+
+      const seat = Number(values[field]);
+
+      const taken = leg[1] === 'd' ? busFrom?.occupied : busTo?.occupied;
+
+      return seat > 0 && Array.isArray(taken) && taken.includes(seat);
+    });
+
+    if (gone.length === 0) {
+      return;
+    }
+
+    gone.forEach(field => passenger.setValue(field, 0));
+
+    // upstream too - it is what ChooseSeat reads as its default on remount
+    onStore(passenger.getValues());
+
+    // the fee line counts what is still hand-picked, which is now fewer
+    setSeatsPicked(count => Math.max(0, count - gone.length));
+
+    setSeatsReset(value => value + 1);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [busFrom, busTo]);
+
   // Edited: Claude - Date: 2026-08-28 (sweep, low): the currency is the
   // LAST token - split(' ')[1] read '250.00' out of '1 250.00 EUR'
   const currency = currencyOf(total.display);
@@ -276,7 +336,48 @@ const Checkout = ({ values, step1, step2, step3, isPartner, t, onStore, onBack }
    * reserve and complimentary - see surchargeOf, which only recognises the
    * five gateways obtapi actually surcharges.
    */
-  const surcharge = surchargeOf(grandTotal.value, action, paymentsData);
+  /*
+   * Claude - 2026-08-29 (audit A4-07, medium)
+   *
+   * WHAT A RESELLER ACTUALLY OWES. An agency pays the fare minus its own
+   * commission (obtapi Payments\Owed), the card is charged on that net, and
+   * this screen knew nothing about it - so an agent was shown a 1.95
+   * surcharge on a 65.10 basket and a 67.05 total, while RaiAccept asked for
+   * 60.67. Every figure a reseller saw before pressing pay was wrong, in a
+   * way no reconciliation of their card statement could explain.
+   *
+   * Zero for everybody else, and no request made for them: a passenger earns
+   * no commission, so net and gross are the same number and their checkout
+   * is untouched.
+   */
+  const { data: ComissionData } = useGetComission(
+    UserData !== undefined && ['agent', 'subagent'].includes(UserData.type),
+    step1.departure,
+    step2.price.id,
+    step1.adults,
+    step1.children,
+    step1.babies,
+    step3 !== undefined ? step1._return : undefined,
+    step3?.price.id
+  );
+
+  /*
+   * Never more than the basket - a commission larger than the fare is a
+   * configuration mistake, and the server's own Owed::forBooking floors it at
+   * zero rather than paying anybody to travel. The two must agree or the
+   * total shown is wrong again, in the other direction.
+   */
+  const comission = Math.min(
+    Math.round(((ComissionData?.comission_agent ?? 0) + Number.EPSILON) * 100) / 100,
+    grandTotal.value
+  );
+
+  /*
+   * Claude - 2026-08-29: the surcharge is charged on what is OWED, which is
+   * the basket less the seller's own commission - the same base
+   * Payments\Surcharge::quote uses. It was computed on the gross.
+   */
+  const surcharge = surchargeOf(grandTotal.value - comission, action, paymentsData);
 
   /*
    * What the buyer is actually asked for. Rounded rather than summed
@@ -288,9 +389,11 @@ const Checkout = ({ values, step1, step2, step3, isPartner, t, onStore, onBack }
    * value of the SALE is the tickets and the add-ons, and folding a card
    * fee into it would quietly inflate revenue for anyone paying by card.
    */
-  const payable: TotalData = surcharge > 0 ? {
-    display: `${ Math.round((grandTotal.value + surcharge) * 100) / 100 } ${ currency }`,
-    value: Math.round((grandTotal.value + surcharge) * 100) / 100
+  const owed = Math.round((grandTotal.value - comission + surcharge) * 100) / 100;
+
+  const payable: TotalData = (surcharge > 0 || comission > 0) ? {
+    display: `${ owed } ${ currency }`,
+    value: owed
   } : grandTotal;
 
   /**
@@ -419,6 +522,22 @@ const Checkout = ({ values, step1, step2, step3, isPartner, t, onStore, onBack }
         const message = (submitError as { response?: { data?: { message?: string } } })?.response?.data?.message;
 
         notifyError(message ?? t('routes_order.checkout.error', { ns: 'common', defaultValue: 'We could not complete your booking. Please try again.' }));
+
+        /*
+         * Claude - 2026-08-29 (audit A3-08c, low)
+         *
+         * REFRESH THE SEAT MAP after a refusal. The commonest reason a
+         * booking is refused at this point is that somebody else took a seat
+         * while this form was open - and the map the buyer is looking at was
+         * fetched before that happened, so it still shows the seat as free
+         * and the button still reads "You have chosen seat 7". Re-asking is
+         * cheap, and it is what makes the effect below able to notice.
+         *
+         * Unconditional rather than gated on reading the message: the reply
+         * is a localised sentence in one of fifteen languages, and a stale
+         * map is worth re-fetching whatever went wrong.
+         */
+        queryClient.invalidateQueries({ queryKey: ['get-bus-occupied'] });
       }
     });
   };
@@ -439,6 +558,10 @@ const Checkout = ({ values, step1, step2, step3, isPartner, t, onStore, onBack }
       <Results>
         <Listing>
           <Passengers
+            /* Claude - 2026-08-29 (audit A3-08c): remounted when a chosen
+               seat turns out to be taken - the only way ChooseSeat, which
+               owns its selection internally, can be told to re-read it. */
+            key={ seatsReset }
             values={ values }
             step1={ step1 }
             fields={ fields }
@@ -508,6 +631,10 @@ const Checkout = ({ values, step1, step2, step3, isPartner, t, onStore, onBack }
           coupon={ coupon }
           total={ payable }
           surcharge={ surcharge > 0 ? `${ surcharge } ${ currency }` : undefined }
+          /* the seller's own cut, taken off what they settle - the same line
+             their invoice carries (audit A4-17), so the two documents for one
+             sale finally state the same number */
+          comission={ comission > 0 ? `${ comission } ${ currency }` : undefined }
           action={ action }
           single={ singleMethod }
           pending={ isPending }
@@ -518,7 +645,9 @@ const Checkout = ({ values, step1, step2, step3, isPartner, t, onStore, onBack }
               selected={ action ?? '' }
               isPartner={ isPartner ?? false }
               routeId={ step2.id }
-              total={ grandTotal.value }
+              /* what the payer OWES, so each button's "+X" matches the
+                 surcharge line under it and the charge itself (audit A4-07) */
+              total={ Math.round((grandTotal.value - comission) * 100) / 100 }
               currency={ currency }
               t={ t }
               onChange={ onAction }

package/Checkout/Sidebar/Sidebar.tsx

@@ -34,6 +34,16 @@ interface Props {
    * what changed when they picked a card.
    */
   surcharge?: string
+  /**
+   * The seller's own commission, already deducted from `total`.
+   *
+   * Claude - 2026-08-29 (audit A4-07): a reseller settles the NET, so the
+   * deduction is stated rather than folded silently into the total - the
+   * same shape their invoice takes, and for the same reason: the body has to
+   * add up to the number their card is charged. Undefined for anybody who
+   * earns no commission, which is every passenger.
+   */
+  comission?: string
   action?: string
   single?: boolean
   pending: boolean
@@ -55,7 +65,7 @@ interface Props {
  * page and scrolled away while add-ons were being ticked - so the number
  * changed out of sight of the person it was changing for.
  */
-const Sidebar = ({ step1, step2, step3, fare, addons, coupon, total, surcharge, action, single, pending, t, onPay, children, payments }: Props): JSX.Element => (
+const Sidebar = ({ step1, step2, step3, fare, addons, coupon, total, surcharge, comission, action, single, pending, t, onPay, children, payments }: Props): JSX.Element => (
   <Container>
     <Panel className="box">
       <SubTitle>
@@ -88,6 +98,14 @@ const Sidebar = ({ step1, step2, step3, fare, addons, coupon, total, surcharge,
 
         { coupon && <Amount type="discount" code={ coupon.code } value={ coupon.discount } t={ t } /> }
 
+        { /* Claude - 2026-08-29 (audit A4-07): above the surcharge, because
+             the surcharge is charged on what is left after it - the lines
+             then read in the order the arithmetic happens. `discount` styling
+             so it reads as money coming OFF, which it is. */ }
+        { comission && (
+          <Amount type="discount" label={ t('routes_order.step5.summary.comission') } value={ comission } t={ t } />
+        ) }
+
         { /* Claude - 2026-08-29: below the discount and above the total,
              because it is the last thing added to what is owed - and it is
              the only line here that appears and disappears as the payment

package/Found/Picks/Picks.tsx

@@ -1,6 +1,6 @@
 import { TFunction } from 'i18next';
 import { Container, Pick, Label, Value, Meta, Company } from './styles';
-import { SortKey, sortItems } from '../refine';
+import { SortKey, sortItems, formatDuration } from '../refine';
 import { FoundData } from '@autobusal/providers/types/routes';
 
 interface Props {
@@ -55,7 +55,13 @@ const Picks = ({ items, sort, t, onSelect }: Props): JSX.Element | null => {
             <Value>{ best.price.display }</Value>
 
             <Meta>
-              { best.duration !== '-' && best.duration }
+              { /* Claude - 2026-08-29 (audit A3-02j, low): the duration
+                   FORMATTED, not the raw "HH:MM" the API sends. On a card
+                   whose other line is a price, "04:30" reads as a departure
+                   time - and the result cards below already went through
+                   exactly this (the 2026-08-01 note in Route.tsx: "the clock
+                   is the point"). Same helper, so the two cannot diverge. */ }
+              { best.duration !== '-' && formatDuration(best.duration, t) }
 
               { /* The operator's name is hidden on a phone - see Company in
                    styles. The separator goes with it, or a card reads

package/Found/Route/Route.tsx

@@ -6,8 +6,9 @@ import { RiBus2Line } from 'react-icons/ri';
 import { MdOutlineAltRoute } from 'react-icons/md';
 import { formatDuration, splitPrice } from '../refine';
 import { Button, RouteFeature, Information, Rating } from '@autobusal/common';
+import { useGetSettings } from '@autobusal/providers/services';
 import { createDate, getDayParts } from '@autobusal/utilities';
-import { Container, ButtonDetails, SpecialOffer, FavoriteStop, Trip, Company, Location, Stop, Iso, Time, Price, Amount, Decimals, Currency, PriceNotice, LinkCompany, CodeCompany, Details, Detail, ButtonPolicy, TitleDetail, FeaturesItems, Leaves, Day, NextDay } from './styles';
+import { Container, ButtonDetails, SpecialOffer, FavoriteStop, Trip, Company, Location, Stop, Iso, Time, Price, Amount, Decimals, Currency, PriceNotice, LinkCompany, CodeCompany, Details, Detail, ButtonPolicy, TitleDetail, FeaturesItems, Leaves, Day, NextDay, Stops, StopsItems, StopRow, StopTime, StopDay, StopBorder } from './styles';
 import { FoundData } from '@autobusal/providers/types/routes';
 
 // neutral placeholder so a missing/broken operator logo doesn't render the
@@ -45,6 +46,21 @@ const Route = ({ data, type, date, passengers, t, onSave, children }: Props): JS
   const customs = Object.values(data.customs).join(', ');
   const transiting = Object.values(data.transiting).join(', ');
 
+  /*
+   * Claude - 2026-08-29 (audit A3-02h, low)
+   *
+   * The itinerary and whether this ticket can be changed - the two things
+   * the details expander was missing. `stops` is absent on an
+   * external-provider offer and on an older obtapi, which is why it is
+   * defaulted rather than assumed; a list of one is a leg with no journey
+   * in it and draws nothing.
+   */
+  const stops = data.stops ?? [];
+
+  const { data: settings } = useGetSettings();
+
+  const flexible = settings.addons?.flex?.available === true;
+
   const price = splitPrice(data.price.display);
 
   const features = data.trip.features_data.map((item, index) => (
@@ -299,6 +315,60 @@ const Route = ({ data, type, date, passengers, t, onSave, children }: Props): JS
             </ButtonPolicy>
           </Detail>
         ) }
+
+        { /* Claude - 2026-08-29 (audit A3-02h, low): WHETHER THE TICKET CAN
+             BE CHANGED, said where the trip is chosen rather than three
+             screens later. Only when the brand actually sells the option -
+             on a brand without it the old deadline model applies and its
+             terms belong to the route's own information document, linked
+             beside this. */ }
+        { !data.external && flexible && (
+          <Detail>
+            <TitleDetail>{ t('routes_order.step2.route.changes.title') }</TitleDetail>
+            { t('routes_order.step2.route.changes.flex') }
+          </Detail>
+        ) }
+
+        { /* Claude - 2026-08-29 (audit A3-02h, low): THE ITINERARY. The card
+             has counted the intermediate stops since August without ever
+             being able to name them - and where a coach calls is one of the
+             few things a traveller actually chooses between when two
+             operators run the same corridor. Last, and full width, because
+             it is the only list here. */ }
+        { stops.length > 1 && (
+          <Stops>
+            <TitleDetail>{ t('routes_order.step2.route.stops.title') }</TitleDetail>
+
+            <StopsItems>
+              { stops.map((stop, index) => {
+                const end = index === 0 || index === stops.length - 1;
+
+                return (
+                  <StopRow key={ index } $end={ end }>
+                    { /* the boarding stop is announced by its DEPARTURE, every
+                         later call by when the coach gets there */ }
+                    <StopTime>{ index === 0 ? stop.departure : stop.arrival }</StopTime>
+
+                    <span>
+                      { stop.city }
+                      { stop.stop ? ` · ${ stop.stop }` : '' }
+                    </span>
+
+                    { stop.day > 0 && (
+                      <StopDay title={ t('routes_order.step2.route.next_day', { count: stop.day }) }>
+                        +{ stop.day }
+                      </StopDay>
+                    ) }
+
+                    { stop.douane && (
+                      <StopBorder>{ t('routes_order.step2.route.stops.border') }</StopBorder>
+                    ) }
+                  </StopRow>
+                );
+              }) }
+            </StopsItems>
+          </Stops>
+        ) }
       </Details>
 
       { information && typeof data.id === 'number' && <Information id={ data.id } t={ t } onClose={ () => setInformation(false) } /> }

package/Found/Route/styles.ts

@@ -560,6 +560,63 @@ export const TitleDetail = styled.h6`
   font-size: ${ props => props.theme.size.xs };
 `;
 
+/**
+ * The itinerary, as a list of calls.
+ *
+ * Claude - 2026-08-29 (audit A3-02h). A full-width detail rather than a
+ * column beside the others: it is the one item here that is a LIST, and
+ * squeezed into a third of the row every stop wrapped onto two lines.
+ */
+export const Stops = styled(Detail)`
+  @media (min-width: 480px) {
+    flex-basis: 100%;
+  }
+  @media (min-width: 768px) {
+    flex: 1 1 100%;
+  }
+`;
+
+export const StopsItems = styled.ol`
+  display: flex;
+  flex-direction: column;
+  gap: 3px;
+  margin: 0;
+  padding: 0;
+  list-style: none;
+`;
+
+export const StopRow = styled.li<{ $end: boolean }>`
+  display: flex;
+  align-items: baseline;
+  gap: 6px;
+  font-weight: ${ props => (props.$end ? 700 : 400) };
+`;
+
+/**
+ * The clock time, in a fixed column so the stop names line up under one
+ * another however long the times are.
+ */
+export const StopTime = styled.span`
+  flex: 0 0 auto;
+  min-width: 42px;
+  color: ${ props => props.theme.font.faded };
+  font-variant-numeric: tabular-nums;
+`;
+
+/**
+ * "+1" against a stop the coach reaches after midnight - the same marker the
+ * arrival on the card above carries, for the same reason.
+ */
+export const StopDay = styled.span`
+  color: ${ props => props.theme.font.warning };
+  font-size: ${ props => props.theme.size.xs };
+`;
+
+export const StopBorder = styled.span`
+  color: ${ props => props.theme.font.info };
+  font-size: ${ props => props.theme.size.xs };
+`;
+
 export const ButtonPolicy = styled.button`
   display: flex;
   align-items: center;

package/RoutesOrder.tsx

@@ -1,5 +1,5 @@
 import { useState, useEffect, useMemo } from 'react';
-import { useParams, useSearchParams } from 'react-router-dom';
+import { useParams, useSearchParams, useNavigate, useLocation } from 'react-router-dom';
 import { TFunction } from 'i18next';
 import { AiOutlineSearch, AiOutlineCaretDown, AiOutlineCaretUp } from 'react-icons/ai';
 import { Meta } from '@autobusal/common';
@@ -89,6 +89,27 @@ const RoutesOrder = ({ t }: Props): JSX.Element => {
    */
   const [ searchParams, setSearchParams ] = useSearchParams();
 
+  const navigate = useNavigate();
+
+  const location = useLocation();
+
+  /*
+   * Claude - 2026-08-29 (audit A3-02f)
+   *
+   * Where this wizard's own URLs start, taken from the path in hand rather
+   * than hardcoded - so whatever locale prefix is in front of /bus-lines
+   * survives being written back. Null when the segment is not there at all,
+   * which is the honest answer for a mounting that carries no search spec in
+   * its URL, and makes syncUrl a no-op rather than a wrong guess.
+   */
+  const base = (() => {
+    const segments = location.pathname.split('/');
+
+    const at = segments.indexOf('bus-lines');
+
+    return at === -1 ? null : segments.slice(0, at + 1).join('/');
+  })();
+
   const step = searchParams.get('step');
 
   const current = (() => {
@@ -173,18 +194,95 @@ const RoutesOrder = ({ t }: Props): JSX.Element => {
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [urlKey]);
 
+  /**
+   * Write a search spec into the address bar, and adopt exactly what that
+   * URL would be read back as.
+   *
+   * Claude - 2026-08-29 (audit A3-02f, medium)
+   *
+   * THE DATE STRIP CHANGED THE RESULTS AND NOT THE URL. Clicking a day on
+   * the strip swapped the listing underneath while the address bar still
+   * named the day the visitor arrived on - so a refresh silently threw the
+   * chosen day away, and a shared or bookmarked link took the reader to a
+   * different date than the one on the screen it was copied from. The same
+   * was true of the collapsed search-again panel, which can change cities
+   * and passenger counts as well as dates.
+   *
+   * `prepare` is run over the params being written, and its answer - not the
+   * caller's spec - is what goes into state. That is what keeps the two from
+   * drifting: a one-way's return slot is normalised to "none" in the URL and
+   * back to the departure date in state, and if state kept the caller's
+   * value instead, the effect below would see a URL describing a different
+   * search and helpfully throw away the chosen coach.
+   *
+   * Replace, not push. Stepping through days is browsing one screen, not
+   * walking a trail - a strip of seven days should not cost seven presses of
+   * Back to leave the page.
+   */
+  const syncUrl = (spec: RoutesSearchForm, dropStep = false): RoutesSearchForm => {
+    // No /bus-lines in the path means this wizard is mounted somewhere that
+    // does not carry a search spec in its URL, and there is nothing to write.
+    if (base === null) {
+      if (dropStep) {
+        goto(null, true);
+      }
+
+      return spec;
+    }
+
+    const query = new URLSearchParams(searchParams);
+
+    /*
+     * The step is KEPT unless the caller says otherwise. Changing the return
+     * date happens ON the return step, and deleting `step=return` here would
+     * have answered a date change by throwing the buyer back to the outbound
+     * results.
+     */
+    if (dropStep) {
+      query.delete('step');
+    }
+
+    // the chosen stations travel in the query, and prepare reads them from
+    // there - so they have to be written before it runs
+    for (const [key, value] of [['sfrom', spec.stop_from], ['sto', spec.stop_to]] as const) {
+      if (value) {
+        query.set(key, String(value));
+      } else {
+        query.delete(key);
+      }
+    }
+
+    const written = {
+      from: spec.from,
+      to: spec.to,
+      departure: spec.departure.replace(/\//g, '-'),
+      // `_return` is optional on the form type, and "none" is the literal a
+      // one-way URL carries - so an absent one is a one-way, not a blank slot
+      _return: spec.type === 'return' && spec._return ? spec._return.replace(/\//g, '-') : 'none',
+      type: spec.type,
+      adults: String(spec.adults),
+      children: String(spec.children),
+      babies: String(spec.babies)
+    };
+
+    const path = `${ base }/${ written.from }/${ written.to }/${ written.departure }/${ written._return }/${ written.type }/${ written.adults }/${ written.children }/${ written.babies }`;
+
+    const search = query.toString();
+
+    navigate(search ? `${ path }?${ search }` : path, { replace: true });
+
+    return prepare(undefined, written, query, settings.preferences.defaultLocations);
+  };
+
   const onSearchDate = (type: ('departure' | '_return'), day: string): void => {
     if (step1 !== undefined) {
-      setStep1({
-        ...step1,
-        [type]: day
-      });
+      setStep1(syncUrl({ ...step1, [type]: day }));
     }
   };
 
   const onStep1 = (data: RoutesSearchForm): void => {
-    setStep1(data);
-    goto(null, true);
+    // a new search lands on the results, so the step goes with the old one
+    setStep1(syncUrl(data, true));
 
     // we mark it as redirected
     setRedirected(true);

package/Step1/prepare.ts

@@ -12,8 +12,6 @@ const prepare = (
     return value;
   }
 
-  const type = params.type === 'return' ? 'return' : 'departure';
-
   const from = params.from ?? defaultLocations.from;
   /*
    * Edited: Claude - Date: 2026-08-29
@@ -44,10 +42,32 @@ const prepare = (
    */
   const requested = params._return?.replace(/-/g, '/');
 
-  const _return = isPreparedDate(requested)
+  const hasReturn = isPreparedDate(requested);
+
+  const _return = hasReturn
     ? String(requested)
     : (isPreparedDate(departure) ? departure : futureDate(2));
 
+  /*
+   * Claude - 2026-08-29 (audit A3-07c, medium)
+   *
+   * A RETURN DATE IN THE URL MEANS A ROUND TRIP, whatever the type segment
+   * says. The two are independent slots on the 9-segment route and they can
+   * contradict each other - .../12-10-2026/19-10-2026/departure/... names a
+   * return date and then declares the trip one-way. That URL used to sell a
+   * ONE-WAY silently: the visitor saw their outbound date honoured, their
+   * return date apparently accepted, no return leg offered anywhere, and a
+   * single ticket at the end of it.
+   *
+   * A one-way URL carries the literal "none" in that slot (see below), so
+   * "not a date" is how one-way is really expressed and nothing that means
+   * one-way is affected. Resolving towards the round trip rather than
+   * dropping the date is the safe direction: the buyer who typed or shared
+   * two dates gets the trip they described and can still switch back in the
+   * form, where dropping it would quietly sell them half a journey.
+   */
+  const type = params.type === 'return' || hasReturn ? 'return' : 'departure';
+
   const adults = params.adults ?? 1;
   const children = params.children ?? 0;
   const babies = params.babies ?? 0;

package/Step5/Coupons/Coupons.tsx

@@ -1,8 +1,9 @@
+import { useState } from 'react';
 import { TFunction } from 'i18next';
 import { useForm } from 'react-hook-form';
 import { RiCoupon3Line } from 'react-icons/ri';
 import { Validate, Display } from '@autobusal/utilities';
-import { Container, ContainerForm, ContainerInput, Apply } from './styles';
+import { Container, ContainerForm, ContainerInput, Apply, Message } from './styles';
 import { CouponData } from '@autobusal/providers/types/orders';
 import { FoundData } from '@autobusal/providers/types/routes';
 import { TotalData, CouponForm } from '../../types';
@@ -26,7 +27,25 @@ const Coupons = ({ current, step2, t, total, onApplied }: Props): (JSX.Element |
   // onSave, so a real local numeric id is guaranteed here.
   const { mutate: SearchCoupons, isPending } = useGetCoupon(step2.id as number, total.value);
 
+  /*
+   * Claude - 2026-08-29 (audit A3-10c, medium)
+   *
+   * A CODE THAT DOES NOT WORK NOW SAYS SO.
+   *
+   * There were two silences here, and the second was total. A code the
+   * server recognised but refused (expired, spent, not for this route) got
+   * an `alert()`, which some browsers suppress and none of them place next
+   * to the field. A code that does not exist at all never reached this
+   * handler: the request 4xx's, `onSuccess` does not run, and there was no
+   * `onError` - so the commonest case of all, a typo, cleared the spinner
+   * and changed nothing on screen. A buyer cannot tell that from a coupon
+   * that silently applied, and the total beside it does not move either way.
+   */
+  const [ message, setMessage ] = useState<{ text: string, error: boolean } | null>(null);
+
   const onSubmit = (data: CouponForm): void => {
+    setMessage(null);
+
     SearchCoupons(data, {
       onSuccess: (data) => {
         if (data.used) {
@@ -35,7 +54,10 @@ const Coupons = ({ current, step2, t, total, onApplied }: Props): (JSX.Element |
           return;
         }
 
-        alert(t('routes_order.step5.coupon.error'));
+        setMessage({ text: t('routes_order.step5.coupon.error'), error: true });
+      },
+      onError: () => {
+        setMessage({ text: t('routes_order.step5.coupon.error'), error: true });
       }
     });
   };
@@ -77,6 +99,12 @@ const Coupons = ({ current, step2, t, total, onApplied }: Props): (JSX.Element |
           </ContainerInput>
 
           { Display(errors.code) }
+
+          { message && (
+            <Message $error={ message.error } role="status" aria-live="polite">
+              { message.text }
+            </Message>
+          ) }
         </ContainerForm>
       </form>
     </Container>

package/Step5/Coupons/styles.ts

@@ -26,6 +26,20 @@ export const ContainerInput = styled.div`
   }
 `;
 
+/**
+ * What happened to the code that was just typed.
+ *
+ * Claude - 2026-08-29 (audit A3-10c, medium). Inline, directly under the
+ * field, which is where this form's own validation message already appears -
+ * a buyer who mistypes a code is looking at the box, not anywhere else. Two
+ * colours because "applied" is the answer this form exists to give and it
+ * should not look like a failure.
+ */
+export const Message = styled.div<{ $error?: boolean }>`
+  font-size: ${ props => props.theme.size.s };
+  color: ${ props => (props.$error ? props.theme.font.error : props.theme.font.success) };
+`;
+
 export const Apply = styled.button`
   position: absolute;
   top: 50%;

package/Step5/Payments/Payments.tsx

@@ -14,11 +14,17 @@ interface Props {
   isPartner: boolean
   routeId?: number | string
   /**
-   * The checkout total the surcharge is drawn against, and its currency.
+   * What the payer OWES - the base the surcharge is drawn against - and its
+   * currency.
    *
    * Claude - 2026-08-29 (ruling by Ferjolt): each card button says what it
    * adds, so the cost of choosing a card is visible BEFORE it is chosen -
    * the summary line can only ever explain the method already picked.
+   *
+   * Claude - 2026-08-29 (audit A4-07): the OWED figure, not the basket. A
+   * reseller settles the fare minus their own commission and is surcharged on
+   * that, so passing the gross made every button quote a fee larger than the
+   * one the summary directly underneath it - and the bank - would charge.
    */
   total?: number
   currency?: string

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autobusal/routes-order",
-  "version": "1.34.3",
+  "version": "1.34.4",
   "author": "Ferjolt Ozuni",
   "type": "module",
   "main": "index.ts"

package/services.ts

@@ -292,6 +292,61 @@ export const useGetPayments = (routeId?: number | string): UseQueryResult<Action
   })
 );
 
+/**
+ * What commission the signed-in seller earns on this booking - and so what
+ * they, rather than a passenger, actually owe for it.
+ *
+ * Claude - 2026-08-29 (audit A4-07, medium)
+ *
+ * A reseller pays the fare MINUS their own commission (obtapi Payments\Owed)
+ * and the card surcharge is charged on that net. The checkout knew none of
+ * it: it computed the surcharge on the gross basket and printed a total to
+ * match, so an agent was shown 67.05 and the bank then asked for 60.67.
+ * Neither number on screen before "Make Payment" was the one that would be
+ * charged.
+ *
+ * POST, because this endpoint already exists in exactly this shape for the
+ * mobile checkout and takes the same search inputs order creation does - so a
+ * round trip is quoted as a PAIR and the commission is computed on the
+ * same-operator fare rather than on two one-ways added together.
+ *
+ * Enabled for seller types only: nobody else earns anything, the endpoint
+ * short-circuits them to zero, and a guest checkout should not spend a
+ * request being told so.
+ */
+export const useGetComission = (
+  enabled: boolean,
+  departure: string,
+  departurePriceId: (number | string),
+  adults: number,
+  children: number,
+  babies: number,
+  _return?: string,
+  returnPriceId?: (number | string)
+): UseQueryResult<{ comission_agent: number }> => (
+  useQuery({
+    queryKey: ['quote-comission', { departure, departurePriceId, adults, children, babies, _return, returnPriceId }],
+    // a synthetic external-provider price id can never be quoted locally
+    enabled: enabled && typeof departurePriceId === 'number',
+    queryFn: async () => (
+      await apiClient
+        // no fromId/toId: the endpoint derives the cities from the departure
+        // price row, the way order creation does (Orders\Make\Prepare)
+        .post('/api/orders/quote/departure', {
+          departure,
+          adults,
+          children,
+          babies,
+          departure_price_id: departurePriceId,
+          ...(_return !== undefined && typeof returnPriceId === 'number'
+            ? { _return, return_price_id: returnPriceId }
+            : {})
+        })
+        .then(response => response.data)
+    )
+  })
+);
+
 /**
  * The Flexible Ticket offer for the routes actually chosen.
  *