@tribe-nest/forge 3.57.0 → 3.59.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tribe-nest/forge",
-  "version": "3.57.0",
+  "version": "3.59.0",
   "publishConfig": {
     "access": "public"
   },
@@ -31,9 +31,11 @@
     "@stripe/react-stripe-js": "^3.8.0",
     "@stripe/stripe-js": "^7.6.1",
     "@tanstack/react-query": "^5.62.7",
-    "@tribe-nest/media-client": "^0.4.0",
+    "@tribe-nest/media-client": "^0.5.0",
     "@tribe-nest/media-protocol": "^1.0.0",
+    "@tribe-nest/seating-core": "^1.0.0",
     "axios": "^1.7.9",
+    "libphonenumber-js": "^1.13.13",
     "lucide-react": "^0.510.0",
     "react-hook-form": "^7.60.0",
     "react-markdown": "^10.1.0",

package/src/_tests/workspaceAliases.ts

@@ -34,6 +34,7 @@ export const WORKSPACE_SOURCE_ALIASES: { find: RegExp; replacement: string }[] =
   ["@tribe-nest/media-client/protocol", "../../../media-client/src/protocol.ts"],
   ["@tribe-nest/media-protocol", "../../../media-protocol/src/index.ts"],
   ["@tribe-nest/media-protocol/token", "../../../media-protocol/src/token.ts"],
