Reject duplicate queue legs — same route can no longer be queued twice (ISS-065, v0.34.0)

- LeftPane fly-to button enabled for any plane state; posts to /queue when the plane is flying, else /fly
- Relocate lists ALL planes (relocatable); relocate-go posts to /queue for a flying selected plane, else /fly
- Delete queue-add select + Add-to-queue button and shared queueAddDestIcao state; leg rows/cancel kept
- e2e/queue.spec.ts test 1 adds its queued leg via the Relocate section (starter is flying)
- e2e/two-planes.spec.ts per-plane-queues test adds the starter's second leg via API POST /queue

CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## v0.34.0 — 2026-09-21 01:26
+- **Duplicate queue legs rejected with 409 (ISS-065).** `queueLeg` (`lib/game/actions.ts`) now refuses to append a destination that is already in the plane's flight queue ("{icao} is already in the flight queue"), and — while the plane is flying — re-queuing the active leg's destination ("already flying to {icao}"). Previously the same route could be queued any number of times, producing pointless repeated/zero-length hops when landing auto-chains `queue[0]`. No UI or OpenAPI changes (the endpoint already documents error responses)
+
+## v0.33.0 — 2026-09-21 00:45
+- **Merged On board into the Fleet list (ISS-054).** The left pane's separate "On board" section is deleted; each Fleet row (`components/LeftPane.tsx`) is now the single per-plane block — status/fuel/loadout plus, when present, that plane's loaded/expired cargo rows (fly-to / refuel-for-flight / abandon + penalty preview) and its queue legs. The header shows "in flight" + the current leg for flying planes and the location ICAO when grounded; the empty "Queue" heading is no longer rendered (the sub-section renders only with ≥1 queued leg). All per-item testids unchanged (`onboard-package-*`, `fly-to-*`, `refuel-for-*`, `abandon-*`, `abandon-penalty-*`, `plane-leg-*`, `queue-leg-*`, `queue-cancel-*`); the removed one is `onboard-{plane.id}` (use `plane-{id}`). CSS: `.onboard-block .contract-row*` re-targeted to `.plane-row .contract-row*`; no server or OpenAPI changes
+- **E2E updates.** The four `onboard-{plane.id}` references now target the fleet rows (`e2e/hover.spec.ts`, `e2e/right-pane.spec.ts`, `e2e/two-planes.spec.ts`); `e2e/panes.spec.ts` no longer asserts an "On board" heading — it asserts the heading is absent from both panes
+
+## v0.32.0 — 2026-09-20 23:47
+- **Queue via fly-to and Relocate; dedicated queue-add input removed (ISS-053).** The flight queue no longer has its own entry point in the On board block (`components/LeftPane.tsx`): the per-cargo "Fly to …" button is now enabled for ANY plane state, and posts to `/api/planes/{id}/queue` instead of `/fly` when the plane is `flying` (grounded → `/fly`, unchanged); Relocate's plane list widened from grounded-only to ALL planes (`relocatable = state.planes`; Refuel keeps its own `grounded` filter), and `relocate-go` posts to `/queue` when the SELECTED plane is flying, else `/fly`. The queue-add select + "Add to queue" button (and the shared `queueAddDestIcao` state) are deleted; leg rows + cancel buttons unchanged. No server or OpenAPI changes — both endpoints already existed
+- **E2E updates.** `e2e/queue.spec.ts` test 1 now adds its queued leg via the Relocate section (selects plane-starter, which is flying at that point → `/queue`) instead of the removed queue-add control; `e2e/two-planes.spec.ts` "per-plane queues are independent" adds the starter's second leg via API POST `/api/planes/plane-starter/queue` (the starter is grounded there, so fly-to would start rather than queue). All `queue-leg-*` / `queue-cancel-*` assertions unchanged
+
+## v0.31.0 — 2026-09-20 21:23
+- **Two-plane Load is one-click again (ISS-055).** The reported "can't load cargo with two planes at the same airport" was UX, not a server bug: `LoadControls` (`components/RightPane.tsx`) rendered a plane picker for ≥2 eligible planes whose Load button stayed DISABLED until a pick existed, while the single-plane path is one-click. The multi-plane path now PRESELECTS the first eligible plane (`effective = … ?? eligible[0] ?? null`; the select already bound to `effective?.id`), so Load is enabled and one-click whenever ≥1 plane qualifies — the dropdown still allows picking a different plane
+- **LeftPane queue testids scoped by plane id (ISS-055).** With two on-board blocks in the DOM the unscoped ids duplicated: `queue-leg-{i}` → `queue-leg-{plane.id}-{i}`, `queue-cancel-{i}` → `queue-cancel-{plane.id}-{i}`, plus the add control `queue-add-dest`/`queue-add` → `queue-add-dest-{plane.id}`/`queue-add-{plane.id}` (`components/LeftPane.tsx`). The shared pane-level destination pick is unchanged. `e2e/queue.spec.ts` locators updated to the scoped form (single-plane fleet, id `plane-starter`)
+- **New test hook: POST /api/test/add-cash (ISS-055).** Grants cash so e2e can afford a second plane (ATR €200k vs the €20k starting balance) — body `{ amount?: number }` (positive finite, default €1M), gated on `FLIGHT_TEST_HOOKS=1` exactly like its siblings (`app/api/test/create-package`, `/expire-package`; same 404/400 error shape), returns the full state snapshot. Test-only: outside the OpenAPI spec, so the documented path list stays at thirteen
+- **New serial e2e spec `e2e/two-planes.spec.ts` (ISS-055).** Six tests covering every two-plane gameplay flow — each buys its own second ATR via the UI (after an add-cash grant) and discovers it in /api/state as the plane that isn't `plane-starter`: **load** (picker lists both planes, preselect makes Load one-click without touching the select, explicit pick routes to the other plane, both on-board blocks render with cargo simultaneously), **fly** (parallel dispatch to different destinations; ISS-057 semantics — last landing leaves `paused === false && timeScale === 1`, dispatching a plane while another is grounded stays at 1×, dispatching the LAST grounded plane resumes `lastSelectedTimeScale` = 1000 in the /fly response), **refuel** (left-pane section lists both planes; refueling one deducts exactly its fill-up cost and tops only that tank), **relocate** (moves one plane, starter untouched), **queue** (per-plane scoped controls add/cancel independently; landing auto-chains the next queued leg at 1000×), **sell** (payout = round(price × SELL_FRACTION) added to cash, fleet back to 1, selling the last remaining plane 409s via API). Robust reset: beforeEach heals + sells every non-starter plane (queue cleared first so landings can't auto-chain mid-heal, leftover cargo abandoned so the sell guard never 409s) and repositions the starter home — every test starts AND ends at fleet = 1
+- Verified: `tsc --noEmit` clean; unit suite green locally (327 passed in 32 files — unchanged, no new unit tests: the sibling test hooks have none, so add-cash follows suit); `npx playwright test --list` = 52 tests in 14 files (was 46/13 — six new two-plane tests); e2e not run locally by design — CI verifies against an isolated stack
+
 ## v0.30.0 — 2026-09-20 19:47
 - **Landing slows the sim to 1× instead of pausing; dispatch restores the last selected speed (ISS-057).** Replaces the v0.24.0 pause-on-landing behavior with a slow-down: in `tickOnce` (`lib/sim/engine.ts`), when ≥1 plane landed this tick and ANY plane is grounded ('available') afterwards, the sim drops to `MIN_TIME_SCALE` (1×) — a just-landed plane counts, so any real landing slows; a chained plane stays 'flying' via deliverPackages' auto-chain branch, so a pure-chain tick with nothing grounded does NOT slow. Pause becomes manual-only: ticks never set it anymore
 - **Resume on dispatch.** `flyPlane` (`lib/game/actions.ts`) still clears a manually-paused sim on dispatch (kept), and now ALSO restores the last manually selected speed when this dispatch took the LAST grounded plane airborne — fresh-select 'available' planes after the update, and if zero remain set `timeScale = lastSelectedTimeScale`. With another plane still grounded the sim stays at 1×

app/api/test/add-cash/route.ts

@@ -0,0 +1,58 @@
+import { getGameDb, persist } from '@/lib/db/client';
+import * as schema from '@/lib/db/schema';
+import { getStateSnapshot } from '@/lib/game/state';
+import { tickNow } from '@/lib/sim/engine';
+
+// TEST-ONLY hook (v0.31.0, ISS-055) — grants cash so the e2e suite can afford a second
+// plane (ATR €200k vs the €20k starting balance). Disabled unless FLIGHT_TEST_HOOKS=1
+// (set in docker-compose.yml for the e2e instance only); every other deployment 404s here.
+// Sibling of /api/test/create-package — same gate, same conventions.
+//
+// POST /api/test/add-cash
+//   body { amount?: number } — a positive finite number when provided; defaults to €1M.
+//   Adds to account.cash (rounded to cents) and returns the full state snapshot.
+
+const DEFAULT_AMOUNT = 1_000_000;
+
+export async function POST(req: Request) {
+  if (process.env.FLIGHT_TEST_HOOKS !== '1') {
+    return Response.json({ error: 'test hooks disabled' }, { status: 404 });
+  }
+
+  let body: unknown = {};
+  try {
+    const text = await req.text();
+    body = text ? JSON.parse(text) : {};
+  } catch {
+    return Response.json({ error: 'invalid JSON body' }, { status: 400 });
+  }
+  if (typeof body !== 'object' || body === null || Array.isArray(body)) {
+    return Response.json({ error: 'body must be a JSON object' }, { status: 400 });
+  }
+  const input = body as Record<string, unknown>;
+  for (const key of Object.keys(input)) {
+    if (key !== 'amount') {
+      return Response.json({ error: `unknown field "${key}"` }, { status: 400 });
+    }
+  }
+  let amount = DEFAULT_AMOUNT;
+  if (input.amount !== undefined) {
+    if (typeof input.amount !== 'number' || !Number.isFinite(input.amount) || input.amount <= 0) {
+      return Response.json({ error: 'amount must be a positive finite number' }, { status: 400 });
+    }
+    amount = input.amount;
+  }
+
+  try {
+    const inst = await getGameDb();
+    await tickNow(); // clock is current before the snapshot we return (same as siblings)
+    const account = (await inst.db.select().from(schema.account))[0];
+    if (!account) throw new Error('account row missing');
+    await inst.db.update(schema.account).set({ cash: Math.round((account.cash + amount) * 100) / 100 });
+    await persist(inst);
+    return Response.json(await getStateSnapshot());
+  } catch (err) {
+    console.error('test hook failed', err);
+    return Response.json({ error: 'test hook failed' }, { status: 500 });
+  }
+}

