@autobusal/routes-order 1.32.0 → 1.33.0

package/CHANGELOG.md

@@ -1,5 +1,31 @@
 # Changelog
 
+## 1.33.0
+
+### Added
+
+- **The pair page is a page about the journey, not just a search box over it.** `/routes/search/facts` now carries how often the pair is served (the union of days a traveller can leave on, plus departures per week), how many of the scheduled services run non-stop, how many travel overnight, the cities in between, what is on board, the two countries, and the dearest fare alongside the cheapest - all read off the timetable, all riding the existing 6h cache, none of it estimated.
+- Every list-shaped fact carries an `every` flag beside it, and the copy is chosen from that flag. Six of the ten Tirana-Thessaloniki coaches are non-stop and they carry different equipment, so "every bus calls at Korca" and "some buses also call at Korca" are different claims; obtapi says which one the data supports rather than leaving the wording to guess.
+- **A visible FAQ** (`Faq/`), built from `Facts/questions` - the same array the `FAQPage` structured data is emitted from, so the answer Google quotes is the string the page renders, character for character, in all fifteen languages. Native `<details>`, no state: the answer is in the DOM whether it is open or shut, which is what a prerendered snapshot and a crawler that does not click both need. Questions with no data behind them are not asked.
+- **`BusTrip` gained an `itinerary`** - but only where every service on the pair calls at every stop listed. An itinerary is a statement about *the* trip, and on a pair where most coaches run non-stop there is no single itinerary to state. Departure and arrival stops carry a `PostalAddress` where obtapi knows the country.
+- **A "travelling back?" link**, from the new `links.reverse`. Pairs are directional, so the return leg is a different page with its own timetable - and it belonged to neither "popular from" nor "popular to", being a pair from the destination back to the origin. Null, and absent, when nobody sells it.
+
+### Fixed
+
+- **"3h 0m" in the facts grid, "3h" in the answer below it.** The facts block carried its own copy of the duration formatter without the whole-hour rule the FAQ answers use, so a three-hour coach was described two ways on one page. One exported formatter now.
+- **The departure count called itself the wrong thing.** `facts.departures` counts the distinct coaches in the timetable, and a single daily one of them makes seven departures a week - so "10 scheduled departures" beside the new "every day, 70 scheduled departures a week" read as a contradiction rather than as two facts. The label and the FAQ answer now say *scheduled services* in all fifteen languages; the number they print is unchanged.
+- **"There are 1 scheduled departures"** - the sentence a thin pair got from the FAQ schema for as long as the block has existed, and a thin pair is most of them. A separate key rather than an i18next plural rule; the plural categories of the eight Slavic locales here are not something one English-shaped rule gets right.
+
+## 1.32.1
+
+### Added
+
+- **A saved-passenger chooser and a "remember this passenger" checkbox**, per passenger rather than per order, because "remember me but not the person I am buying for" is the ordinary case and one control per booking cannot say it. The list is fetched once for the whole checkout, not once per traveller.
+
+  Picking applies the whole person, not the filled parts: a passport left from a previous choice is cleared, because the customer has said who is sitting in that seat. Only fields the route actually collects are written - react-hook-form submits values set for names it never registered, so writing the rest would post a WhatsApp number to a route that never asked for one.
+
+  A journey that needs a field the saved profile lacks says so in the form's own words. `missing` absent means *not measured* and is not treated as "nothing missing".
+
 ## 1.32.0
 
 ### Added

package/Checkout/Checkout.tsx

@@ -24,7 +24,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 } from '../services';
+import { usePostOrder, useGetFlex, useGetPayments, useGetSavedPassengers } from '../services';
 import { addon as commerceAddon, beginCheckout, stash } from '@autobusal/providers/Setup/commerce';
 import { item as commerceItem } from '../commerce';
 
@@ -125,6 +125,38 @@ const Checkout = ({ values, step1, step2, step3, isPartner, t, onStore, onBack }
     step1.babies ?? 0
   );
 