+  ["@tribe-nest/seating-core", "../../../seating-core/src/index.ts"],
 ].map(([specifier, path]) => ({
   find: new RegExp(`^${specifier!.replace(/[/\\^$*+?.()|[\]{}]/g, "\\$&")}$`),
   replacement: fileURLToPath(new URL(path!, import.meta.url)),

package/src/contexts/CartContext.tsx

@@ -75,6 +75,29 @@ export type CartItem = {
  * whole existing shop, on both rendering stacks, is unaffected; the two places
  * that genuinely need both (the cart panel and checkout) read both lists.
  */
+/** One seat a cart line holds, with the label every surface prints. */
+export type CartSeat = { id: string; label: string };
+
+/**
+ * Display and order data for one tier of a ticket selection.
+ *
+ * `seatIds` and `seats` are present on a RESERVED-SEATING tier only: the
+ * event seat ids the buyer picked on the map (what the bundle checkout sends
+ * as the line's `seatIds`, in this order) and the same seats with the labels
+ * the cart, the checkout summary and the confirmation print ("Stalls · Row A
+ * · Seat 12"). The line's quantity IS `seatIds.length` on such a tier, so the
+ * cart never offers a stepper for it: changing seats happens on the event
+ * page. Absent on a general admission tier, and on carts saved before seats
+ * could ride in them.
+ */
+export type TicketCartLineMeta = {
+  title: string;
+  price: number;
+  pwywAmount?: number;
+  seatIds?: string[];
+  seats?: CartSeat[];
+};
+
 export type TicketCartItem = {
   eventId: string;
   eventSlug: string;
@@ -92,7 +115,7 @@ export type TicketCartItem = {
    * endpoint treats a line's `price` as display-only and never charges it; the
    * chosen amount has to arrive in a field the server actually reads.
    */
-  ticketMeta: Record<string, { title: string; price: number; pwywAmount?: number }>;
+  ticketMeta: Record<string, TicketCartLineMeta>;
   /**
    * The event's RESOLVED booking fee, captured when the modal put the tickets
    * here, so the cart checkout can show the fee line the buyer will be charged
@@ -142,6 +165,17 @@ interface CartContextType {
   setTickets: (item: TicketCartItem) => void;
   /** Drops the selection AND every add-on attached to that event. */
   removeTickets: (eventId: string) => void;
+  /**
+   * Take named seats OUT of an event's selection, without opening the drawer.
+   *
+   * The bundle checkout calls this when seats in the cart were taken by
+   * another buyer: the taken seats leave their tier line (its quantity is its
+   * seat count, so it shrinks with them), a tier left with no seat leaves the
+   * selection, and an event left with no tier leaves the cart with its add-ons,
+   * exactly as `removeTickets` would. Seats are never substituted here: the
+   * buyer goes back to the event's picker to choose again.
+   */
+  removeTicketSeats: (eventId: string, seatIds: string[]) => void;
   hasTicketsFor: (eventId: string) => boolean;
   /** Products + tickets, for the header badge. */
   itemCount: number;
@@ -175,6 +209,40 @@ function readAddonContext(): AttachedTo | undefined {
   }
 }
 
+/**
+ * An event's selection with `seatIds` taken out of it, or `null` when nothing
+ * is left. Pure, so the checkout's tests can assert it without a provider.
+ *
+ * A tier's quantity follows its seat count, because on a seated tier the two
+ * are one number. A general admission tier (no `seatIds` on its meta) is never
+ * touched: the ids belong to a seated tier by construction.
+ */
+export function pruneSeatsFromTicketItem(item: TicketCartItem, seatIds: readonly string[]): TicketCartItem | null {
+  const gone = new Set(seatIds);
+  const tickets: Record<string, number> = {};
+  const ticketMeta: Record<string, TicketCartLineMeta> = {};
+  for (const [ticketId, qty] of Object.entries(item.tickets)) {
+    const meta = item.ticketMeta[ticketId];
+    if (!meta?.seatIds) {
+      if (qty > 0) {
+        tickets[ticketId] = qty;
+        if (meta) ticketMeta[ticketId] = meta;
+      }
+      continue;
+    }
+    const keptIds = meta.seatIds.filter((id) => !gone.has(id));
+    if (keptIds.length === 0) continue;
+    tickets[ticketId] = keptIds.length;
+    ticketMeta[ticketId] = {
+      ...meta,
+      seatIds: keptIds,
+      seats: (meta.seats ?? []).filter((seat) => !gone.has(seat.id)),
+    };
+  }
+  if (Object.keys(tickets).length === 0) return null;
+  return { ...item, tickets, ticketMeta };
+}
+
 export function CartProvider({ children }: { children: ReactNode }) {
   const [cartItems, setCartItems] = useState<CartItem[]>([]);
   const [ticketItems, setTicketItems] = useState<TicketCartItem[]>([]);
@@ -339,10 +407,24 @@ export function CartProvider({ children }: { children: ReactNode }) {
     setCartItems((prev) => prev.filter((i) => i.attachedTo?.entityId !== eventId));
   }, []);
 
-  const hasTicketsFor = useCallback(
-    (eventId: string) => ticketItems.some((t) => t.eventId === eventId),
-    [ticketItems],
-  );
+  const removeTicketSeats = useCallback((eventId: string, seatIds: string[]) => {
+    let emptied = false;
+    setTicketItems((prev) =>
+      prev.flatMap((item) => {
+        if (item.eventId !== eventId) return [item];
+        const next = pruneSeatsFromTicketItem(item, seatIds);
+        if (next) return [next];
+        emptied = true;
+        return [];
+      }),
+    );
+    // The add-ons go with the base, as in `removeTickets`. Read from the
+    // flatMap above rather than from `ticketItems`, so a stale closure cannot
+    // keep an orphaned add-on that the server would refuse.
+    setCartItems((prev) => (emptied ? prev.filter((i) => i.attachedTo?.entityId !== eventId) : prev));
+  }, []);
+
+  const hasTicketsFor = useCallback((eventId: string) => ticketItems.some((t) => t.eventId === eventId), [ticketItems]);
 
   const clearCart = () => {
     setCartItems([]);
@@ -371,6 +453,7 @@ export function CartProvider({ children }: { children: ReactNode }) {
         ticketItems,
         setTickets,
         removeTickets,
+        removeTicketSeats,
         hasTicketsFor,
         itemCount,
         isBundle,

package/src/data/queries/useCallBreakouts.ts

@@ -0,0 +1,112 @@
+import { useQuery, useQueryClient } from "@tanstack/react-query";
+import { useCallback, useMemo, useState } from "react";
+
+import type { BreakoutParticipant, BreakoutRoomSummary, CallStageBreakouts } from "../../ui/media/callBreakouts";
+import { useForge } from "../../provider/ForgeProvider";
+
+/**
+ * The PUBLIC lane's `CallStageBreakouts` adapter: the reference implementation
+ * of the shape the stage renders.
+ *
+ * Everything hangs off the CALL's address (`/video-calls/:id/breakouts`): one
+ * GET describes the rooms and this seat's place in them, and every mutation
+ * answers with the same describe, so the query is replaced from the response
+ * rather than refetched (a refetch as well would race it). Admin composes its
+ * own adapter against the dashboard's client; the SHAPE is the seam.
+ *
+ * ## Who polls
+ *
+ * The host's view carries live counts that come from the media plane, so the
+ * host polls every few seconds. An attendee's list is a handful of names that
+ * change only when the host acts, and there can be forty of them: they read
+ * once, and the stage calls `refresh()` when the rooms tab is open and after
+ * every reconnect (which is what a move is), so they are never stale where it
+ * matters and never a request per viewer per few seconds where it does not.
+ */
+
+/** The server's describe, the wire shape the adapter is built from. */
+export type CallBreakoutsDescribe = {
+  canManage: boolean;
+  active: boolean;
+  current: { publicId: string; name: string } | null;
+  main: { participantCount: number; participants: BreakoutParticipant[] };
+  rooms: BreakoutRoomSummary[];
+};
+
+export const CALL_BREAKOUTS_POLL_MS = 5000;
+
+/** The server's own sentence when it gave one, else the thrown error's. */
+export const breakoutErrorMessage = (cause: unknown): string => {
+  const response = (cause as { response?: { data?: { message?: unknown } } } | undefined)?.response;
+  const message = response?.data?.message;
+  if (typeof message === "string" && message.trim()) return message;
+  return cause instanceof Error && cause.message ? cause.message : "";
+};
+
+export function useCallBreakouts(callId: string | undefined): CallStageBreakouts | undefined {
+  const { client } = useForge();
+  const queryClient = useQueryClient();
+  const [pending, setPending] = useState(false);
+
+  const queryKey = useMemo(() => ["call-breakouts", callId] as const, [callId]);
+  const base = `/video-calls/${callId}/breakouts`;
+
+  const query = useQuery<CallBreakoutsDescribe>({
+    queryKey,
+    queryFn: async () => (await client.get(base)).data,
+    enabled: !!callId && !!client,
+    // Only the host's view has live numbers in it. See the docblock.
+    refetchInterval: (state) => (state.state.data?.canManage ? CALL_BREAKOUTS_POLL_MS : false),
+  });
+
+  const act = useCallback(
+    async (request: () => Promise<{ data: CallBreakoutsDescribe }>) => {
+      setPending(true);
+      try {
+        const res = await request();
+        queryClient.setQueryData(queryKey, res.data);
+      } catch (cause) {
+        throw new Error(breakoutErrorMessage(cause));
+      } finally {
+        setPending(false);
+      }
+    },
+    [queryClient, queryKey],
+  );
+
+  const create = useCallback(
+    (input: { count: number; assign: "auto" | "manual" }) => act(() => client.post(base, input)),
+    [act, client, base],
+  );
+  const assign = useCallback(
+    (identity: string, roomPublicId: string | null) => act(() => client.put(`${base}/assignment`, { identity, roomPublicId })),
+    [act, client, base],
+  );
+  const moveSelf = useCallback(
+    (roomPublicId: string | null) => act(() => client.put(`${base}/me`, { roomPublicId })),
+    [act, client, base],
+  );
+  const closeAll = useCallback(() => act(() => client.delete(base)), [act, client, base]);
+  const refresh = useCallback(() => {
+    void queryClient.invalidateQueries({ queryKey });
+  }, [queryClient, queryKey]);
+
+  return useMemo<CallStageBreakouts | undefined>(() => {
+    if (!callId) return undefined;
+    const data = query.data;
+    return {
+      ready: !!data,
+      canManage: data?.canManage ?? false,
+      active: data?.active ?? false,
+      current: data?.current ?? null,
+      main: data?.main ?? { participantCount: 0, participants: [] },
+      rooms: data?.rooms ?? [],
+      pending,
+      create,
+      assign,
+      moveSelf,
+      closeAll,
+      refresh,
+    };
+  }, [callId, query.data, pending, create, assign, moveSelf, closeAll, refresh]);
+}

package/src/data/queries/useCheckouts.ts

@@ -34,6 +34,14 @@ export type CheckoutLineInput =
        * server clamps it against the tier's floor).
        */
       pwywAmount?: number;
+      /**
+       * The EVENT seat ids the buyer picked, on a reserved-seating tier only:
+       * exactly `quantity` of them, in the order chosen. The server refuses a
+       * seated tier's line without them (400 `seats_required`) and answers 409
+       * `SEATS_TAKEN` with `details.eventSeatIds` when any has gone to another
+       * buyer since. Absent on a general admission tier.
+       */
+      seatIds?: string[];
       title: string;
       coverImage?: string;
     };
@@ -57,8 +65,13 @@ export function cartToCheckoutLines(cartItems: CartItem[], ticketItems: TicketCa
         // display-only and never charges. This is the field the server forwards
         // into the ticket order — dropping it would charge the tier's floor and
         // still return 200, so the buyer would be quietly undercharged.
-        ...(t.ticketMeta[ticketId]?.pwywAmount != null
-          ? { pwywAmount: t.ticketMeta[ticketId]?.pwywAmount }
+        ...(t.ticketMeta[ticketId]?.pwywAmount != null ? { pwywAmount: t.ticketMeta[ticketId]?.pwywAmount } : {}),
+        // The seats ride on the line: a seated tier's order is created FROM
+        // this, and without them the server would either refuse the line or
+        // (on an older build) seat the buyer anywhere, which is the one thing
+        // a buyer who chose on a map must never get silently.
+        ...((t.ticketMeta[ticketId]?.seatIds?.length ?? 0) > 0
+          ? { seatIds: [...t.ticketMeta[ticketId]!.seatIds!] }
           : {}),
         title: t.ticketMeta[ticketId]?.title ?? t.eventTitle,
         coverImage: t.coverImage,

package/src/data/queries/useEvents.ts

@@ -1,4 +1,5 @@
 import type { AppliedDiscountCoupon, IEvent } from "../../types/models";
+import type { SeatAttributes, SeatMapDocument } from "@tribe-nest/seating-core";
 import { useForge } from "../../provider/ForgeProvider";
 import { useMutation, useQuery } from "@tanstack/react-query";
 
@@ -81,8 +82,75 @@ export function useEvent(
   });
 }
 
+/**
+ * One sellable seat of an event, as the public seating read publishes it.
+ *
+ * `id` is the EVENT seat (what an order names); `sourceSeatId` is the seat's id
+ * inside the frozen layout, which is how a renderer joins it to a `<circle>`.
+ * Held, sold and blocked all read `unavailable`: a buyer must not be able to
+ * tell a house seat from a sold one.
+ */
+export type PublicEventSeat = {
+  id: string;
+  sourceSeatId: string;
+  eventTicketId: string;
+  status: "available" | "unavailable";
+  attributes: SeatAttributes;
+};
+
+/** `GET /public/events/:id/seating`. `null` when the event has no seat map. */
+export type PublicEventSeating = {
+  /** The layout frozen at bind time. Coordinates are absolute and baked. */
+  layout: SeatMapDocument;
+  /** Layout category key -> the ticket tier that prices it for this event. */
+  tierMapping: Record<string, string>;
+  seats: PublicEventSeat[];
+};
+
+/**
+ * The seat map and live availability for a reserved-seating event.
+ *
+ * `Cache-Control: no-store` on the server, and `pollMs` here, because the
+ * whole value of the read is that it is CURRENT: a seat somebody else took ten
+ * seconds ago must not still look free. Disabled (no request at all) unless
+ * `enabled`, so an event page that never opens the picker never polls.
+ */
+export function useEventSeatingQuery(
+  eventId?: string,
+  options: {
+    enabled?: boolean;
+    /** Refetch interval while enabled. `false` (or 0) polls nothing. */
+    pollMs?: number | false;
+  } = {},
+) {
+  const { client, profileId } = useForge();
+  const enabled = (options.enabled ?? true) && !!eventId && !!profileId && !!client;
+  return useQuery<PublicEventSeating | null>({
+    queryKey: ["event-seating", eventId, profileId],
+    queryFn: async () => {
+      const res = await client.get(`/public/events/${eventId}/seating`, { params: { profileId } });
+      // An empty body (204, or an older API with no route) reads as "no map".
+      return (res.data ?? null) as PublicEventSeating | null;
+    },
+    enabled,
+    staleTime: 0,
+    refetchInterval: enabled && options.pollMs ? options.pollMs : false,
+  });
+}
+
 export type CreateEventOrderInput = {
   items: Record<string, number>;
+  /**
+   * ticketId -> the EVENT seat ids (`PublicEventSeat.id`) the buyer picked, for
+   * every tier that sells reserved seats (seating wave 2).
+   *
+   * A seated tier requires exactly `items[ticketId]` seats; a general
+   * admission tier must not carry any. Omit the key entirely on an event with
+   * no seat map, so an ordinary purchase posts the body it always did. A 409
+   * `errors.event.seats_taken` with `details.eventSeatIds` means those seats
+   * went to somebody else between the read and the order.
+   */
+  seats?: Record<string, string[]>;
   /**
    * ticketId → the buyer's chosen amount, PER UNIT, on a pay-what-you-want
    * tier. Ignored server-side for any tier that is not PWYW, and clamped up to

package/src/data/queries/useMyBookings.ts

@@ -122,6 +122,22 @@ export type MyBooking = {
   /** The server's answer. Never recomputed here. */
   canReschedule: boolean;
   rescheduleReason: RescheduleRefusal | null;
+  /**
+   * The last instant a self-service move is allowed (ISO), or null when it is
+   * not allowed at all. Optional: an older API build does not emit it.
+   */
+  rescheduleDeadline?: string | null;
+  /**
+   * The reschedule rule this booking was sold under. `followsCancellation` is
+   * true when the coach set no reschedule policy, so the cancellation window
+   * governs moves and its sentence already covers it. Optional, as above.
+   */
+  reschedulePolicy?: {
+    policy: "none" | "until" | "anytime";
+    cutoffHours: number | null;
+    followsCancellation: boolean;
+    description: string | null;
+  };
   /**
    * The session's `.ics`, both forms — what lets the portal offer Apple
    * Calendar rather than only Google/Outlook/Microsoft 365. `null` unless the

package/src/data/queries/useNotifications.ts

@@ -5,7 +5,7 @@ import { useCallback, useEffect, useState } from "react";
 /**
  * Member notification headless hooks — the FROZEN public contract that the
  * apps/client PWA and every generated custom-code site consume. Speaks ONLY the
- * `/public/notifications/*` API (see docs/membership-notifications-initiative.md
+ * `/public/notifications/*` API (see docs/archive/shipped/membership-notifications-initiative.md
  * "API surface"). Moved here from apps/client so custom-code sites get push
  * subscription registration, inbox, and a settings matrix with no apps/client
  * code.

package/src/i18n/de.json

@@ -229,6 +229,7 @@
   "forge.bundle_confirmation.partial_body": "Deine Zahlung ist angekommen und ein Teil deiner Bestellung ist bestätigt. Den Rest schließen wir gerade ab. Er kommt gleich per E-Mail, ohne weitere Kosten für dich.",
   "forge.bundle_confirmation.partial_title": "Zahlung erhalten",
   "forge.bundle_confirmation.return_to_checkout": "Zurück zur Kasse",
+  "forge.bundle_confirmation.seats_title": "Deine Plätze",
   "forge.bundle_confirmation.summary_both": "In einem Schritt bezahlt. Deine Tickets kommen per E-Mail und deine Bestellung ist bestätigt.",
   "forge.bundle_confirmation.summary_order": "In einem Schritt bezahlt. Deine Bestellung ist bestätigt.",
   "forge.bundle_confirmation.summary_paid": "In einem Schritt bezahlt.",
@@ -236,6 +237,40 @@
   "forge.bundle_confirmation.tickets_emailed": "Tickets per E-Mail an dich unterwegs",
   "forge.bundle_confirmation.title": "Alles erledigt",
   "forge.bundle_confirmation.view_orders": "Bestellungen ansehen",
+  "forge.call_stage.breakouts.assign_auto": "Automatisch",
+  "forge.call_stage.breakouts.assign_label": "Personen zuweisen",
+  "forge.call_stage.breakouts.assign_manual": "Ich weise sie selbst zu",
+  "forge.call_stage.breakouts.assigned_not_arrived": "(unterwegs)",
+  "forge.call_stage.breakouts.button": "Räume",
+  "forge.call_stage.breakouts.close_all": "Alle Räume schließen",
+  "forge.call_stage.breakouts.close_cancel": "Offen lassen",
+  "forge.call_stage.breakouts.close_confirm": "Räume schließen",
+  "forge.call_stage.breakouts.close_confirm_body": "Alle kommen zurück in den Hauptraum, und die Räume werden geschlossen.",
+  "forge.call_stage.breakouts.count_label": "Anzahl der Räume",
+  "forge.call_stage.breakouts.create": "Räume erstellen",
+  "forge.call_stage.breakouts.create_title": "Gruppenräume",
+  "forge.call_stage.breakouts.current_marker": "Du bist hier",
+  "forge.call_stage.breakouts.empty_room": "Noch niemand hier",
+  "forge.call_stage.breakouts.error": "Das hat nicht geklappt. Versuche es noch einmal.",
+  "forge.call_stage.breakouts.help_attendee": "Die Gastgeberin oder der Gastgeber hat diesen Anruf in kleinere Räume aufgeteilt. Du wirst automatisch verschoben, Kamera und Mikrofon bleiben wie sie sind, und du kommst zurück in den Hauptraum, wenn die Räume geschlossen werden oder du auf Zurück in den Hauptraum drückst.",
+  "forge.call_stage.breakouts.help_attendee_label": "Was sind Gruppenräume?",
+  "forge.call_stage.breakouts.help_create": "Jeder Raum ist ein eigener Anruf unter diesem. Bei automatischer Zuweisung werden alle Anwesenden gleichmäßig auf die Räume verteilt und sofort verschoben; bei manueller Zuweisung bewegt sich niemand, bis du einen Raum für die Person wählst. Du kannst selbst jeden Raum betreten, und alle kommen zurück, wenn du die Räume schließt.",
+  "forge.call_stage.breakouts.help_create_label": "Was passiert, wenn ich Räume erstelle?",
+  "forge.call_stage.breakouts.help_join": "Beitreten bringt dich in diesen Raum; die anderen Räume laufen ohne dich weiter. Ein Raum neben einem Namen verschiebt diese Person, und eine Aufzeichnung, die du startest, folgt dem Raum, in dem du bist.",
+  "forge.call_stage.breakouts.help_join_label": "Wie wechsle ich zwischen Räumen?",
+  "forge.call_stage.breakouts.join": "Beitreten",
+  "forge.call_stage.breakouts.loading": "Räume werden geladen…",
+  "forge.call_stage.breakouts.main_room": "Hauptraum",
+  "forge.call_stage.breakouts.move_to_label": "{name} in einen Raum verschieben",
+  "forge.call_stage.breakouts.participant_count": "{count} in diesem Raum",
+  "forge.call_stage.breakouts.return_to_main": "Zurück zum Hauptraum",
+  "forge.call_stage.breakouts.return_to_main_room": "Zurück in den Hauptraum",
+  "forge.call_stage.breakouts.status_moving": "Du wirst in {room} verschoben",
+  "forge.call_stage.breakouts.status_moving_detail": "Kamera und Mikrofon bleiben wie sie sind.",
+  "forge.call_stage.breakouts.status_returning": "Du kommst zurück in den Hauptraum",
+  "forge.call_stage.breakouts.tab": "Räume",
+  "forge.call_stage.breakouts.you_are_in": "Du bist in {room}",
+  "forge.call_stage.breakouts.you_are_in_main": "Du bist im Hauptraum",
   "forge.call_stage.camera_start": "Kamera starten",
   "forge.call_stage.camera_stop": "Kamera stoppen",
   "forge.call_stage.chat": "Chat",
@@ -353,6 +388,7 @@
   "forge.cart.aria_remove_item": "Artikel entfernen",
   "forge.cart.aria_remove_tickets": "Tickets entfernen",
   "forge.cart.attached_to_tickets": "Mit deinen Tickets hinzugefügt",
+  "forge.cart.change_seats": "Plätze ändern",
   "forge.cart.checkout": "Zur Kasse",
   "forge.cart.empty_title": "Dein Warenkorb ist leer.",
   "forge.cart.gift_for": "Geschenk für {recipient_name} ({recipient_email})",
@@ -436,6 +472,10 @@
   "forge.checkout.rate_days": "({days} Tage)",
   "forge.checkout.rate_estimated_day": "Voraussichtlich {days} Tag",
   "forge.checkout.rate_estimated_days": "Voraussichtlich {days} Tage",
+  "forge.checkout.seats_conflict_action": "Andere Plätze wählen",
+  "forge.checkout.seats_conflict_body": "{seats} für {event_title} sind an jemand anderen gegangen. Wähle andere Plätze, um fortzufahren; der Rest deines Warenkorbs bleibt unverändert.",
+  "forge.checkout.seats_conflict_title": "Einige deiner Plätze wurden gerade vergeben",
+  "forge.checkout.seats_label": "Plätze: {seats}",
   "forge.checkout.shipping": "Versand",
   "forge.checkout.shipping_address_title": "Lieferadresse",
   "forge.checkout.shipping_options_title": "Versandoptionen",
@@ -809,6 +849,17 @@
   "forge.event_detail.not_found": "Event nicht gefunden.",
   "forge.event_detail.presale_only": "Tickets für dieses Event gibt es nur im Vorverkauf.",
   "forge.event_detail.price_from_label": "Ab",
+  "forge.event_seat_picker.dismiss": "Schließen",
+  "forge.event_seat_picker.empty": "Es gibt noch keine Plätze zur Auswahl.",
+  "forge.event_seat_picker.help_body": "Tippe auf einen Platz, um ihn auszuwählen, und noch einmal, um ihn freizugeben. Zoome mit zwei Fingern oder dem Mausrad und ziehe, um den Plan zu verschieben. Graue Plätze sind nicht verfügbar. Beste verfügbare wählt die niedrigsten zusammenhängenden Plätze für dich.",
+  "forge.event_seat_picker.help_label": "Wie wähle ich Plätze aus?",
+  "forge.event_seat_picker.loading": "Saalplan wird geladen",
+  "forge.event_seat_picker.max_reached": "Du hast die maximale Anzahl an Plätzen für {tier} erreicht.",
+  "forge.event_seat_picker.mix_blocked": "Dieser Platz kann deiner aktuellen Auswahl nicht hinzugefügt werden.",
+  "forge.event_seat_picker.seat_unavailable": "Dieser Platz ist nicht verfügbar.",
+  "forge.event_seat_picker.seats_taken_body": "{seats} sind an jemand anderen gegangen. Wähle erneut aus den noch verfügbaren Plätzen.",
+  "forge.event_seat_picker.seats_taken_title": "Einige deiner Plätze wurden gerade vergeben",
+  "forge.event_seat_picker.title": "Plätze auswählen",
   "forge.event_series_detail.date_count": "{count} Termine",
   "forge.event_series_detail.date_count_range": "{count} Termine · {first_date} bis {last_date}",
   "forge.event_series_detail.location_online": "Online",
@@ -883,6 +934,11 @@
   "forge.event_tickets.pwyw_range_min_max": "(mindestens {min}, bis {max})",
   "forge.event_tickets.remove_discount": "Rabatt entfernen",
   "forge.event_tickets.request_tickets": "Tickets anfragen",
+  "forge.event_tickets.seat_best_available": "Beste verfügbare",
+  "forge.event_tickets.seat_remove_aria": "{seat} entfernen",
+  "forge.event_tickets.seats_left_one": "{count} Platz frei",
+  "forge.event_tickets.seats_left_other": "{count} Plätze frei",
+  "forge.event_tickets.seats_title": "Deine Plätze",
   "forge.event_tickets.select_option": "Auswählen…",
   "forge.event_tickets.select_title": "Tickets wählen",
   "forge.event_tickets.subtotal": "Zwischensumme",
@@ -1228,6 +1284,14 @@
   "forge.payment_link_payment.preparing_payment": "Zahlung wird vorbereitet…",
   "forge.payment_link_payment.tax_added": "+ {tax_amount} MwSt.",
   "forge.payment_link_payment.title": "Zahlungsanfrage",
+  "forge.phone_input.country_label": "Land",
+  "forge.phone_input.country_placeholder": "Land auswaehlen",
+  "forge.phone_input.error_invalid": "Das sieht nicht nach einer gueltigen Nummer fuer das gewaehlte Land aus",
+  "forge.phone_input.error_no_country": "Bitte waehlen Sie zuerst Ihr Land aus",
+  "forge.phone_input.error_required": "Bitte geben Sie eine Telefonnummer ein",
+  "forge.phone_input.hint_no_country_code": "Die Landesvorwahl koennen Sie weglassen. Die Flagge setzt sie fuer Sie.",
+  "forge.phone_input.placeholder_fallback": "Telefonnummer",
+  "forge.phone_input.warning_landline": "Das sieht nach einem Festnetzanschluss aus und kann moeglicherweise keine SMS empfangen.",
   "forge.podcast_episode.next": "Weiter →",
   "forge.podcast_episode.not_found": "Folge nicht gefunden.",
   "forge.podcast_episode.pause": "Pause",
@@ -1358,6 +1422,21 @@
   "forge.review_form.title_label": "Titel",
   "forge.review_form.title_placeholder": "Fass es in ein paar Worten zusammen",
   "forge.review_form.update_submit": "Bewertung aktualisieren",
+  "forge.seat_legend.aria_label": "Legende",
+  "forge.seat_legend.left_one": "{count} frei",
+  "forge.seat_legend.left_other": "{count} frei",
+  "forge.seat_legend.selected": "Ausgewählt",
+  "forge.seat_legend.sold_out": "Ausverkauft",
+  "forge.seat_legend.unavailable": "Nicht verfügbar",
+  "forge.seat_map_canvas.accessible": "barrierefreier Platz",
+  "forge.seat_map_canvas.aria_label": "Saalplan",
+  "forge.seat_map_canvas.fit": "Ganzen Plan anzeigen",
+  "forge.seat_map_canvas.general_admission": "Freie Platzwahl",
+  "forge.seat_map_canvas.status_available": "verfügbar",
+  "forge.seat_map_canvas.status_selected": "ausgewählt",
+  "forge.seat_map_canvas.status_unavailable": "nicht verfügbar",
+  "forge.seat_map_canvas.zoom_in": "Vergrößern",
+  "forge.seat_map_canvas.zoom_out": "Verkleinern",
   "forge.signup_form.accept_terms": "Ich akzeptiere die AGB und die Datenschutzerklärung",
   "forge.signup_form.code_label": "Bestätigungscode",
   "forge.signup_form.code_sent": "Wir haben einen 6-stelligen Code an {email} geschickt. Gib ihn ein, um dein Konto fertig einzurichten.",