app/globals.css

@@ -376,17 +376,10 @@ body {
   font-variant-numeric: tabular-nums;
 }
 
-/* v0.12.0 — on-board blocks (per plane); moved to the left pane in ISS-021 (v0.20.0) */
+/* ISS-054 (v0.33.0) — per-plane cargo rows nested inside the Fleet list's plane cards: two lines,
-.onboard-block {
+   a full-width fly-to button then refuel + abandon side by side below it; long destination names
-  background: rgba(30, 41, 59, 0.6);
+   truncate with an ellipsis. Transparent sub-rows with a top border under the card header. */
-  border-radius: 6px;
+.plane-row .contract-row {
-  padding: 8px;
-  margin-bottom: 8px;
-}
-
-/* ISS-028 (v0.20.0 part 2) — on-board cargo rows are two lines: a full-width fly-to button,
-   then refuel + abandon side by side below it; long destination names truncate with an ellipsis. */
-.onboard-block .contract-row {
   background: transparent;
   padding: 6px 0 0;
   border-top: 1px solid rgba(148, 163, 184, 0.2);
@@ -395,7 +388,7 @@ body {
   gap: 5px;
 }
 
-.onboard-block .contract-row .contract-sub {
+.plane-row .contract-row .contract-sub {
   margin-top: 0; /* row spacing comes from the container's gap */
 }
 

components/LeftPane.tsx

@@ -19,7 +19,7 @@ interface LeftPaneProps {
   // The shell's single-poll refresh — called after a sim-control POST so the pane updates immediately.
   onRefresh: () => void;
   // ISS-021 (v0.20.0): push the full snapshot returned by an action endpoint into the shared shell
-  // state — needed now that the On board section's refuel/fly/abandon actions live in this pane.
+  // state — needed now that the per-plane cargo rows' refuel/fly/abandon actions live in this pane.
   applySnapshot: (snapshot: StateSnapshot) => void;
   // ISS-002 (v0.15.0): report fleet-row hovers to the shell so the map can highlight the plane.
   onHover: (target: HoverTarget | null) => void;
@@ -92,7 +92,7 @@ export async function retrySimPost(
 export default function LeftPane({ state, loading, error, onRefresh, applySnapshot, onHover, onError }: LeftPaneProps) {
   const [busy, setBusy] = useState(false);
 
-  // ISS-021 (v0.20.0): shared action runner for the On board section (moved here from RightPane).
+  // ISS-021 (v0.20.0): shared action runner for the per-plane cargo/queue actions (moved here from RightPane).
   const { runAction, busy: actionsBusy, actionError } = useGameAction(state, applySnapshot, onError);
 
   // ISS-023 (v0.21.0): Relocate selections — moved here from the right-pane market row; same
@@ -106,10 +106,6 @@ export default function LeftPane({ state, loading, error, onRefresh, applySnapsh
   // a sensible default (first grounded plane with fuel below max).
   const [refuelPlaneId, setRefuelPlaneId] = useState<string | null>(null);
 
-  // ISS-043 (v0.26.0): flight-queue "add" destination — one shared pick across every on-board
-  // block's queue-add select (the e2e fleet is a single plane; per-block state would be dead weight).
-  const [queueAddDestIcao, setQueueAddDestIcao] = useState<string | null>(null);
-
   // ISS-010 (v0.18.0): one-time /api/airports fetch per page life — destination options for the
   // Relocate section, sorted by name so e2e selection is stable. Same promise-ref pattern as Map.tsx;
   // on failure airportOptions stays null and the Relocate button simply remains disabled. Moved here
@@ -199,27 +195,23 @@ export default function LeftPane({ state, loading, error, onRefresh, applySnapsh
   const paused = state?.simState.paused ?? false;
   const timeScale = state?.simState.timeScale ?? 1;
 
-  // On board (v0.12.0, moved from the right pane in ISS-021 v0.20.0): every plane that carries
+  // Snapshot clock — feeds the deadline/penalty previews in the per-plane cargo rows.
-  // cargo or is mid-flight gets a block — its loaded/expired packages with fly-to-destination +
-  // abandon controls, and flying planes show their current leg.
   const clockMs = state?.simState.clockMs ?? 0;
-  // ISS-043 (v0.26.0): a plane with queued legs always shows its block too — the queue is the
-  // reason it's here even when grounded with nothing on board.
-  const onboard = state
-    ? state.planes.filter((p) => p.status === 'flying' || cargoWeightFor(state, p.id) > 0 || (p.queue?.length ?? 0) > 0)
-    : [];
 
-  // ISS-023 (v0.21.0): Relocate — any GROUNDED plane can be repositioned to any airport via the
+  // ISS-023 (v0.21.0): Relocate — any plane can be repositioned to any airport via the existing fly
-  // existing fly endpoint (pure repositioning, no package needed since v0.12.0). Moved here from
+  // endpoint (pure repositioning, no package needed since v0.12.0). Moved here from the right-pane
-  // the right-pane market row; with state null both fall back to null and the section isn't rendered.
+  // market row; with state null both fall back to null and the section isn't rendered.
-  const grounded = state ? state.planes.filter((p) => p.status === 'available') : [];
+  // ISS-053 (v0.32.0): widened from grounded-only to ALL planes — a flying plane's relocation is
-  const relocatePlane = grounded.find((p) => p.id === relocatePlaneId) ?? grounded[0] ?? null;
+  // queued instead of started immediately (see relocate-go below). `grounded` stays for Refuel.
+  const relocatable = state ? state.planes : [];
+  const relocatePlane = relocatable.find((p) => p.id === relocatePlaneId) ?? relocatable[0] ?? null;
   const relocateDest =
     airportOptions === null ? null : airportOptions.find((a) => a.icao === relocateDestIcao) ?? airportOptions[0] ?? null;
 
   // ISS-035 (v0.23.0): Refuel-to-full — any GROUNDED plane with fuel below max can be topped up via the
   // existing refuel endpoint (no body → server defaults to mode 'full'). Moved here from the right-pane
-  // market row; reuses `grounded` above, and with state null falls back to null.
+  // market row; grounded-only, and with state null falls back to null.
+  const grounded = relocatable.filter((p) => p.status === 'available');
   const refuelable = grounded.filter((p) => p.fuel < p.maxFuel);
   const refuelPlane =
     (state?.planes.find((p) => p.id === refuelPlaneId && p.status === 'available' && p.fuel < p.maxFuel)) ??
@@ -341,8 +333,17 @@ export default function LeftPane({ state, loading, error, onRefresh, applySnapsh
               <p className="pane-muted">No planes.</p>
             ) : (
               <ul data-testid="fleet-list" className="fleet-list">
-                {state.planes.map((p) => (
+                {state.planes.map((p) => {
-                  // ISS-002: hovering a fleet row highlights the plane on the map.
+                  // ISS-054 (v0.33.0): the merged per-plane block — status/fuel/loadout plus the former
+                  // On board section's cargo rows and queue legs, so all plane info lives in one place.
+                  const cargo = state.packages.filter(
+                    (pkg) => pkg.planeId === p.id && (pkg.status === 'loaded' || pkg.status === 'expired'),
+                  );
+                  return (
+                    // ISS-002: hovering a fleet row highlights the plane on the map. Handlers live only on
+                    // the outer <li> — React's enter/leave don't fire when moving to a child, so this covers
+                    // the whole block without flicker between sub-elements; cargo rows override with their
+                    // own package hover (below).
                     <li
                       key={p.id}
                       data-testid={`plane-${p.id}`}
@@ -352,7 +353,18 @@ export default function LeftPane({ state, loading, error, onRefresh, applySnapsh
                     >
                       <div className="plane-main">
                         <span className="plane-model">{PLANE_TYPES[p.model]?.name ?? p.model}</span>
-                      <span className={`plane-status status-${p.status}`}>{p.status}</span>
+                        {p.status === 'flying' ? (
+                          <>
+                            <span className="plane-status status-flying">in flight</span>
+                            {p.destName && (
+                              <span data-testid={`plane-leg-${p.id}`} className="contract-route">
+                                {p.locationName} → {p.destName}
+                              </span>
+                            )}
+                          </>
+                        ) : (
+                          <span className="plane-status status-available">{p.locationIcao}</span>
+                        )}
                       </div>
                       <div className="fuel-bar" aria-hidden="true">
                         <div style={{ width: `${Math.max(0, Math.min(100, (p.fuel / p.maxFuel) * 100))}%` }} />
@@ -362,48 +374,6 @@ export default function LeftPane({ state, loading, error, onRefresh, applySnapsh
                         <span data-testid={`plane-loadout-${p.id}`}>{loadoutFor(state, p)}</span>
                         <span className="plane-loc">{planeLocation(p)}</span>
                       </div>
-                  </li>
-                ))}
-              </ul>
-            )}
-          </section>
-
-          {/* ISS-021 (v0.20.0): moved here from the right pane — between Fleet and Time. */}
-          <section className="pane-section">
-            <h3 className="pane-heading">On board</h3>
-            {onboard.length === 0 ? (
-              <p className="pane-muted">Nothing on board.</p>
-            ) : (
-              onboard.map((plane) => {
-                const cargo = state.packages.filter(
-                  (pkg) => pkg.planeId === plane.id && (pkg.status === 'loaded' || pkg.status === 'expired'),
-                );
-                return (
-                  // ISS-002: hovering the on-board block (including its cargo rows) highlights the plane.
-                  // Handlers live only on the outer div — React's enter/leave don't fire when moving to a
-                  // child, so this covers the whole block without flicker between sub-elements.
-                  <div
-                    key={plane.id}
-                    data-testid={`onboard-${plane.id}`}
-                    className="onboard-block"
-                    onMouseEnter={() => onHover({ kind: 'plane', id: plane.id })}
-                    onMouseLeave={() => onHover(null)}
-                  >
-                    <div className="contract-main">
-                      <span className="plane-model">{PLANE_TYPES[plane.model]?.name ?? plane.model}</span>
-                      {plane.status === 'flying' ? (
-                        <>
-                          <span className="plane-status status-flying">in flight</span>
-                          {plane.destName && (
-                            <span data-testid={`plane-leg-${plane.id}`} className="contract-route">
-                              {plane.locationName} → {plane.destName}
-                            </span>
-                          )}
-                        </>
-                      ) : (
-                        <span className="plane-status status-available">{plane.locationIcao}</span>
-                      )}
-                    </div>
                       {cargo.map((pkg) => {
                         const penalty = abandonPenalty(pkg, clockMs);
                         return (
@@ -415,15 +385,17 @@ export default function LeftPane({ state, loading, error, onRefresh, applySnapsh
                             key={pkg.id}
                             data-testid={`onboard-package-${pkg.id}`}
                             className="contract-row"
-                          onMouseEnter={() => onHover({ kind: 'package', originIcao: pkg.originIcao, destIcao: pkg.destIcao, planeId: plane.id })}
+                            onMouseEnter={() => onHover({ kind: 'package', originIcao: pkg.originIcao, destIcao: pkg.destIcao, planeId: p.id })}
-                          onMouseLeave={() => onHover({ kind: 'plane', id: plane.id })}
+                            onMouseLeave={() => onHover({ kind: 'plane', id: p.id })}
                           >
                             <button
                               type="button"
                               data-testid={`fly-to-${pkg.id}`}
                               className="pane-btn onboard-fly-btn"
-                            disabled={actionsBusy || plane.status !== 'available'}
+                              disabled={actionsBusy}
-                            onClick={() => void runAction(`/api/planes/${plane.id}/fly`, { destIcao: pkg.destIcao })}
+                              // ISS-053 (v0.32.0): a flying plane can't start another leg — the click queues it instead,
+                              // so "Fly to …" works from any state and the queue needs no dedicated input.
+                              onClick={() => void runAction(`/api/planes/${p.id}/${p.status === 'flying' ? 'queue' : 'fly'}`, { destIcao: pkg.destIcao })}
                             >
                               <span className="onboard-fly-label" title={`Fly to ${pkg.destName}`}>
                                 Fly to {pkg.destName}
@@ -434,8 +406,8 @@ export default function LeftPane({ state, loading, error, onRefresh, applySnapsh
                                 type="button"
                                 data-testid={`refuel-for-${pkg.id}`}
                                 className="pane-btn"
-                              disabled={actionsBusy || plane.status !== 'available'}
+                                disabled={actionsBusy || p.status !== 'available'}
-                              onClick={() => void runAction(`/api/planes/${plane.id}/refuel`, { mode: 'forFlight', packageId: pkg.id })}
+                                onClick={() => void runAction(`/api/planes/${p.id}/refuel`, { mode: 'forFlight', packageId: pkg.id })}
                               >
                                 Refuel
                               </button>
@@ -443,7 +415,7 @@ export default function LeftPane({ state, loading, error, onRefresh, applySnapsh
                                 type="button"
                                 data-testid={`abandon-${pkg.id}`}
                                 className="pane-btn"
-                              disabled={actionsBusy || plane.status !== 'available'}
+                                disabled={actionsBusy || p.status !== 'available'}
                                 onClick={() => void runAction(`/api/packages/${pkg.id}/abandon`)}
                               >
                                 Abandon{' '}
@@ -462,64 +434,45 @@ export default function LeftPane({ state, loading, error, onRefresh, applySnapsh
                           </div>
                         );
                       })}
-                    {/* ISS-043 (v0.26.0): flight queue — the not-yet-started legs with cancel, plus an
+                      {/* ISS-043 (v0.26.0): flight queue — the not-yet-started legs with cancel.
-                        add control reusing this pane's already-fetched airport options (no second fetch). */}
+                          ISS-053 (v0.32.0): the dedicated add input is gone — fly-to and Relocate post to
+                          /queue while a plane is flying, so no separate entry point is needed.
+                          ISS-054 (v0.33.0): rendered only when non-empty. */}
+                      {p.queue.length > 0 && (
                         <div className="queue-subsection">
                           <span className="queue-heading">Queue</span>
-                      {plane.queue.map((icao, i) => (
+                          {/* ISS-055 (v0.31.0): testids scoped by plane id — with two blocks the unscoped ids
-                        <div key={`${icao}-${i}`} data-testid={`queue-leg-${i}`} className="queue-row">
+                              duplicated in the DOM and broke Playwright strict mode. */}
+                          {p.queue.map((icao, i) => (
+                            <div key={`${icao}-${i}`} data-testid={`queue-leg-${p.id}-${i}`} className="queue-row">
                               <span className="contract-route">
                                 {airportOptions?.find((a) => a.icao === icao)?.name ?? icao} ({icao})
                               </span>
                               <button
                                 type="button"
-                            data-testid={`queue-cancel-${i}`}
+                                data-testid={`queue-cancel-${p.id}-${i}`}
                                 className="pane-btn"
                                 disabled={actionsBusy}
-                            onClick={() => void runAction(`/api/planes/${plane.id}/queue/cancel`, { index: i })}
+                                onClick={() => void runAction(`/api/planes/${p.id}/queue/cancel`, { index: i })}
                               >
                                 Cancel
                               </button>
                             </div>
                           ))}
-                      <div className="market-row">
-                        <select
-                          data-testid="queue-add-dest"
-                          aria-label="Airport to add to the flight queue"
-                          value={queueAddDestIcao ?? ''}
-                          onChange={(e) => setQueueAddDestIcao(e.target.value || null)}
-                        >
-                          <option value="">Select an airport…</option>
-                          {airportOptions?.map((a) => (
-                            <option key={a.icao} value={a.icao}>
-                              {a.name}
-                            </option>
-                          ))}
-                        </select>
-                        <button
-                          type="button"
-                          data-testid="queue-add"
-                          className="pane-btn"
-                          disabled={actionsBusy || queueAddDestIcao === null}
-                          onClick={() => {
-                            if (queueAddDestIcao) void runAction(`/api/planes/${plane.id}/queue`, { destIcao: queueAddDestIcao });
-                          }}
-                        >
-                          Add to queue
-                        </button>
-                      </div>
-                    </div>
                         </div>
+                      )}
+                    </li>
                   );
-              })
+                })}
+              </ul>
             )}
           </section>
 
           {/* ISS-023 (v0.21.0): moved here from the right-pane market row — it belongs with
-              everything else about our planes, between On board and Time. */}
+              everything else about our planes, between Fleet and Time. */}
           {/* ISS-027 (v0.22.0): hovering the section previews the planned relocation on the map —
               dashed trace from the selected plane's airport to the destination + a ring on the target.
-              With no grounded plane or no loaded airport options there is nothing to preview → null. */}
+              With no planes or no loaded airport options there is nothing to preview → null. */}
           <section
             className="pane-section"
             data-testid="relocate-section"
@@ -533,8 +486,9 @@ export default function LeftPane({ state, loading, error, onRefresh, applySnapsh
             onMouseLeave={() => onHover(null)}
           >
             <h3 className="pane-heading">Relocate</h3>
-            {/* ISS-010 (v0.18.0): relocate a grounded plane — the fly endpoint already allows pure
+            {/* ISS-010 (v0.18.0): relocate a plane — the fly endpoint already allows pure
-                repositioning, this row just exposes it for planes with nothing on board. */}
+                repositioning, this row just exposes it for planes with nothing on board.
+                ISS-053 (v0.32.0): lists ALL planes; a flying one's relocation is queued below. */}
             <div className="market-row market-row-relocate">
               <select
                 data-testid="relocate-plane"
@@ -542,7 +496,7 @@ export default function LeftPane({ state, loading, error, onRefresh, applySnapsh
                 value={relocatePlane?.id ?? ''}
                 onChange={(e) => setRelocatePlaneId(e.target.value || null)}
               >
-                {grounded.map((p) => (
+                {relocatable.map((p) => (
                   <option key={p.id} value={p.id}>
                     {PLANE_TYPES[p.model]?.name ?? p.model} — {p.locationIcao}
                   </option>
@@ -565,9 +519,11 @@ export default function LeftPane({ state, loading, error, onRefresh, applySnapsh
                 data-testid="relocate-go"
                 className="pane-btn"
                 disabled={actionsBusy || relocatePlane === null || relocateDest === null}
+                // ISS-053 (v0.32.0): a flying plane can't start another leg — queue it instead, so the
+                // relocation takes off when the current one lands.
                 onClick={() => {
                   if (relocatePlane && relocateDest) {
-                    void runAction(`/api/planes/${relocatePlane.id}/fly`, { destIcao: relocateDest.icao });
+                    void runAction(`/api/planes/${relocatePlane.id}/${relocatePlane.status === 'flying' ? 'queue' : 'fly'}`, { destIcao: relocateDest.icao });
                   }
                 }}
               >
@@ -581,7 +537,7 @@ export default function LeftPane({ state, loading, error, onRefresh, applySnapsh
           <section className="pane-section" data-testid="refuel-section">
             <h3 className="pane-heading">Refuel</h3>
             {/* Moved verbatim from the right-pane Market section — same testids/labels; the per-package
-                "Refuel" button in On board (mode 'forFlight') is a different feature and stays there. */}
+                "Refuel" button in the fleet rows (mode 'forFlight') is a different feature and stays there. */}
             <div className="market-row">
               {refuelable.length === 0 ? (
                 <span data-testid="market-refuel-none" className="pane-muted">

components/RightPane.tsx

@@ -49,8 +49,9 @@ export function loadEligiblePlanes(state: StateSnapshot, pkg: PackageState): Pla
 // Load controls for one open package: a single Load button when exactly one plane
 // is eligible (it acts on that plane directly), a small plane picker + Load when
 // several are, and a disabled button with the reason otherwise. Each row owns its
-// selection in local state and defaults to the "Select a plane…" placeholder —
+// selection in local state; ISS-055 (v0.31.0): the multi-plane path PRESELECTS the
-// never preselecting — so rows stay visibly independent (v0.10.1 pattern).
+// first eligible plane so Load is one-click out of the box (matching the single-plane
+// UX) while the picker still allows choosing a different plane.
 function LoadControls({
   pkg,
   eligible,
@@ -63,8 +64,9 @@ function LoadControls({
   onLoad: (planeId: string) => void;
 }) {
   const [selectedId, setSelectedId] = useState<string | null>(null);
-  // The user's pick while it stays eligible, else nothing (placeholder).
+  // ISS-055 (v0.31.0): the user's pick while it stays eligible, else the FIRST eligible plane —
-  const effective = eligible.find((p) => p.id === selectedId) ?? null;
+  // Load is enabled and one-click whenever ≥1 plane qualifies; the picker still allows a different pick.
+  const effective = eligible.find((p) => p.id === selectedId) ?? eligible[0] ?? null;
 
   if (eligible.length === 1) {
     return (

e2e/hover.spec.ts

@@ -439,7 +439,7 @@ test('hovering the Relocate section previews the planned route and target airpor
   }).toBe(0);
 });
 
-test('hovering an on-board block of a flying plane highlights its route', async ({ page }) => {
+test('hovering the fleet row of a flying plane highlights its route', async ({ page }) => {
   test.setTimeout(600_000); // self-heal + one flight at scale 1000 + fly-home cleanup
   await flyHomeViaApi(page);
 
@@ -458,8 +458,8 @@ test('hovering an on-board block of a flying plane highlights its route', async
   expect(fly.status()).toBe(200);
   await setScale(page, SCALE);
 
-  // The on-board block shows the plane in flight once a snapshot with status 'flying' lands.
+  // The fleet row shows the plane in flight once a snapshot with status 'flying' lands (ISS-054).
-  const block = page.getByTestId('onboard-plane-starter');
+  const block = page.getByTestId('plane-plane-starter');
   await expect(block).toContainText(/in flight/i, { timeout: 15_000 });
 
   // Freeze mid-flight so the ~10 s leg can't land under us while we assert (same pattern as

e2e/panes.spec.ts

@@ -70,10 +70,9 @@ test('left pane renders wallet, reputation and the starter fleet at Frankfurt',
   // Sim clock renders (UTC wall-clock of the game time).
   await expect(page.getByTestId('sim-clock')).toContainText(/UTC/);
 
-  // ISS-021 (v0.20.0): the On board section moved to the left pane (between Fleet and Time) —
+  // ISS-054 (v0.33.0): On board merged into the Fleet list — its heading is gone from both panes,
-  // its heading renders here…
+  // per-plane cargo rows now render inside the fleet rows.
-  await expect(page.getByTestId('left-pane').getByRole('heading', { name: 'On board', exact: true })).toBeVisible();
+  await expect(page.getByTestId('left-pane').getByRole('heading', { name: 'On board', exact: true })).toHaveCount(0);
-  // …and no longer in the right pane.
   await expect(page.getByTestId('right-pane').getByRole('heading', { name: 'On board', exact: true })).toHaveCount(0);
 
   // ISS-035 (v0.23.0): the Refuel-to-full row moved to the left pane next to Relocate — its section

e2e/queue.spec.ts

@@ -1,7 +1,8 @@
 import { test, expect, type Page } from '@playwright/test';
 
 // v0.26.0 — ISS-043 part 2 (UI): the flight queue. A plane's not-yet-started legs show up in a
-// Queue sub-section of its on-board block (add via airport select + button, cancel per leg), and
+// Queue sub-section of its on-board block (cancel per leg; adding happens via fly-to / Relocate
+// while flying, ISS-053), and
 // a flying plane with queued legs draws them as a DOTTED line (`queue-routes` layer) chaining
 // dest → queue[0] → … — the active leg stays in the solid `routes-legs` layer. Landing auto-starts
 // the next queued leg server-side (part 1); test 3 exercises that chain end-to-end through the API.
@@ -216,9 +217,9 @@ test('queue display + cancel via UI (ISS-043 part 2)', async ({ page }) => {
   const onboardRow = page.getByTestId(`onboard-package-${pkg.id}`);
   await expect(onboardRow, 'loaded package appears in the On board section').toBeVisible({ timeout: 15_000 });
 
-  // LeftPane's own /api/airports fetch populates the queue-add select — wait for it.
+  // LeftPane's own /api/airports fetch populates the Relocate destination select — wait for it.
-  const addSelect = page.getByTestId('queue-add-dest');
+  const destSelect = page.getByTestId('relocate-dest');
-  await expect(addSelect.locator(`option[value="${QUEUE}"]`)).toHaveCount(1, { timeout: 15_000 });
+  await expect(destSelect.locator(`option[value="${QUEUE}"]`)).toHaveCount(1, { timeout: 15_000 });
 
   // START leg 1 via the UI (fly-to button in the on-board block).
   const flyBtn = page.getByTestId(`fly-to-${pkg.id}`);
@@ -232,20 +233,23 @@ test('queue display + cancel via UI (ISS-043 part 2)', async ({ page }) => {
   }, { timeout: 15_000, message: 'waiting for the fly click to take effect (status "flying" + dest set)' }).toBe(true);
   await postSim(page, { paused: true }); // pause-sim pattern: deterministic window for UI clicks
 
-  // ADD a leg to the queue via the UI. The button is disabled until an airport is selected…
+  // ISS-065: re-queuing the CURRENT leg's destination while flying must be rejected with 409.
-  const addButton = page.getByTestId('queue-add');
+  const dupQueue = await page.request.post('/api/planes/plane-starter/queue', { data: { destIcao: DEST } });
-  await expect(addButton).toBeDisabled();
+  expect(dupQueue.status()).toBe(409);
-  await addSelect.selectOption(QUEUE);
+
-  await expect(addButton).toBeEnabled();
+  // ADD a leg to the queue via the Relocate section (ISS-053): the starter is flying, so relocate-go
-  await addButton.click();
+  // posts to /queue and the leg starts when it lands.
+  await page.getByTestId('relocate-plane').selectOption('plane-starter');
+  await destSelect.selectOption(QUEUE);
+  await page.getByTestId('relocate-go').click();
 
   // …and the new leg appears as queue-leg-0 with its destination.
-  const legRow = page.getByTestId('queue-leg-0');
+  const legRow = page.getByTestId('queue-leg-plane-starter-0');
   await expect(legRow, 'the queued leg appears in the Queue sub-section').toContainText(QUEUE, { timeout: 15_000 });
 
   // CANCEL it via the UI and assert it's gone.
-  await page.getByTestId('queue-cancel-0').click();
+  await page.getByTestId('queue-cancel-plane-starter-0').click();
-  await expect(page.getByTestId('queue-leg-0'), 'the cancelled leg is removed from the queue').toHaveCount(0, { timeout: 15_000 });
+  await expect(page.getByTestId('queue-leg-plane-starter-0'), 'the cancelled leg is removed from the queue').toHaveCount(0, { timeout: 15_000 });
 
   // Cleanup: resume + fast-forward to arrival at DEST (empty queue → plain landing), then fly home.
   await setScale(page, SCALE);

e2e/right-pane.spec.ts

@@ -268,8 +268,8 @@ test('on-board list: fly-to-destination + abandon with penalty preview; flying p
   await expect(flyBtn).toBeEnabled();
   await flyBtn.click();
 
-  // The on-board block now shows the plane in flight with its current leg…
+  // The fleet row now shows the plane in flight with its current leg (ISS-054)…
-  await expect(page.getByTestId('onboard-plane-starter')).toContainText(/in flight/i, { timeout: 10_000 });
+  await expect(page.getByTestId('plane-plane-starter')).toContainText(/in flight/i, { timeout: 10_000 });
   const leg = page.getByTestId('plane-leg-plane-starter');
   await expect(leg).toBeVisible();
   await expect(leg).toContainText('→');

e2e/two-planes.spec.ts

@@ -0,0 +1,590 @@
+import type { Page } from '@playwright/test';
+import { expect, test } from '@playwright/test';
+
+// v0.31.0 — ISS-055: gameplay with TWO planes in the fleet. The reported bug ("can't load cargo
+// if both planes are on the same airport") was UX-only: LoadControls' multi-plane path rendered a
+// greyed-out Load button until a plane was picked from the dropdown, while the single-plane path
+// is one-click. v0.31.0 preselects the first eligible plane (components/RightPane.tsx), and this
+// spec covers every two-plane flow: load (preselect + picker), parallel flights with the ISS-057
+// slow/resume semantics, refuel, relocate, per-plane queues (scoped testids) and sell.
+//
+// Each test buys its own second plane via the UI (after a cash grant from the new
+// POST /api/test/add-cash hook — ATR €200k vs the €20k starting balance); beforeEach/afterEach
+// guarantee the fleet is exactly one plane (the starter, grounded at EDDF) before and after.
+
+const SCALE = 1000; // fastest sim speed (v0.14.0 ladder top) — keeps flights to seconds of real time
+const HUB = 'EDDF'; // must match HUB_ICAO in lib/game/seed.ts
+const STARTER = 'plane-starter'; // the seeded plane's id (lib/game/seed.ts)
+const BUY_MODEL = 'atr72'; // cheapest catalog entry — the second plane every test buys
+
+interface PlaneState {
+  id: string;
+  model: string;
+  status: 'available' | 'flying';
+  fuel: number;
+  maxFuel: number;
+  locationIcao: string;
+  destIcao: string | null;
+  queue: string[];
+}
+
+interface PackageState {
+  id: string;
+  originIcao: string;
+  destIcao: string;
+  status: 'open' | 'loaded' | 'delivered' | 'expired' | 'abandoned' | 'ignored';
+  planeId: string | null;
+}
+
+interface CatalogEntry {
+  model: string;
+  label: string;
+  price: number;
+  maxFuel: number;
+  burnPerKm: number;
+  emptyWeightKg: number;
+  speedKmh: number;
+  maxPayloadKg: number;
+}
+
+interface StateBody {
+  account: { cash: number; reputation: number };
+  simState: { clockMs: number; timeScale: number; paused: boolean };
+  planes: PlaneState[];
+  packages: PackageState[];
+  catalog: CatalogEntry[];
+  fuelPricePerL: number;
+  sellFraction: number;
+}
+
+// Mirrors formatCash in lib/format.ts (same Intl settings → identical strings).
+const eur = (v: number) => new Intl.NumberFormat('en-US', { style: 'currency', currency: 'EUR' }).format(v);
+
+async function getState(page: Page): Promise<StateBody> {
+  const res = await page.request.get('/api/state');
+  expect(res.status()).toBe(200);
+  return (await res.json()) as StateBody;
+}
+
+async function postSim(page: Page, body: unknown) {
+  return page.request.post('/api/sim', { data: body });
+}
+
+// Set the time scale and VERIFY from the response that it stuck. Also records lastSelectedTimeScale
+// (the ISS-057 resume target) and clears pause — so any fast-forward after a slowed-to-1× landing
+// proceeds at full speed.
+async function setScale(page: Page, scale: number): Promise<void> {
+  const res = await page.request.post('/api/sim', { data: { timeScale: scale, paused: false } });
+  expect(res.status()).toBe(200);
+  const body = (await res.json()) as { timeScale: number };
+  expect(body.timeScale, `timeScale should be ${scale} after POST /api/sim`).toBe(scale);
+}
+
+// Mirrors haversineKm in lib/geo.ts (same formula → identical floats).
+function haversineKm(lat1: number, lon1: number, lat2: number, lon2: number): number {
+  const toRad = (d: number) => (d * Math.PI) / 180;
+  const dLat = toRad(lat2 - lat1);
+  const dLon = toRad(lon2 - lon1);
+  const a =
+    Math.sin(dLat / 2) ** 2 +
+    Math.cos(toRad(lat1)) * Math.cos(toRad(lat2)) * Math.sin(dLon / 2) ** 2;
+  return 2 * 6371 * Math.asin(Math.min(1, Math.sqrt(a)));
+}
+
+// Mirrors lib/sim/movement.ts (v0.16.0): fuel required to cover distanceKm arriving empty —
+// closed form of the weight-proportional burn model, k calibrated so a full tank burns burnPerKm.
+const FUEL_DENSITY_KG_PER_L = 0.8; // must match FUEL_DENSITY_KG_PER_L in lib/sim/movement.ts
+function requiredFuelFor(burnPerKm: number, emptyWeightKg: number, maxFuel: number, distanceKm: number): number {
+  const k = burnPerKm / (emptyWeightKg + FUEL_DENSITY_KG_PER_L * maxFuel);
+  return (emptyWeightKg / FUEL_DENSITY_KG_PER_L) * (Math.exp(k * FUEL_DENSITY_KG_PER_L * distanceKm) - 1);
+}
+
+// Two CLOSEST airports to the hub — short, full-tank-flyable legs on distinct destinations.
+async function twoNearestToHub(page: Page): Promise<Array<{ icao: string; lat: number; lon: number }>> {
+  const fc = (await (await page.request.get('/api/airports')).json()) as {
+    features: Array<{ properties: { icao: string; lat: number; lon: number } }>;
+  };
+  const hub = fc.features.find((f) => f.properties.icao === HUB)!.properties;
+  return fc.features
+    .filter((f) => f.properties.icao !== HUB)
+    .map((f) => ({ ...f.properties, d: haversineKm(hub.lat, hub.lon, f.properties.lat, f.properties.lon) }))
+    .sort((x, y) => x.d - y.d)
+    .slice(0, 2)
+    .map(({ icao, lat, lon }) => ({ icao, lat, lon }));
+}
+
+// Farthest airport from EDDF whose leg still fits a FULL ATR tank — the longest flyable leg. The
+// dataset's absolute farthest can exceed range (a full-tank fly there would rightly 409).
+async function farthestFlyableToHub(page: Page): Promise<{ icao: string; lat: number; lon: number }> {
+  const entry = (await getState(page)).catalog.find((e) => e.model === BUY_MODEL)!;
+  const fc = (await (await page.request.get('/api/airports')).json()) as {
+    features: Array<{ properties: { icao: string; lat: number; lon: number } }>;
+  };
+  const hub = fc.features.find((f) => f.properties.icao === HUB)!.properties;
+  let farthest: { icao: string; lat: number; lon: number; d: number } | null = null;
+  for (const f of fc.features) {
+    if (f.properties.icao === HUB) continue;
+    const d = haversineKm(hub.lat, hub.lon, f.properties.lat, f.properties.lon);
+    if (requiredFuelFor(entry.burnPerKm, entry.emptyWeightKg, entry.maxFuel, d) > entry.maxFuel) continue; // beyond range
+    if (!farthest || d > farthest.d) {
+      farthest = { icao: f.properties.icao, lat: f.properties.lat, lon: f.properties.lon, d };
+    }
+  }
+  if (!farthest) throw new Error('no full-tank-flyable airport found in the dataset');
+  return { icao: farthest.icao, lat: farthest.lat, lon: farthest.lon };
+}
+
+// Test hook (FLIGHT_TEST_HOOKS=1): create an open package on a known route with a forced weight.
+async function createPackage(
+  page: Page,
+  fromIcao: string,
+  toIcao: string,
+  deadlineOffsetMs?: number,
+  weightKg?: number,
+): Promise<PackageState> {
+  const created = await page.request.post('/api/test/create-package', {
+    data: { originIcao: fromIcao, destIcao: toIcao, deadlineOffsetMs, weightKg },
+  });
+  expect(created.status()).toBe(201);
+  return (await created.json()) as PackageState;
+}
+
+// Test hook (FLIGHT_TEST_HOOKS=1): grant cash so a second plane is affordable. Returns the full
+// post-grant snapshot (the route's response).
+async function addCash(page: Page, amount?: number): Promise<StateBody> {
+  const res = await page.request.post('/api/test/add-cash', { data: amount === undefined ? {} : { amount } });
+  expect(res.status()).toBe(200);
+  return (await res.json()) as StateBody;
+}
+
+// Buy a second ATR through the UI (Planes market tab) and return its id — discovered in /api/state
+// as the plane that isn't plane-starter (bought planes get random UUIDs, no stable name).
+async function buySecondPlaneViaUi(page: Page): Promise<string> {
+  await addCash(page); // default €1M grant — covers the ATR's €200k price regardless of prior cash
+
+  await page.goto('/');
+  const right = page.getByTestId('right-pane');
+  await expect(right).toBeVisible({ timeout: 15_000 });
+  await page.getByTestId('tab-planes-market').click();
+
+  const buyModel = page.getByTestId('market-buy-model');
+  await expect(buyModel, 'the market model picker appears').toBeVisible({ timeout: 15_000 });
+  await buyModel.selectOption(BUY_MODEL);
+  await page.getByTestId('market-buy').click();
+
+  let secondId: string | null = null;
+  await expect
+    .poll(async () => {
+      const s = await getState(page);
+      secondId = s.planes.find((p) => p.id !== STARTER)?.id ?? null;
+      return secondId !== null;
+    }, { timeout: 15_000, message: 'waiting for the bought plane to appear in /api/state' })
+    .toBe(true);
+  return secondId!;
+}
+
+// Cancel every queued leg of a plane via the API (works while flying — the server checks no status).
+async function clearQueueViaApi(page: Page, planeId: string): Promise<void> {
+  for (;;) {
+    const q = (await getState(page)).planes.find((p) => p.id === planeId)?.queue ?? [];
+    if (q.length === 0) return;
+    expect((await page.request.post(`/api/planes/${planeId}/queue/cancel`, { data: { index: 0 } })).status()).toBe(200);
+  }
+}
+
+// Abandon leftover loaded/expired cargo on a GROUNDED plane — the sell guard rejects planes
+// carrying cargo, and clean baselines keep exact-cash assertions honest.
+async function abandonLeftoverCargo(page: Page, planeId: string): Promise<void> {
+  const s = await getState(page);
+  for (const pkg of s.packages) {
+    if (pkg.planeId === planeId && (pkg.status === 'loaded' || pkg.status === 'expired')) {
+      expect((await page.request.post(`/api/packages/${pkg.id}/abandon`)).ok()).toBeTruthy();
+    }
+  }
+}
+
+// Heal one plane to "grounded at the hub": clear its queue first (no auto-chain on landing),
+// fast-forward any in-flight leg, then reposition home. Same pattern as flyHomeViaApi in the other
+// specs, generalized to an arbitrary plane id.
+async function healPlaneHome(page: Page, planeId: string): Promise<void> {
+  await clearQueueViaApi(page, planeId);
+  let p = (await getState(page)).planes.find((x) => x.id === planeId);
+  if (!p) return; // already sold — nothing to heal
+  // ISS-057: a prior landing may have slowed the sim to 1× — restore 1000× first so any in-flight leg
+  // completes fast. Re-applied inside the poll below, since a sibling's landing mid-wait slows it again.
+  await setScale(page, SCALE);
+  if (p.status === 'flying') {
+    // While flying, locationIcao stays at the DEPARTURE airport — re-read state after landing.
+    await expect
+      .poll(async () => {
+        const s = await getState(page);
+        const plane = s.planes.find((x) => x.id === planeId);
+        if (plane?.status === 'flying' && s.simState.timeScale !== SCALE) await setScale(page, SCALE); // sibling landing re-slowed to 1×
+        return plane?.status ?? '';
+      }, {
+        timeout: 240_000,
+        message: `waiting for an in-flight ${planeId} to land`,
+      })
+      .toBe('available');
+    p = (await getState(page)).planes.find((x) => x.id === planeId)!;
+  }
+  if (p.locationIcao !== HUB) {
+    // ISS-057: the landing above slowed the sim to 1× — setScale restores 1000× for the return leg.
+    await setScale(page, SCALE);
+    let flyHome = await page.request.post(`/api/planes/${planeId}/fly`, { data: { destIcao: HUB } });
+    if (flyHome.status() === 409) {
+      // A long outbound leg can leave the tank too empty for the return — top up and retry.
+      expect((await page.request.post(`/api/planes/${planeId}/refuel`)).status()).toBe(200);
+      flyHome = await page.request.post(`/api/planes/${planeId}/fly`, { data: { destIcao: HUB } });
+    }
+    expect(flyHome.status()).toBe(200);
+    await expect
+      .poll(async () => ((await getState(page)).planes.find((x) => x.id === planeId)?.locationIcao ?? ''), {
+        timeout: 240_000,
+        message: `waiting for ${planeId} to land back at the hub`,
+      })
+      .toBe(HUB);
+  }
+}
+
+// Sell every non-starter plane (healing it home first if an interrupted run left it elsewhere or
+// in flight) — leaves the fleet at exactly one plane.
+async function sellNonStarters(page: Page): Promise<void> {
+  const s = await getState(page);
+  for (const p of s.planes.filter((x) => x.id !== STARTER)) {
+    await healPlaneHome(page, p.id); // grounded + at the hub before cargo can be abandoned / it sold
+    await abandonLeftoverCargo(page, p.id);
+    expect((await page.request.post('/api/market/sell-plane', { data: { planeId: p.id } })).status()).toBe(200);
+  }
+}
+
+// Canonical start state for every test: fleet of exactly one plane (the starter), grounded at EDDF,
+// no cargo on board — even after an interrupted previous run.
+async function resetFleet(page: Page): Promise<void> {
+  await sellNonStarters(page);
+  await healPlaneHome(page, STARTER);
+  await abandonLeftoverCargo(page, STARTER);
+}
+
+test.describe.configure({ mode: 'serial' }); // shared live DB — order matters within this file
+
+// Leave the fleet at exactly one plane and restore sane sim controls for the other specs.
+test.beforeEach(async ({ page }) => {
+  await resetFleet(page);
+});
+
+test.afterEach(async ({ page }) => {
+  await sellNonStarters(page); // a failure mid-test may have left the second plane behind (even in flight)
+  const res = await postSim(page, { timeScale: 1, paused: false });
+  expect(res.status()).toBe(200);
+});
+
+test('two grounded planes: Load is one-click with a preselected plane; the picker routes to the other', async ({ page }) => {
+  test.setTimeout(300_000); // self-heal can take minutes after an interrupted run
+  const secondId = await buySecondPlaneViaUi(page); // both grounded at EDDF — bought planes spawn at HUB
+  await page.getByTestId('tab-jobs').click(); // purchase left us on Planes-market; package rows live in Jobs (tabs unmount inactive content)
+
+  const [nearest] = await twoNearestToHub(page);
+  // Forced light weight (500 kg) so the package fits BOTH ATRs' payload deterministically.
+  const pkg1 = await createPackage(page, HUB, nearest.icao, 24 * 3_600_000, 500);
+
+  // The multi-plane picker lists BOTH planes…
+  const picker = page.getByTestId(`load-plane-${pkg1.id}`);
+  await expect(picker).toBeVisible({ timeout: 15_000 });
+  await expect(picker.locator(`option[value="${STARTER}"]`)).toHaveCount(1, { timeout: 15_000 });
+  await expect(picker.locator(`option[value="${secondId}"]`)).toHaveCount(1);
+
+  // …and PRESELECTS the first eligible plane — Load is enabled without touching the select (ISS-055).
+  const s0 = await getState(page);
+  const firstEligible = s0.planes.find((p) => p.status === 'available' && p.locationIcao === HUB)!;
+  await expect(picker, 'the picker preselects the first eligible plane').toHaveValue(firstEligible.id);
+  const loadBtn1 = page.getByTestId(`load-${pkg1.id}`);
+  await expect(loadBtn1, 'Load is enabled without a manual pick').toBeEnabled();
+
+  // One-click Load binds the package to the preselected (first eligible) plane.
+  await loadBtn1.click();
+  await expect
+    .poll(async () => {
+      const p = (await getState(page)).packages.find((x) => x.id === pkg1.id);
+      return !!p && p.status === 'loaded' ? p.planeId : null;
+    }, { timeout: 15_000, message: 'waiting for the package to load onto a plane' })
+    .toBe(firstEligible.id);
+
+  // Second package — pick the OTHER plane explicitly via the dropdown.
+  const pkg2 = await createPackage(page, HUB, nearest.icao, 24 * 3_600_000, 500);
+  const picker2 = page.getByTestId(`load-plane-${pkg2.id}`);
+  await expect(picker2).toBeVisible({ timeout: 15_000 });
+  await picker2.selectOption(secondId);
+  await page.getByTestId(`load-${pkg2.id}`).click();
+  await expect
+    .poll(async () => {
+      const p = (await getState(page)).packages.find((x) => x.id === pkg2.id);
+      return !!p && p.status === 'loaded' ? p.planeId : null;
+    }, { timeout: 15_000, message: 'waiting for the second package to load onto a plane' })
+    .toBe(secondId);
+
+  // Both planes carry cargo simultaneously — both fleet rows render their cargo (ISS-054).
+  await expect(page.getByTestId(`plane-${STARTER}`), 'the starter row renders').toBeVisible({ timeout: 15_000 });
+  await expect(page.getByTestId(`plane-${secondId}`), 'the second plane row renders').toBeVisible({ timeout: 15_000 });
+});
+
+test('two planes fly in parallel; the last landing slows to 1× and the next dispatch resumes', async ({ page }) => {
+  test.setTimeout(300_000); // self-heal + one long leg each way at scale 1000
+  const secondId = await buySecondPlaneViaUi(page);
+
+  // Full tanks for both — the starter's may be partial from an earlier run.
+  expect((await page.request.post(`/api/planes/${STARTER}/refuel`)).status()).toBe(200);
+  expect((await page.request.post(`/api/planes/${secondId}/refuel`)).status()).toBe(200);
+
+  // Two very different leg lengths: the starter takes the SHORTEST hop, the second plane the longest
+  // full-tank-flyable one — their landings are separated by hours of game time and can never fall on
+  // the same tick (ISS-057 slows to 1× on ANY landing, so a shared-tick arrival would race the asserts).
+  const [nearest] = await twoNearestToHub(page);
+  const farthest = await farthestFlyableToHub(page);
+
+  const pkgA = await createPackage(page, HUB, nearest.icao, 24 * 3_600_000, 500);
+  const pkgB = await createPackage(page, HUB, farthest.icao, 24 * 3_600_000, 500);
+  expect((await page.request.post(`/api/packages/${pkgA.id}/load`, { data: { planeId: STARTER } })).status()).toBe(200);
+  expect((await page.request.post(`/api/packages/${pkgB.id}/load`, { data: { planeId: secondId } })).status()).toBe(200);
+
+  const flyA = await page.request.post(`/api/planes/${STARTER}/fly`, { data: { destIcao: nearest.icao } });
+  expect(flyA.status()).toBe(200);
+  const flyB = await page.request.post(`/api/planes/${secondId}/fly`, { data: { destIcao: farthest.icao } });
+  expect(flyB.status()).toBe(200);
+
+  // Both are flying to their destinations (the second /fly response snapshot is authoritative).
+  const s1 = (await flyB.json()) as StateBody;
+  expect(s1.planes.find((p) => p.id === STARTER)?.status).toBe('flying');
+  expect(s1.planes.find((p) => p.id === STARTER)?.destIcao).toBe(nearest.icao);
+  expect(s1.planes.find((p) => p.id === secondId)?.status).toBe('flying');
+  expect(s1.planes.find((p) => p.id === secondId)?.destIcao).toBe(farthest.icao);
+
+  // Fast-forward to the FIRST landing (the short hop)…
+  await setScale(page, SCALE);
+  await expect
+    .poll(async () => ((await getState(page)).planes.some((p) => p.status === 'available')), {
+      timeout: 240_000,
+      message: 'waiting for the first plane to land',
+    })
+    .toBe(true);
+
+  // …restore speed (that landing slowed the sim to 1× — ISS-057) so the long leg fast-forwards too.
+  await setScale(page, SCALE);
+  await expect
+    .poll(async () => ((await getState(page)).planes.every((p) => p.status === 'available')), {
+      timeout: 240_000,
+      message: 'waiting for both planes to land',
+    })
+    .toBe(true);
+
+  // ISS-057: the LAST landing left a grounded plane → the sim slowed to 1× WITHOUT pausing.
+  const landed = await getState(page);
+  expect(landed.simState.paused).toBe(false);
+  expect(landed.simState.timeScale).toBe(1);
+  // Both packages delivered on arrival (in deadline — 24h window vs hours of flight time).
+  expect(landed.packages.find((p) => p.id === pkgA.id)?.status).toBe('delivered');
+  expect(landed.packages.find((p) => p.id === pkgB.id)?.status).toBe('delivered');
+
+  // The outbound to the range edge left the tank nearly empty — top up for the return leg.
+  expect((await page.request.post(`/api/planes/${secondId}/refuel`)).status()).toBe(200);
+
+  // Resume semantics: with the starter still grounded, dispatching the second plane does NOT resume…
+  const flyB2 = await page.request.post(`/api/planes/${secondId}/fly`, { data: { destIcao: HUB } });
+  expect(flyB2.status()).toBe(200);
+  let body = (await flyB2.json()) as StateBody;
+  expect(body.simState.timeScale, 'another plane still grounded → stays at 1×').toBe(1);
+
+  // …but dispatching the LAST grounded plane restores the last manually selected speed.
+  const flyA2 = await page.request.post(`/api/planes/${STARTER}/fly`, { data: { destIcao: HUB } });
+  expect(flyA2.status()).toBe(200);
+  body = (await flyA2.json()) as StateBody;
+  expect(body.simState.timeScale, 'the last grounded plane resumes lastSelectedTimeScale').toBe(SCALE); // setScale posted 1000
+});
+
+test('refuel section lists both planes; refueling one tops only its tank', async ({ page }) => {
+  test.setTimeout(300_000); // self-heal + two short hops at scale 1000
+  const secondId = await buySecondPlaneViaUi(page);
+
+  // Partial tanks: a short hop each, to different destinations.
+  const [a, b] = await twoNearestToHub(page);
+  expect((await page.request.post(`/api/planes/${STARTER}/refuel`)).status()).toBe(200);
+  expect((await page.request.post(`/api/planes/${secondId}/refuel`)).status()).toBe(200);
+  expect((await page.request.post(`/api/planes/${STARTER}/fly`, { data: { destIcao: a.icao } })).status()).toBe(200);
+  expect((await page.request.post(`/api/planes/${secondId}/fly`, { data: { destIcao: b.icao } })).status()).toBe(200);
+
+  // Fast-forward to the first landing, restore speed (ISS-057 slows on any landing), then wait for both.
+  await setScale(page, SCALE);
+  await expect
+    .poll(async () => ((await getState(page)).planes.some((p) => p.status === 'available')), {
+      timeout: 240_000,
+      message: 'waiting for the first plane to land',
+    })
+    .toBe(true);
+  await setScale(page, SCALE);
+  await expect
+    .poll(async () => ((await getState(page)).planes.every((p) => p.status === 'available')), {
+      timeout: 240_000,
+      message: 'waiting for both planes to land',
+    })
+    .toBe(true);
+
+  const pre = await getState(page);
+  const starter = pre.planes.find((p) => p.id === STARTER)!;
+  const second = pre.planes.find((p) => p.id === secondId)!;
+  expect(starter.fuel, 'the hop burned fuel').toBeLessThan(starter.maxFuel);
+  expect(second.fuel, 'the hop burned fuel').toBeLessThan(second.maxFuel);
+
+  // The left-pane Refuel section lists BOTH grounded planes with partial tanks…
+  const refuelSelect = page.getByTestId('market-refuel-plane');
+  await expect(refuelSelect).toBeVisible({ timeout: 15_000 });
+  await expect(refuelSelect.locator(`option[value="${STARTER}"]`)).toHaveCount(1);
+  await expect(refuelSelect.locator(`option[value="${secondId}"]`)).toHaveCount(1);
+
+  // …select the SECOND plane — the preview is its exact fill-up cost (mirrors refuelPlane 'full').
+  const expectedCost = Math.round((second.maxFuel - second.fuel) * pre.fuelPricePerL * 100) / 100;
+  await refuelSelect.selectOption(secondId);
+  await expect(page.getByTestId('market-refuel-cost')).toContainText(eur(expectedCost));
+
+  await page.getByTestId('market-refuel').click();
+  await expect
+    .poll(async () => {
+      const s = await getState(page);
+      return Math.abs(s.account.cash - (pre.account.cash - expectedCost)) < 0.001;
+    }, { timeout: 15_000, message: 'waiting for the refuel cost to land in /api/state' })
+    .toBe(true);
+
+  const post = await getState(page);
+  expect(post.planes.find((p) => p.id === secondId)!.fuel, 'that tank is full').toBe(second.maxFuel);
+  expect(post.planes.find((p) => p.id === STARTER)!.fuel, 'the other tank is untouched').toBe(starter.fuel);
+});
+
+test('relocate section moves one plane without touching the other', async ({ page }) => {
+  test.setTimeout(300_000); // self-heal + one short hop at scale 1000
+  const secondId = await buySecondPlaneViaUi(page); // both grounded at EDDF
+
+  const [a] = await twoNearestToHub(page); // relocation destination for the second plane
+
+  // The Relocate section lists BOTH grounded planes…
+  const relocateSelect = page.getByTestId('relocate-plane');
+  await expect(relocateSelect).toBeVisible({ timeout: 15_000 });
+  await expect(relocateSelect.locator(`option[value="${STARTER}"]`)).toHaveCount(1);
+  await expect(relocateSelect.locator(`option[value="${secondId}"]`)).toHaveCount(1);
+
+  // LeftPane's own /api/airports fetch populates the destination select — wait for it.
+  const destSelect = page.getByTestId('relocate-dest');
+  await expect(destSelect.locator(`option[value="${a.icao}"]`)).toHaveCount(1, { timeout: 15_000 });
+
+  // Relocate ONLY the second plane…
+  await relocateSelect.selectOption(secondId);
+  await destSelect.selectOption(a.icao);
+  await page.getByTestId('relocate-go').click();
+
+  // …it is flying to the new airport while the starter stays put at EDDF.
+  await expect
+    .poll(async () => {
+      const s = await getState(page);
+      return (s.planes.find((p) => p.id === secondId)?.status ?? '') === 'flying' &&
+        (s.planes.find((p) => p.id === STARTER)?.locationIcao ?? '') === HUB;
+    }, { timeout: 15_000, message: 'waiting for the relocation to take effect' })
+    .toBe(true);
+
+  // Let it land — locationIcao flips to the destination on arrival.
+  await setScale(page, SCALE);
+  await expect
+    .poll(async () => ((await getState(page)).planes.find((p) => p.id === secondId)?.locationIcao ?? ''), {
+      timeout: 240_000,
+      message: `waiting for the relocated plane to land at ${a.icao}`,
+    })
+    .toBe(a.icao);
+
+  const s = await getState(page);
+  expect(s.planes.find((p) => p.id === secondId)!.status).toBe('available');
+  expect(s.planes.find((p) => p.id === STARTER)!.locationIcao, 'the starter is untouched').toBe(HUB);
+});
+
+test('per-plane queues are independent; landing auto-chains the next queued leg', async ({ page }) => {
+  test.setTimeout(300_000); // self-heal + two chained legs at scale 1000
+  const secondId = await buySecondPlaneViaUi(page);
+  const [a, b] = await twoNearestToHub(page);
+
+  // Full tank for the starter — it flies both legs (EDDF→a then the auto-chained a→b).
+  expect((await page.request.post(`/api/planes/${STARTER}/refuel`)).status()).toBe(200);
+
+  // Seed one queued leg per plane via the API so BOTH on-board blocks render…
+  expect((await page.request.post(`/api/planes/${STARTER}/queue`, { data: { destIcao: a.icao } })).status()).toBe(200);
+  expect((await page.request.post(`/api/planes/${secondId}/queue`, { data: { destIcao: b.icao } })).status()).toBe(200);
+
+  // …each block shows its own seeded leg row under plane-scoped testids (ISS-055)…
+  const starterLeg0 = page.getByTestId(`queue-leg-${STARTER}-0`);
+  await expect(starterLeg0, 'the starter block renders its queued leg').toContainText(a.icao, { timeout: 15_000 });
+  await expect(page.getByTestId(`queue-leg-${secondId}-0`), 'the second block renders its queued leg').toContainText(b.icao);
+
+  // …and ADD a second leg to the STARTER via the API — the dedicated queue-add UI was removed in
+  // ISS-053 (fly-to / Relocate cover it), and the starter is grounded here so fly-to would start, not queue.
+  expect((await page.request.post(`/api/planes/${STARTER}/queue`, { data: { destIcao: b.icao } })).status()).toBe(200);
+  await expect(page.getByTestId(`queue-leg-${STARTER}-1`), 'the second leg is queued on the STARTER').toContainText(b.icao, { timeout: 15_000 });
+
+  // CANCEL the only leg on the SECOND plane — its queue empties, the starter's stays intact.
+  await page.getByTestId(`queue-cancel-${secondId}-0`).click();
+  await expect(page.getByTestId(`queue-leg-${secondId}-0`), 'the cancelled leg is gone').toHaveCount(0, { timeout: 15_000 });
+  await expect(starterLeg0, 'the starter queue is untouched by the other plane cancel').toContainText(a.icao);
+
+  // Fly the STARTER to its first queued destination…
+  const flyRes = await page.request.post(`/api/planes/${STARTER}/fly`, { data: { destIcao: a.icao } });
+  expect(flyRes.status()).toBe(200);
+
+  // …fast-forward; on landing at a the server AUTO-CHAINS queue[0] (b) in the same tick — but with
+  // the second plane still grounded, ISS-057 slows the sim to 1× on that landing. Wait for the chain…
+  await setScale(page, SCALE);
+  await expect
+    .poll(async () => {
+      const p = (await getState(page)).planes.find((x) => x.id === STARTER);
+      return !!p && p.status === 'flying' && p.destIcao === b.icao;
+    }, { timeout: 240_000, message: `waiting for the auto-chained leg ${a} → ${b} to start` })
+    .toBe(true);
+
+  // …then restore speed so the chained leg fast-forwards too.
+  await setScale(page, SCALE);
+  await expect
+    .poll(async () => {
+      const p = (await getState(page)).planes.find((x) => x.id === STARTER);
+      return !!p && p.status === 'available' && p.locationIcao === b.icao;
+    }, { timeout: 240_000, message: `waiting for the chained leg to land at ${b}` })
+    .toBe(true);
+
+  // The second plane never moved — still grounded at EDDF with an empty queue.
+  const s = await getState(page);
+  expect(s.planes.find((p) => p.id === secondId)!.status).toBe('available');
+  expect(s.planes.find((p) => p.id === secondId)!.locationIcao).toBe(HUB);
+});
+
+test('sell section lists both planes; selling one pays out and the last plane is protected', async ({ page }) => {
+  test.setTimeout(300_000); // self-heal can take minutes after an interrupted run
+  const secondId = await buySecondPlaneViaUi(page); // both grounded at EDDF
+
+  const pre = await getState(page); // authoritative catalog + economy constants (v0.10.0)
+  const entry = pre.catalog.find((e) => e.model === BUY_MODEL)!;
+  const payout = Math.round(entry.price * pre.sellFraction * 100) / 100;
+
+  // The Sell row lists BOTH grounded planes…
+  const sellSelect = page.getByTestId('market-sell-plane');
+  await expect(sellSelect).toBeVisible({ timeout: 15_000 });
+  await expect(sellSelect.locator(`option[value="${STARTER}"]`)).toHaveCount(1);
+  await expect(sellSelect.locator(`option[value="${secondId}"]`)).toHaveCount(1);
+
+  // …sell the SECOND one — payout is SELL_FRACTION × price, fleet back to one plane.
+  await sellSelect.selectOption(secondId);
+  await expect(page.getByTestId('market-sell-payout')).toContainText(eur(payout));
+  await page.getByTestId('market-sell').click();
+
+  await expect
+    .poll(async () => {
+      const s = await getState(page);
+      return Math.abs(s.account.cash - (pre.account.cash + payout)) < 0.001 && s.planes.length === 1;
+    }, { timeout: 15_000, message: 'waiting for the sell to land in /api/state' })
+    .toBe(true);
+
+  // The last remaining plane can never be sold — even via the API.
+  const res = await page.request.post('/api/market/sell-plane', { data: { planeId: STARTER } });
+  expect(res.status()).toBe(409);
+});

lib/game/actions.test.ts

@@ -261,6 +261,37 @@ describe('queueLeg (v0.25.0, ISS-043)', () => {
     const inst = await freshDb('qleg-unknownicao.db');
     await expectActionError(queueLeg(inst, 'plane-starter', 'ZZZZ'), 400, /unknown airport/);
   });
+
+  it('rejects a destination already in the queue with 409 (ISS-065)', async () => {
+    const inst = await freshDb('qleg-dup.db');
+    await queueLeg(inst, 'plane-starter', 'LEMD');
+
+    await expectActionError(queueLeg(inst, 'plane-starter', 'LEMD'), 409, /already in the flight queue/);
+
+    const plane = (await inst.db.select().from(schema.planes))[0];
+    expect(JSON.parse(plane.queue)).toEqual(['LEMD']); // rejected leg not appended
+  });
+
+  it('rejects re-queuing the active leg destination of a flying plane with 409 (ISS-065)', async () => {
+    const inst = await freshDb('qleg-dupflying.db');
+    await inst.db.update(schema.planes)
+      .set({ status: 'flying', departureSimTime: T0, destIcao: 'LEMD' })
+      .where(eq(schema.planes.id, 'plane-starter'));
+
+    await expectActionError(queueLeg(inst, 'plane-starter', 'LEMD'), 409, /already flying to LEMD/);
+
+    const plane = (await inst.db.select().from(schema.planes))[0];
+    expect(JSON.parse(plane.queue)).toEqual([]); // rejected leg not appended
+  });
+
+  it('still appends a different known airport with success (ISS-065 sanity)', async () => {
+    const inst = await freshDb('qleg-dupother.db');
+    await queueLeg(inst, 'plane-starter', 'LEMD');
+    await expect(queueLeg(inst, 'plane-starter', 'EHAM')).resolves.toBeUndefined();
+
+    const plane = (await inst.db.select().from(schema.planes))[0];
+    expect(JSON.parse(plane.queue)).toEqual(['LEMD', 'EHAM']);
+  });
 });
 
 describe('cancelQueuedLeg (v0.25.0, ISS-043)', () => {

lib/game/actions.ts

@@ -153,7 +153,16 @@ export async function queueLeg(inst: GameDb, planeId: string, destIcao: string):
     throw new GameActionError(400, `unknown airport ${destIcao}`);
   }
 
+  // ISS-065: the same route can't be queued twice — re-queuing the active leg's destination or a
+  // leg already in the queue would only produce pointless repeated hops on landing.
+  if (plane.status === 'flying' && plane.destIcao === destIcao) {
+    throw new GameActionError(409, `already flying to ${destIcao}`);
+  }
+
   const queue = parseIcaoQueue(plane.queue);
+  if (queue.includes(destIcao)) {
+    throw new GameActionError(409, `${destIcao} is already in the flight queue`);
+  }
   queue.push(destIcao);
   await inst.db.update(schema.planes).set({ queue: JSON.stringify(queue) }).where(eq(schema.planes.id, planeId));
   await persist(inst);

lib/openapi.test.ts

@@ -202,7 +202,7 @@ describe('OpenAPI spec', () => {
     expect(errorCodes('/api/packages/{id}/load')).toEqual(['400', '404', '409']);
     expect(errorCodes('/api/packages/{id}/abandon')).toEqual(['404', '409']);
     expect(errorCodes('/api/planes/{planeId}/fly')).toEqual(['400', '404', '409']);
-    expect(errorCodes('/api/planes/{planeId}/queue')).toEqual(['400', '404']); // v0.25.0 — no 409: queueing works grounded or flying
+    expect(errorCodes('/api/planes/{planeId}/queue')).toEqual(['400', '404', '409']); // v0.34.0 (ISS-065) — 409 on duplicate leg / active-leg re-queue
     expect(errorCodes('/api/planes/{planeId}/queue/cancel')).toEqual(['400', '404']); // v0.25.0
     expect(errorCodes('/api/market/buy-plane')).toEqual(['400', '409']);
     expect(errorCodes('/api/market/sell-plane')).toEqual(['400', '404', '409']);

lib/openapi.ts

@@ -260,6 +260,11 @@ export const openApiSpec = {
             description: 'Unknown plane id',
             content: { 'application/json': { schema: { $ref: '#/components/schemas/Error' } } },
           },
+          409: {
+            description:
+              'The destination is already in the flight queue, or (while flying) it equals the active leg\'s destination (v0.34.0, ISS-065)',
+            content: { 'application/json': { schema: { $ref: '#/components/schemas/Error' } } },
+          },
         },
       },
     },

package.json

@@ -1,6 +1,6 @@
 {
   "name": "flight-ops",
-  "version": "0.30.0",
+  "version": "0.34.0",
   "private": true,
   "scripts": {
     "dev": "next dev -p 3000",