+  /**
+   * "Book somebody you have booked before" - saved passengers.
+   *
+   * Edited: Claude - Date: 2026-08-20
+   *
+   * Fetched ONCE here and drilled down rather than asked for inside each
+   * passenger block: a family of five would otherwise be five requests for
+   * one list, and the list is the same list.
+   *
+   * ONLY FOR A SIGNED-IN CUSTOMER. The endpoint is `role:visitor`, so a
+   * guest and a member of staff both get a 404 - a deliberate refusal that
+   * confirms nothing (see obtapi's Account\PassengersController). Deciding
+   * that here, from a fact the app already knows, means the request is never
+   * made for them and there is no failed query on a checkout screen to
+   * accidentally surface.
+   *
+   * The price ids go with it so every row comes back saying what THIS
+   * journey would still have to ask for - see the chooser.
+   */
+  const isCustomer = UserData?.type === 'visitor';
+
+  const { data: SavedData } = useGetSavedPassengers(
+    step2.price.id as number,
+    step3?.price.id as (number | undefined),
+    isCustomer
+  );
+
+  // undefined until the list has landed, which is also what a guest gets and
+  // is exactly the right answer for both: nothing about the feature renders
+  // until there is an account behind it with an answer
+  const saved = isCustomer ? (SavedData?.data ?? []) : undefined;
+
   const addonItems = [
     addonWhatsapp && SettingsData?.addons?.whatsapp.available ? {
       label: t('routes_order.step5.addons.whatsapp.label'),
@@ -280,6 +312,8 @@ const Checkout = ({ values, step1, step2, step3, isPartner, t, onStore, onBack }
             fields={ fields }
             busFrom={ busFrom }
             busTo={ busTo }
+            saved={ saved }
+            savedMax={ SavedData?.max }
             t={ t }
             errors={ passenger.formState.errors }
             refs={ passenger.register }

package/Facts/Facts.tsx

@@ -1,6 +1,7 @@
 import { TFunction } from 'i18next';
-import { Container, Grid, Fact, Label, Value, Note, Operators } from './styles';
+import { Container, Grid, Fact, Label, Value, Note, Operators, Prose } from './styles';
 import { FactsData } from './types';
+import { DAYS, duration } from './questions';
 
 interface Props {
   id: string
@@ -29,21 +30,55 @@ interface Props {
  * Renders nothing at all when the API has no facts for the pair. An empty
  * facts block is worse than none - it is exactly the thin content this tier
  * exists to remove.
+ *
+ * Edited: Claude - Date: 2026-08-20
+ *
+ * It now also answers "what is this journey LIKE", which is the half a
+ * grid of numbers cannot: how often it runs, how many of the coaches are
+ * non-stop, how many travel overnight, where they call, what is on board,
+ * and whether it crosses a border. Sentences rather than more tiles,
+ * because that is the half a reader takes away and a machine can quote.
+ *
+ * The same restraint applies to all of it: a sentence whose data is
+ * missing is not printed, and one whose data supports only a weaker claim
+ * is printed in the weaker wording. A pair with one weekly coach ends up
+ * with a short honest block, not a padded one.
  */
 const Facts = ({ id, facts, t }: Props): JSX.Element => {
-  // "07:30" built from a duration in minutes reads as a time of day, so the
-  // hours and minutes are spelled out instead.
-  const duration = (minutes: number): string => (
-    t('routes_order.facts.duration_value', {
-      hours: Math.floor(minutes / 60),
-      minutes: minutes % 60
-    })
-  );
+  /**
+   * Edited: Claude - Date: 2026-08-20
+   *
+   * Whether this coach leaves the country, which is the first thing a
+   * traveller wants settled and the one fact here that is not about the
+   * timetable at all - it is about the two cities. Silent when either
+   * country is unknown rather than assuming the pair is domestic, and
+   * silent on the wording of what a border crossing REQUIRES: entry rules
+   * are the traveller's own and this page has no business inventing them.
+   */
+  const countries = (() => {
+    if (!facts.from_country || !facts.to_country) {
+      return null;
+    }
+
+    return facts.from_country === facts.to_country
+      ? <p>{ t('routes_order.facts.domestic', { country: facts.from_country }) }</p>
+      : <p>{ t('routes_order.facts.international', { from_country: facts.from_country, to_country: facts.to_country }) }</p>;
+  })();
+
+  const via = facts.via && facts.via.cities.length > 0 ? facts.via : null;
+
+  const amenities = facts.amenities && facts.amenities.names.length > 0 ? facts.amenities : null;
+
+  // Edited: Claude - Date: 2026-08-20
+  // A thin pair can have none of the four sentences below, and an empty
+  // <Prose> is still a box with a top margin - a gap under the grid that
+  // reads as something failing to load.
+  const prose = Boolean(countries || via || amenities || facts.operators.length > 0);
 
   const range = facts.duration_min !== null && facts.duration_max !== null
     ? (facts.duration_min === facts.duration_max
-        ? duration(facts.duration_min)
-        : `${ duration(facts.duration_min) } – ${ duration(facts.duration_max) }`)
+        ? duration(facts.duration_min, t)
+        : `${ duration(facts.duration_min, t) } – ${ duration(facts.duration_max, t) }`)
     : null;
 
   return (
@@ -84,6 +119,51 @@ const Facts = ({ id, facts, t }: Props): JSX.Element => {
           <Value>{ facts.departures }</Value>
         </Fact>
 
+        { /* Edited: Claude - Date: 2026-08-20
+             HOW OFTEN, which the departure count above cannot say - ten
+             services means something very different once a week than it
+             does every day. Absent entirely when no coach on the pair has a
+             usable timetable row, including the case that matters: a season
+             that has already ended. Saying nothing there is the honest
+             answer; "runs 3 times a week" about a coach that stopped
+             running last September is not. */ }
+        { facts.frequency && (
+          <Fact>
+            <Label>{ t('routes_order.facts.frequency') }</Label>
+
+            <Value>
+              { facts.frequency.daily
+                ? t('routes_order.facts.frequency_daily')
+                : facts.frequency.days.map(day => t(`data.days.${ DAYS[day] }`)).join(', ') }
+
+              <Note>
+                { facts.frequency.weekly === 1
+                  ? t('routes_order.facts.frequency_weekly_single')
+                  : t('routes_order.facts.frequency_weekly', { count: facts.frequency.weekly }) }
+              </Note>
+            </Value>
+          </Fact>
+        ) }
+
+        { /* Edited: Claude - Date: 2026-08-20
+             Counted out of the total rather than shown as a yes/no. "Direct
+             service: yes" on a pair where one coach in ten is direct is
+             true and useless; "1 of 10" is what a reader needs to know
+             before they start comparing departures. */ }
+        { facts.direct > 0 && (
+          <Fact>
+            <Label>{ t('routes_order.facts.direct') }</Label>
+            <Value>{ t('routes_order.facts.of_total', { count: facts.direct, total: facts.departures }) }</Value>
+          </Fact>
+        ) }
+
+        { facts.overnight > 0 && (
+          <Fact>
+            <Label>{ t('routes_order.facts.overnight') }</Label>
+            <Value>{ t('routes_order.facts.of_total', { count: facts.overnight, total: facts.departures }) }</Value>
+          </Fact>
+        ) }
+
         { facts.distance && (
           <Fact>
             <Label>{ t('routes_order.facts.distance') }</Label>
@@ -107,10 +187,45 @@ const Facts = ({ id, facts, t }: Props): JSX.Element => {
         ) }
       </Grid>
 
-      { facts.operators.length > 0 && (
-        <Operators>
-          { t('routes_order.facts.operators', { operators: facts.operators.join(', ') }) }
-        </Operators>
+      { /* Edited: Claude - Date: 2026-08-20
+           The part somebody reads rather than scans. Four sentences at most,
+           each one printed only when the data behind it exists, and none of
+           them a generality - a pair served by one weekly coach gets one
+           sentence and it is true, which is a better page than four
+           sentences of hedging.
+
+           EVERY/SOME IS THE WHOLE CARE HERE. Buses on one route are not
+           interchangeable: six of the ten Tirana-Thessaloniki coaches run
+           non-stop and they carry different equipment. "Every bus calls at
+           Korca" and "some buses also call at Korca" are different claims
+           and obtapi says which one the data supports, so the copy never
+           has to guess. */ }
+      { prose && (
+        <Prose>
+          { countries }
+
+          { via && (
+            <p>
+              { t(via.every ? 'routes_order.facts.via_every' : 'routes_order.facts.via_some', {
+                cities: via.cities.join(', ')
+              }) }
+            </p>
+          ) }
+
+          { amenities && (
+            <p>
+              { t(amenities.every ? 'routes_order.facts.amenities_every' : 'routes_order.facts.amenities_some', {
+                amenities: amenities.names.join(', ')
+              }) }
+            </p>
+          ) }
+
+          { facts.operators.length > 0 && (
+            <Operators>
+              { t('routes_order.facts.operators', { operators: facts.operators.join(', ') }) }
+            </Operators>
+          ) }
+        </Prose>
       ) }
     </Container>
   );

package/Facts/questions.ts

@@ -0,0 +1,215 @@
+import { TFunction } from 'i18next';
+import { FactsData } from './types';
+
+export interface Question {
+  // stable enough to key a list on, and never rendered
+  id: string
+  q: string
+  a: string
+}
+
+/**
+ * ISO weekday to the short day names the rest of the site already ships in
+ * all fifteen languages (`data.days.*`) - "Mon, Wed, Fri" rather than a new
+ * set of long names nobody would have translated for a week.
+ */
+export const DAYS: Record<number, string> = {
+  1: 'mon', 2: 'tue', 3: 'wed', 4: 'thu', 5: 'fri', 6: 'sat', 7: 'sun'
+};
+
+/**
+ * The questions a pair page answers, and their answers.
+ *
+ * Edited: Claude - Date: 2026-08-20
+ *
+ * ONE BUILDER, TWO CONSUMERS, AND THAT IS THE ENTIRE POINT. The FAQPage
+ * structured data and the FAQ a human reads are built from this same array,
+ * so the schema's `acceptedAnswer` is the identical string the page renders
+ * a few hundred pixels away - character for character, in whatever language
+ * the reader is in. Google requires that match and pulls a site's rich
+ * results when it fails; two lists of hand-written questions kept in step by
+ * good intentions is exactly how it fails, six months later, in one locale
+ * nobody re-read.
+ *
+ * EVERY ANSWER IS A FACT obtapi COMPUTED, never an estimate and never a
+ * generality. A question whose data is missing is not asked: no "typically
+ * around 6 hours", no "usually several a day". A pair served by one coach a
+ * week gets four questions and they are all true, which is a better page
+ * than eight questions padded with hedges.
+ *
+ * Ordered by how often the question is actually typed - how long, how much,
+ * how often - rather than by how the payload happens to be shaped.
+ */
+/**
+ * A journey length, in words.
+ *
+ * Edited: Claude - Date: 2026-08-20
+ *
+ * "07:30" built from a duration in minutes reads as a time of day, so the
+ * hours and minutes are spelled out - and a whole number of hours drops the
+ * "0m" rather than printing it.
+ *
+ * Exported because the facts block prints the same number a few hundred
+ * pixels from the FAQ answer that quotes it, and it had its own copy of
+ * this without the whole-hour rule: a three-hour coach read "3h 0m" in the
+ * grid and "3h" in the answer directly below it, on the same page, about
+ * the same bus.
+ */
+export const duration = (minutes: number, t: TFunction<'common'>): string => (
+  minutes % 60 === 0
+    ? t('routes_order.facts.duration_hours', { hours: minutes / 60 })
+    : t('routes_order.facts.duration_value', { hours: Math.floor(minutes / 60), minutes: minutes % 60 })
+);
+
+const questions = (facts: FactsData, t: TFunction<'common'>): Question[] => {
+  const all: Question[] = [];
+
+  const cities = { from: facts.from, to: facts.to };
+
+  if (facts.duration_min !== null && facts.duration_max !== null) {
+    all.push({
+      id: 'duration',
+      q: t('routes_order.schema.duration_q', cities),
+      a: facts.duration_min === facts.duration_max
+        ? t('routes_order.schema.duration_a', { ...cities, duration: duration(facts.duration_min, t) })
+        : t('routes_order.schema.duration_a_range', { ...cities, min: duration(facts.duration_min, t), max: duration(facts.duration_max, t) })
+    });
+  }
+
+  if (facts.price_from_display) {
+    all.push({
+      id: 'price',
+      q: t('routes_order.schema.price_q', cities),
+
+      // A range only where there is one. On a pair whose services all cost
+      // the same, "from 15.00 EUR to 15.00 EUR" is a sentence that makes a
+      // reader distrust the rest of the page.
+      a: facts.price_to_display && facts.price_to !== facts.price_from
+        ? t('routes_order.schema.price_a_range', { ...cities, low: facts.price_from_display, high: facts.price_to_display })
+        : t('routes_order.schema.price_a', { ...cities, price: facts.price_from_display })
+    });
+  }
+
+  if (facts.frequency) {
+    const days = facts.frequency.days.map(day => t(`data.days.${ DAYS[day] }`)).join(', ');
+
+    all.push({
+      id: 'frequency',
+      q: t('routes_order.schema.frequency_q', cities),
+      a: facts.frequency.daily
+        ? t('routes_order.schema.frequency_a_daily', { ...cities, count: facts.frequency.weekly })
+        : (facts.frequency.weekly === 1
+            ? t('routes_order.schema.frequency_a_single', { ...cities, days })
+            : t('routes_order.schema.frequency_a', { ...cities, days, count: facts.frequency.weekly }))
+    });
+  }
+
+  if (facts.departures > 0) {
+    all.push({
+      id: 'departures',
+      q: t('routes_order.schema.departures_q', cities),
+
+      // SERVICES, not departures. `facts.departures` counts the distinct
+      // coaches in the timetable, and a single daily one of them makes
+      // seven departures a week - so beside the frequency answer above,
+      // the old wording ("10 scheduled departures" next to "70 a week")
+      // read as a contradiction rather than as two facts. Both strings
+      // were reworded; the number they print never changed.
+      //
+      // And "There are 1 scheduled departures" was the sentence a thin
+      // pair got for as long as this block has existed - a thin pair being
+      // most of them. A separate key rather than an i18next plural: the
+      // plural categories of the eight Slavic locales here are not
+      // something a single English-shaped rule gets right.
+      a: facts.departures === 1
+        ? t('routes_order.schema.departures_a_single', cities)
+        : t('routes_order.schema.departures_a', { ...cities, count: facts.departures })
+    });
+  }
+
+  if (facts.departure_first && facts.departure_last) {
+    all.push({
+      id: 'times',
+      q: t('routes_order.schema.times_q', cities),
+      a: t('routes_order.schema.times_a', { first: facts.departure_first, last: facts.departure_last })
+    });
+  }
+
+  // Asked only where the answer is a real count. `direct` is meaningless
+  // without a total to read it against, and `departures` is that total.
+  if (facts.departures > 0) {
+    all.push({
+      id: 'direct',
+      q: t('routes_order.schema.direct_q', cities),
+      a: facts.direct === 0
+        ? t('routes_order.schema.direct_a_none', cities)
+        : (facts.direct === facts.departures
+            ? t('routes_order.schema.direct_a_all', cities)
+            : t('routes_order.schema.direct_a', { ...cities, count: facts.direct, total: facts.departures }))
+    });
+  }
+
+  // Only when there IS a night service. "No, none of these run overnight" is
+  // a question asked to be answered no, which is padding.
+  if (facts.overnight > 0) {
+    all.push({
+      id: 'overnight',
+      q: t('routes_order.schema.overnight_q', cities),
+      a: facts.overnight === facts.departures
+        ? t('routes_order.schema.overnight_a_all', cities)
+        : t('routes_order.schema.overnight_a', { ...cities, count: facts.overnight, total: facts.departures })
+    });
+  }
+
+  if (facts.via && facts.via.cities.length > 0) {
+    all.push({
+      id: 'via',
+      q: t('routes_order.schema.via_q', cities),
+
+      // The same sentence the facts block shows, deliberately - it is the
+      // one wording that distinguishes "every coach calls here" from "one of
+      // them does", and the answer must not be a looser paraphrase of it.
+      a: t(facts.via.every ? 'routes_order.facts.via_every' : 'routes_order.facts.via_some', {
+        cities: facts.via.cities.join(', ')
+      })
+    });
+  }
+
+  if (facts.amenities && facts.amenities.names.length > 0) {
+    all.push({
+      id: 'amenities',
+      q: t('routes_order.schema.amenities_q', cities),
+      a: t(facts.amenities.every ? 'routes_order.facts.amenities_every' : 'routes_order.facts.amenities_some', {
+        amenities: facts.amenities.names.join(', ')
+      })
+    });
+  }
+
+  if (facts.operators.length > 0) {
+    all.push({
+      id: 'operators',
+      q: t('routes_order.schema.operators_q', cities),
+      a: t('routes_order.facts.operators', { operators: facts.operators.join(', ') })
+    });
+  }
+
+  if (facts.distance) {
+    all.push({
+      id: 'distance',
+      q: t('routes_order.schema.distance_q', cities),
+
+      // The approximation gets its own sentence rather than the same one
+      // with a hedge bolted on. It is a sum of straight lines and it is
+      // ALWAYS short - 309 km against 412 km of tarmac on
+      // Tirana-Thessaloniki - so an answer that called it the road distance
+      // "approximately" would be wrong by a quarter on every pair.
+      a: facts.distance.road !== null
+        ? t('routes_order.schema.distance_a', { ...cities, km: facts.distance.road })
+        : t('routes_order.schema.distance_a_approx', { ...cities, km: facts.distance.approx })
+    });
+  }
+
+  return all;
+};
+
+export default questions;

package/Facts/styles.ts

@@ -46,3 +46,29 @@ export const Operators = styled.p`
   font-size: ${ props => props.theme.size.s };
   line-height: 1.5;
 `;
+
+/**
+ * The readable half of the facts block.
+ *
+ * Edited: Claude - Date: 2026-08-20
+ *
+ * The grid above answers "what are the numbers"; this answers "what is this
+ * journey like" in sentences, which is what a search engine quotes and what
+ * a reader actually takes away. Sized as body copy rather than as the faded
+ * footnote the operators line used to be on its own - it is content now, not
+ * an attribution.
+ */
+export const Prose = styled.div`
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+  margin-top: 20px;
+
+  /* One rule for the spacing, so the paragraphs below - which include the
+     operators line and its own older margin - cannot each have an opinion
+     about the gap between them. */
+  p {
+    margin: 0;
+    line-height: 1.6;
+  }
+`;

package/Facts/types.ts

@@ -1,11 +1,37 @@
+/**
+ * Edited: Claude - Date: 2026-08-20
+ *
+ * A list of things that are true of the pair, plus whether they are true of
+ * EVERY service on it. Buses on one route are not interchangeable - six of
+ * the ten Tirana-Thessaloniki coaches are non-stop and they carry different
+ * equipment - so "the bus has Wi-Fi" and "one of these buses has Wi-Fi" are
+ * different claims and the copy has to be able to tell them apart.
+ */
+export interface FactsList {
+  every: boolean
+}
+
 export interface FactsData {
   from: string
   to: string
+  // Edited: Claude - Date: 2026-08-20
+  // Names only, and null for a city whose country is not recorded. Lets the
+  // page say whether this journey crosses a border, which changes what a
+  // traveller has to bring.
+  from_country: string | null
+  to_country: string | null
   // cheapest adult fare anybody sells this leg for
   price_from: number | null
   // formatted by the API with the brand's own currency - the PUBLIC settings
   // payload carries no currency, so a frontend has nothing to format with
   price_from_display: string | null
+  // Edited: Claude - Date: 2026-08-20
+  // The dearest fare on the pair, so "how much is a ticket" can answer with
+  // a range. Equal to price_from where every service costs the same, and
+  // the copy collapses to the single-price sentence rather than printing
+  // "from X to X".
+  price_to: number | null
+  price_to_display: string | null
   // ISO 4217, for schema.org's Offer - the display string has the symbol
   // baked in and guessing a code back out of it would be confidently wrong
   currency: string | null
@@ -17,6 +43,34 @@ export interface FactsData {
   // how many coaches serve the pair in the TIMETABLE, not on a given date
   departures: number
   operators: string[]
+  /**
+   * Edited: Claude - Date: 2026-08-20
+   *
+   * How often, which `departures` cannot say - ten services means something
+   * very different once a week than it does every day.
+   *
+   * `days` is the UNION of the days a traveller can leave on, ISO 1 Monday
+   * to 7 Sunday. `weekly` is the SUM across services, so three daily coaches
+   * is 21 rather than 7. Neither is recoverable from the other.
+   *
+   * NULL when no service on the pair has a usable timetable row - including
+   * the case that matters, a season that has already ENDED. A summer coach
+   * whose window closed last September does not "run three times a week",
+   * and obtapi withholds the whole object rather than counting it.
+   */
+  frequency: { days: number[], weekly: number, daily: boolean } | null
+  // how many of the `departures` run non-stop, and how many are still
+  // rolling the next morning - counted out of the total rather than reported
+  // as a yes/no, because "one of ten is direct" is the honest version
+  direct: number
+  overnight: number
+  // the cities in between, across every service on the pair - `every` says
+  // whether all of them call at all of these, which on a busy pair they
+  // usually do not
+  via: (FactsList & { cities: string[] }) | null
+  // what is on board, resolved to display names by obtapi (the ids are
+  // inventory keys and the names come from its lang files)
+  amenities: (FactsList & { names: string[] }) | null
   // Edited: Claude - Date: 2026-08-20
   // The pair's own review score - the published reviews of every route in
   // this very timetable, aggregated by obtapi with the same threshold rule
@@ -73,5 +127,11 @@ export interface FactsResponse {
   facts: FactsData | null
   // Tier 3.4 - pairs leaving the origin, and pairs arriving at the
   // destination. Present even when `facts` is null.
-  links: { from: LinkRow[], to: LinkRow[] }
+  //
+  // Edited: Claude - Date: 2026-08-20
+  // `reverse` is the journey home. Pairs are directional, so it is a
+  // different page with its own timetable and fares - and it belongs to
+  // neither of the two blocks above, being a pair from the DESTINATION back
+  // to the origin. Null when the return leg is not sold.
+  links: { from: LinkRow[], to: LinkRow[], reverse: LinkRow | null }
 }

package/Faq/Faq.tsx

@@ -0,0 +1,52 @@
+import { TFunction } from 'i18next';
+import { Container, Heading, List, Item, Question, Answer } from './styles';
+import { Question as QuestionData } from '../Facts/questions';
+
+interface Props {
+  id: string
+  from: string
+  to: string
+  // Edited: Claude - Date: 2026-08-20
+  // Handed in already built, from Facts/questions - the same array the
+  // FAQPage structured data is emitted from. Building them here as well
+  // would give the page two lists that agree today and drift the first time
+  // one of them is edited, and the whole value of an FAQ rich result is that
+  // the answer Google quotes is the answer the reader finds.
+  questions: QuestionData[]
+  t: TFunction<'common'>
+}
+
+/**
+ * The questions this pair page answers, for a human.
+ *
+ * Edited: Claude - Date: 2026-08-20
+ *
+ * Every answer is a fact obtapi computed off the timetable - how long, how
+ * much, how often, who runs it, where it stops - so a pair served by one
+ * coach a week gets a short honest section rather than a long padded one.
+ * Nothing is asked that the data cannot answer, which is why this renders
+ * whatever it is handed and never composes a fallback.
+ */
+const Faq = ({ id, from, to, questions, t }: Props): (JSX.Element | null) => {
+  if (questions.length === 0) {
+    return null;
+  }
+
+  return (
+    <Container id={ id } className="box">
+      <Heading>{ t('routes_order.faq.title', { from, to }) }</Heading>
+
+      <List>
+        { questions.map(item => (
+          <Item key={ item.id }>
+            <Question>{ item.q }</Question>
+
+            <Answer>{ item.a }</Answer>
+          </Item>
+        )) }
+      </List>
+    </Container>
+  );
+};
+
+export default Faq;