diff --git a/README.md b/README.md
index 1a12114..90db071 100644
--- a/README.md
+++ b/README.md
@@ -172,6 +172,41 @@ on first use in the configured PostgreSQL database. `RESEND_API_KEY` and
 `NIXAMP_MAIL_FROM` are optional if invitation email should be sent rather than
 only returning a shareable link.
 
+## Live shows, and tickets
+
+A live event carries a **kind**: `talk`, `class`, or `concert`. The kind is
+what a branded client reads to pick a layout, and what `/api/v1/events?kind=`
+filters the directory by, so one NixAmp serves a school and a venue without
+either knowing about the other. `concert` brings its own presets
+(`concert-viewer`, `concert-ticketholder`, `concert-artist`) with a stage,
+a setlist, a tip jar, a merch shelf and a till.
+
+A concert also has doors and an encore. `POST /api/v1/events/:id/doors` opens
+the room before the music, `.../start` begins it, `.../encore` says the band
+came back, and `.../end` closes it. Opening, playing and coming back on are
+allowed to everyone on the stage; cancelling and archiving stay with the host.
+An **artist** is an invitation role beside moderator: they perform without
+being handed the guest list.
+
+**A ticket is a paid pass to one room**, over x402 and settled by CoinPay,
+exactly like the crawler paywall but scoped to a single event:
+
+```
+POST /api/v1/events/:id/tickets          # X-PAYMENT proof in, ticket out
+GET  /api/v1/events/:id/tickets          # what it costs and whether you hold one
+POST /api/v1/events/:id/tickets/comp     # the guest list, hosts only
+```
+
+Set `ticketPriceCents` and a `payTo` address on the event and the room answers
+402 to anyone without a ticket, quoting the price; the money goes to the
+event's own address, never to the platform. The ticket rides in
+`x-nixamp-ticket`, or in `?ticket=` for an `<audio>` or `<video>` element that
+cannot set a header. `COINPAY_X402_KEY` switches sales on; without it every
+event is simply a free one. `NIXAMP_TICKET_SECRET` signs the passes (it
+defaults to the CoinPay key), and each event's tickets are signed with a
+secret derived from it and the event id, so a ticket to Friday is not a ticket
+to Saturday.
+
 ## The directory
 
 [nixamp.com/directory](https://nixamp.com/directory) lists nixamps that agreed
diff --git a/src/layouts.ts b/src/layouts.ts
index 3db9113..d8498a1 100644
--- a/src/layouts.ts
+++ b/src/layouts.ts
@@ -55,6 +55,14 @@ export const PANEL_REGISTRY: readonly PanelDefinition[] = [
   { type: "about", title: "About" },
   { type: "join", title: "Join" },
   { type: "stage", title: "Stage", permissions: ["room.speak"] },
+  // A show is watched as well as heard, and what surrounds it is how it earns.
+  { type: "stage-video", title: "Stage" },
+  { type: "setlist", title: "Setlist" },
+  { type: "tip-jar", title: "Tip Jar" },
+  { type: "merch", title: "Merch" },
+  { type: "tickets", title: "Tickets" },
+  { type: "lineup", title: "Lineup" },
+  { type: "soundcheck", title: "Soundcheck", permissions: ["event.perform"] },
   { type: "chat", title: "Chat" },
   { type: "participants", title: "People", permissions: ["room.listen"] },
   { type: "speakers", title: "Speakers", permissions: ["room.speak"] },
@@ -103,13 +111,19 @@ function presetPanel(
   };
 }
 
+/**
+ * A preset belongs to the family its name starts with -- `concert-artist` is
+ * the concert family -- so a new vertical is a set of presets and nothing else.
+ * The admin layout is the exception: it is a role, not a brand.
+ */
 function preset(name: string, panels: PanelInstance[]): Layout {
   const now = new Date(0).toISOString();
+  const family = name.split("-")[0] ?? name;
   return {
     id: name,
     name,
     scope: name === "nixamp-admin" ? "role" : "brand",
-    scopeId: name === "nixamp-admin" ? "admin" : "backtoschool",
+    scopeId: name === "nixamp-admin" ? "admin" : family,
     panels,
     version: 1,
     createdAt: now,
@@ -163,13 +177,76 @@ const adminPanels = [
   presetPanel("advanced-nixamp", "advanced-nixamp", "drawer", 23),
 ] satisfies PanelInstance[];
 
+/**
+ * A live show. The stage is the thing; the setlist says what is happening, the
+ * tip jar and the merch shelf are how a night pays, and the till is a panel
+ * like any other so a client that cannot sell tickets simply does not draw it.
+ */
+const concertViewerPanels = [
+  presetPanel("event-header", "event-header", "primary", 0),
+  presetPanel("stage-video", "stage-video", "primary", 1),
+  presetPanel("tickets", "tickets", "secondary", 2),
+  presetPanel("lineup", "lineup", "secondary", 3),
+  presetPanel("about", "about", "secondary", 4),
+  presetPanel("share", "share", "bottom", 5),
+  presetPanel("chat", "chat", "drawer", 6, { collapsed: true }),
+] satisfies PanelInstance[];
+
+const concertTicketHolderPanels = [
+  presetPanel("event-header", "event-header", "primary", 0),
+  presetPanel("stage-video", "stage-video", "primary", 1),
+  presetPanel("setlist", "setlist", "secondary", 2),
+  presetPanel("chat", "chat", "secondary", 3),
+  presetPanel("tip-jar", "tip-jar", "sidebar", 4),
+  presetPanel("merch", "merch", "sidebar", 5),
+  presetPanel("participants", "participants", "sidebar", 6),
+  presetPanel("share", "share", "bottom", 7),
+] satisfies PanelInstance[];
+
+const concertArtistPanels = [
+  presetPanel("event-header", "event-header", "primary", 0),
+  presetPanel("stage-video", "stage-video", "primary", 1),
+  presetPanel("setlist", "setlist", "secondary", 2),
+  presetPanel("soundcheck", "soundcheck", "secondary", 3),
+  presetPanel("chat", "chat", "sidebar", 4),
+  presetPanel("participants", "participants", "sidebar", 5),
+  presetPanel("invite", "invite", "sidebar", 6),
+  presetPanel("tip-jar", "tip-jar", "sidebar", 7),
+  presetPanel("merch", "merch", "sidebar", 8),
+  presetPanel("event-controls", "event-controls", "bottom", 9),
+  presetPanel("schedule", "schedule", "bottom", 10),
+  presetPanel("recording", "recording", "bottom", 11),
+  presetPanel("tickets", "tickets", "bottom", 12),
+  presetPanel("share", "share", "bottom", 13),
+] satisfies PanelInstance[];
+
 export const LAYOUT_PRESETS: Readonly<Record<string, Layout>> = {
   "backtoschool-viewer": preset("backtoschool-viewer", viewerPanels),
   "backtoschool-member": preset("backtoschool-member", memberPanels),
   "backtoschool-host": preset("backtoschool-host", hostPanels),
+  "concert-viewer": preset("concert-viewer", concertViewerPanels),
+  "concert-ticketholder": preset("concert-ticketholder", concertTicketHolderPanels),
+  "concert-artist": preset("concert-artist", concertArtistPanels),
   "nixamp-admin": preset("nixamp-admin", adminPanels),
 };
 
+/** Where a viewer stands in the room, whatever kind of room it is. */
+export type LayoutRole = "viewer" | "member" | "host";
+
+/**
+ * The preset for a kind of event and who is looking at it.
+ *
+ * One place, because otherwise every client invents its own mapping and a new
+ * kind of live means editing all of them. A kind with no presets of its own
+ * falls back to the general ones rather than to nothing.
+ */
+export function layoutNameFor(kind: string, role: LayoutRole): string {
+  if (kind === "concert") {
+    return role === "host" ? "concert-artist" : role === "member" ? "concert-ticketholder" : "concert-viewer";
+  }
+  return `backtoschool-${role}`;
+}
+
 const LAYOUT_SCHEMA = `
   CREATE TABLE IF NOT EXISTS nixamp_layouts (
     id          TEXT PRIMARY KEY,
diff --git a/src/live-api.ts b/src/live-api.ts
index bafee84..3477a4f 100644
--- a/src/live-api.ts
+++ b/src/live-api.ts
@@ -2,9 +2,12 @@ import type { IncomingMessage, ServerResponse } from "node:http";
 import { tokenFrom, type Account, type Accounts } from "./accounts.ts";
 import {
   INVITATION_STATES,
+  LIVE_EVENT_KINDS,
   LIVE_EVENT_STATUSES,
   LiveEventError,
+  isTicketed,
   type LiveEvent,
+  type LiveEventKind,
   type LiveEventStatus,
   type LiveEvents,
 } from "./live-events.ts";
@@ -12,10 +15,13 @@ import {
   LAYOUT_SCOPES,
   LayoutError,
   PANEL_REGISTRY,
+  layoutNameFor,
   type Layout,
   type Layouts,
   presetLayout,
 } from "./layouts.ts";
+import { needsTicket, ticketFrom, type Tickets } from "./tickets.ts";
+import { toRequest } from "./paywall.ts";
 import { HAND_RAISE_STATES, RoomError, type Rooms } from "./rooms.ts";
 
 export interface LiveApiOptions {
@@ -23,6 +29,8 @@ export interface LiveApiOptions {
   accounts?: Accounts;
   layouts?: Layouts;
   rooms?: Rooms;
+  /** Ticket sales for paid events. Absent means every event is a free one. */
+  tickets?: Tickets;
   site?: string;
   email?: (to: string, note: { title: string; body: string; url: string }) => Promise<boolean>;
 }
@@ -82,14 +90,16 @@ function accountName(account: Account): string {
   return account.email.split("@")[0]?.replace(/[._-]+/g, " ").trim() || "Someone";
 }
 
-function permissionsFor(event: LiveEvent, account: Account | null): string[] {
-  if (account?.id === event.ownerId || event.moderatorIds.includes(account?.id ?? "")) {
+function permissionsFor(event: LiveEvent, account: Account | null, hasTicket = false): string[] {
+  const id = account?.id ?? "";
+  if (account?.id === event.ownerId || event.moderatorIds.includes(id)) {
     return [
       "event.update",
       "event.start",
       "event.end",
       "event.invite",
       "event.moderate",
+      "event.perform",
       "room.listen",
       "room.chat",
       "room.raise_hand",
@@ -104,22 +114,72 @@ function permissionsFor(event: LiveEvent, account: Account | null): string[] {
       "panel.remove",
     ];
   }
+  // An artist performs without presiding: on stage, and on the controls that
+  // put them there, but never on the guest list or the moderation queue.
+  if (event.artistIds.includes(id)) {
+    return [
+      "event.start",
+      "event.end",
+      "event.perform",
+      "room.listen",
+      "room.chat",
+      "room.raise_hand",
+      "room.speak",
+      "recording.start",
+      "recording.stop",
+      "layout.read",
+    ];
+  }
+  // A paid room admits nobody who has not paid, so even listening is withheld
+  // until there is a ticket. A free room is what it always was.
+  const listening = isTicketed(event) && !hasTicket ? [] : ["room.listen"];
   return account
-    ? ["room.listen", "room.chat", "room.raise_hand", "layout.read"]
-    : ["room.listen", "layout.read"];
+    ? [...listening, "room.chat", "room.raise_hand", "layout.read"]
+    : [...listening, "layout.read"];
+}
+
+function roleOf(event: LiveEvent, account: Account | null, hasTicket: boolean): "viewer" | "member" | "host" {
+  const id = account?.id ?? "";
+  if (event.ownerId === id || event.moderatorIds.includes(id) || event.artistIds.includes(id)) return "host";
+  if (isTicketed(event)) return hasTicket ? "member" : "viewer";
+  return account ? "member" : "viewer";
 }
 
-function layoutFor(event: LiveEvent, account: Account | null): Layout {
-  const name = event.ownerId === account?.id || event.moderatorIds.includes(account?.id ?? "")
-    ? "backtoschool-host"
-    : account
-      ? "backtoschool-member"
-      : "backtoschool-viewer";
+function layoutFor(event: LiveEvent, account: Account | null, hasTicket = false): Layout {
+  const name = layoutNameFor(event.kind, roleOf(event, account, hasTicket));
   return presetLayout(event.layoutId ?? name) ?? presetLayout(name)!;
 }
 
-function view(event: LiveEvent, account: Account | null): { event: LiveEvent; permissions: string[]; layout: Layout } {
-  return { event, permissions: permissionsFor(event, account), layout: layoutFor(event, account) };
+export interface EventView {
+  event: LiveEvent;
+  permissions: string[];
+  layout: Layout;
+  ticket: { required: boolean; held: boolean; priceCents: number; currency: string };
+}
+
+function view(event: LiveEvent, account: Account | null, hasTicket = false): EventView {
+  return {
+    event,
+    permissions: permissionsFor(event, account, hasTicket),
+    layout: layoutFor(event, account, hasTicket),
+    ticket: {
+      required: needsTicket(event, account?.id, hasTicket),
+      held: hasTicket,
+      priceCents: event.ticketPriceCents,
+      currency: event.ticketCurrency,
+    },
+  };
+}
+
+/** Whether this request carries a ticket to this event. */
+async function ticketHeld(
+  request: IncomingMessage,
+  url: URL,
+  options: LiveApiOptions,
+  event: LiveEvent,
+): Promise<boolean> {
+  if (!options.tickets || !isTicketed(event)) return false;
+  return options.tickets.holds(event, ticketFrom(request.headers, url));
 }
 
 async function signedIn(request: IncomingMessage, accounts: Accounts | undefined): Promise<Account | null> {
@@ -167,6 +227,22 @@ async function manage(
   return account;
 }
 
+/** Everyone on the stage: the host, a moderator, and an invited artist. */
+async function perform(
+  request: IncomingMessage,
+  response: ServerResponse,
+  options: LiveApiOptions,
+  event: LiveEvent,
+): Promise<Account | null> {
+  const account = await requiredAccount(request, response, options);
+  if (!account) return null;
+  if (!options.events.canPerform(event, account.id)) {
+    json(response, 403, { error: "only the people on this stage can do that" });
+    return null;
+  }
+  return account;
+}
+
 export async function handleLiveApi(
   request: IncomingMessage,
   response: ServerResponse,
@@ -187,6 +263,10 @@ export async function handleLiveApi(
         if (statusValue && !LIVE_EVENT_STATUSES.includes(statusValue as LiveEventStatus)) {
           throw new LiveEventError(`status must be one of ${LIVE_EVENT_STATUSES.join(", ")}`, 422);
         }
+        const kindValue = url.searchParams.get("kind") ?? undefined;
+        if (kindValue && !LIVE_EVENT_KINDS.includes(kindValue as LiveEventKind)) {
+          throw new LiveEventError(`kind must be one of ${LIVE_EVENT_KINDS.join(", ")}`, 422);
+        }
         const mine = url.searchParams.get("mine") === "true";
         if (mine && !account) {
           json(response, 401, { error: "sign in to see your events" });
@@ -199,6 +279,7 @@ export async function handleLiveApi(
         const events = await options.events.list({
           ...(mine && account ? { ownerId: account.id } : {}),
           ...(statusValue ? { status: statusValue as LiveEventStatus } : {}),
+          ...(kindValue ? { kind: kindValue as LiveEventKind } : {}),
           ...(url.searchParams.get("topic") ? { topic: url.searchParams.get("topic")! } : {}),
           ...(url.searchParams.get("from") ? { from: url.searchParams.get("from")! } : {}),
           limit: requestedLimit,
@@ -314,7 +395,7 @@ export async function handleLiveApi(
       return true;
     }
 
-    const eventMatch = /^\/api\/v1\/events\/([^/]+)(?:\/(invitations|chat|hand-raises)(?:\/([^/]+))?|\/(start|end|cancel|archive))?$/.exec(path);
+    const eventMatch = /^\/api\/v1\/events\/([^/]+)(?:\/(invitations|chat|hand-raises|tickets)(?:\/([^/]+))?|\/(doors|start|encore|end|cancel|archive))?$/.exec(path);
     if (!eventMatch) {
       json(response, 404, { error: "no such endpoint" });
       return true;
@@ -329,7 +410,7 @@ export async function handleLiveApi(
       if (request.method === "GET") {
         const account = await eventAccess(request, response, url, options, event);
         if (account === false || !event) return true;
-        json(response, 200, view(event, account));
+        json(response, 200, view(event, account, await ticketHeld(request, url, options, event)));
         return true;
       }
       const account = await requiredAccount(request, response, options);
@@ -340,7 +421,7 @@ export async function handleLiveApi(
           ...input,
           version: requestedVersion(request, input),
         });
-        json(response, 200, view(updated, account));
+        json(response, 200, view(updated, account, await ticketHeld(request, url, options, updated)));
         return true;
       }
       if (request.method === "DELETE") {
@@ -362,17 +443,23 @@ export async function handleLiveApi(
         json(response, 405, { error: "POST only" });
         return true;
       }
-      const account = await manage(request, response, options, event);
+      // Cancelling and archiving a show are the host's business; opening the
+      // doors, playing and coming back on are the band's.
+      const account = action === "cancel" || action === "archive"
+        ? await manage(request, response, options, event)
+        : await perform(request, response, options, event);
       if (!account) return true;
       const input = await body(request);
       const target: Record<string, LiveEventStatus> = {
+        doors: "starting",
         start: "live",
+        encore: "encore",
         end: "ended",
         cancel: "cancelled",
         archive: "archived",
       };
       const updated = await options.events.transition(event.id, event.ownerId, target[action]!, requestedVersion(request, input));
-      json(response, 200, view(updated, account));
+      json(response, 200, view(updated, account, await ticketHeld(request, url, options, updated)));
       return true;
     }
 
@@ -407,6 +494,70 @@ export async function handleLiveApi(
       return true;
     }
 
+    if (collection === "tickets") {
+      // Reading the price is open: a stranger deciding whether to come has to
+      // be told what it costs before they are asked for anything.
+      if (request.method === "GET" && !child) {
+        const account = await signedIn(request, options.accounts);
+        const held = await ticketHeld(request, url, options, event);
+        if (!options.tickets) {
+          json(response, 200, {
+            ticket: { ticketed: isTicketed(event), held: false, sales: false },
+          });
+          return true;
+        }
+        json(response, 200, {
+          ticket: {
+            ...options.tickets.offer(event),
+            held,
+            sales: options.tickets.enabled,
+            required: needsTicket(event, account?.id, held),
+          },
+        });
+        return true;
+      }
+      // The guest list. A host hands out a ticket nobody paid for, which is
+      // the only way a venue can comp the press or make a refund good.
+      if (request.method === "POST" && child === "comp") {
+        if (!options.tickets) {
+          json(response, 503, { error: "this deployment does not issue tickets" });
+          return true;
+        }
+        const host = await manage(request, response, options, event);
+        if (!host) return true;
+        if (!isTicketed(event)) {
+          json(response, 409, { error: "this event is free; no ticket is needed" });
+          return true;
+        }
+        const input = await body(request);
+        const minutes = Number(input["minutes"] ?? event.ticketMinutes);
+        if (!Number.isInteger(minutes) || minutes < 1 || minutes > 525_600) {
+          throw new LiveEventError("minutes must be between 1 and 525600", 422);
+        }
+        json(response, 201, { ticket: await options.tickets.mint(event, minutes), header: "x-nixamp-ticket" });
+        return true;
+      }
+      if (request.method === "POST" && !child) {
+        if (!options.tickets) {
+          json(response, 503, { error: "this deployment does not sell tickets" });
+          return true;
+        }
+        const site = (options.site ?? "https://nixamp.com").replace(/\/$/, "");
+        const answer = await options.tickets.sell(event, toRequest(request, site));
+        const buffer = Buffer.from(await answer.arrayBuffer());
+        response.writeHead(answer.status, {
+          ...CORS,
+          ...Object.fromEntries(answer.headers),
+          "content-length": String(buffer.byteLength),
+          "cache-control": "no-store",
+        });
+        response.end(buffer);
+        return true;
+      }
+      json(response, 405, { error: "GET or POST" });
+      return true;
+    }
+
     if (collection === "chat" && options.rooms) {
       const account = await eventAccess(request, response, url, options, event);
       if (account === false) return true;
@@ -420,6 +571,10 @@ export async function handleLiveApi(
           json(response, 401, { error: "sign in to chat" });
           return true;
         }
+        if (needsTicket(event, account.id, await ticketHeld(request, url, options, event))) {
+          json(response, 402, { error: "the chat for this show is for ticket holders" });
+          return true;
+        }
         const input = await body(request);
         json(response, 201, { message: await options.rooms.post(event.id, account.id, accountName(account), input["body"]) });
         return true;
diff --git a/src/live-events.ts b/src/live-events.ts
index 975b191..41685e9 100644
--- a/src/live-events.ts
+++ b/src/live-events.ts
@@ -4,19 +4,36 @@ import type { Queryable } from "./follows.ts";
 export const LIVE_EVENT_STATUSES = [
   "draft",
   "scheduled",
+  // Doors open: the room is reachable, the show has not started.
   "starting",
   "live",
+  // The set ended and the band came back. Its own state because a listener
+  // arriving now is arriving at something, and "ended" would turn them away.
+  "encore",
   "ended",
   "cancelled",
   "archived",
 ] as const;
 
 export const LIVE_EVENT_VISIBILITIES = ["public", "unlisted", "private"] as const;
-export const INVITATION_ROLES = ["listener", "speaker", "moderator"] as const;
+
+/**
+ * What kind of live this is. NixAmp owns the room; the kind is what a branded
+ * client reads to decide which layout, which words, and which panels. Nothing
+ * here is named after a site: "concert" is a concert whoever is showing it.
+ */
+export const LIVE_EVENT_KINDS = ["talk", "class", "concert"] as const;
+
+/**
+ * `artist` sits beside moderator: somebody who performs rather than presides.
+ * They go on stage and drive the show without being handed the guest list.
+ */
+export const INVITATION_ROLES = ["listener", "speaker", "artist", "moderator"] as const;
 export const INVITATION_STATES = ["pending", "accepted", "declined", "revoked", "expired"] as const;
 
 export type LiveEventStatus = (typeof LIVE_EVENT_STATUSES)[number];
 export type LiveEventVisibility = (typeof LIVE_EVENT_VISIBILITIES)[number];
+export type LiveEventKind = (typeof LIVE_EVENT_KINDS)[number];
 export type InvitationRole = (typeof INVITATION_ROLES)[number];
 export type InvitationState = (typeof INVITATION_STATES)[number];
 
@@ -27,6 +44,9 @@ export interface LiveEvent {
   title: string;
   description?: string;
   topic?: string;
+  kind: LiveEventKind;
+  /** When the room opens, ahead of the music. Optional, and never after startsAt. */
+  doorsOpenAt?: string;
   startsAt?: string;
   endsAt?: string;
   timezone: string;
@@ -36,7 +56,15 @@ export interface LiveEvent {
   roomId: string;
   inviteeIds: string[];
   speakerIds: string[];
+  artistIds: string[];
   moderatorIds: string[];
+  /** 0 is a free show. Above it, a ticket is a paid pass to this room. */
+  ticketPriceCents: number;
+  ticketCurrency: string;
+  /** How long one ticket admits for. A day by default, which covers a replay. */
+  ticketMinutes: number;
+  /** Where the ticket money goes: the performer's address, not the platform's. */
+  payTo?: string;
   chatEnabled: boolean;
   handRaiseEnabled: boolean;
   recordingEnabled: boolean;
@@ -68,6 +96,12 @@ export interface CreateLiveEventInput {
   title: unknown;
   description?: unknown;
   topic?: unknown;
+  kind?: unknown;
+  doorsOpenAt?: unknown;
+  ticketPriceCents?: unknown;
+  ticketCurrency?: unknown;
+  ticketMinutes?: unknown;
+  payTo?: unknown;
   startsAt?: unknown;
   endsAt?: unknown;
   timezone?: unknown;
@@ -88,6 +122,7 @@ export interface UpdateLiveEventInput extends Partial<CreateLiveEventInput> {
 export interface EventListQuery {
   ownerId?: string;
   status?: LiveEventStatus;
+  kind?: LiveEventKind;
   topic?: string;
   from?: string;
   limit?: number;
@@ -107,6 +142,12 @@ const EVENT_SCHEMA = `
     title                      TEXT NOT NULL,
     description                TEXT NOT NULL DEFAULT '',
     topic                      TEXT NOT NULL DEFAULT '',
+    kind                       TEXT NOT NULL DEFAULT 'talk',
+    doors_open_at              TIMESTAMPTZ,
+    ticket_price_cents         INTEGER NOT NULL DEFAULT 0,
+    ticket_currency            TEXT NOT NULL DEFAULT 'USD',
+    ticket_minutes             INTEGER NOT NULL DEFAULT 1440,
+    pay_to                     TEXT,
     starts_at                  TIMESTAMPTZ,
     ends_at                    TIMESTAMPTZ,
     timezone                   TEXT NOT NULL DEFAULT 'UTC',
@@ -122,8 +163,9 @@ const EVENT_SCHEMA = `
     version                    INTEGER NOT NULL DEFAULT 1,
     created_at                 TIMESTAMPTZ NOT NULL DEFAULT now(),
     updated_at                 TIMESTAMPTZ NOT NULL DEFAULT now(),
-    CHECK (status IN ('draft', 'scheduled', 'starting', 'live', 'ended', 'cancelled', 'archived')),
     CHECK (visibility IN ('public', 'unlisted', 'private')),
+    CHECK (ticket_price_cents >= 0),
+    CHECK (ticket_minutes BETWEEN 1 AND 525600),
     CHECK (expected_duration_minutes IS NULL OR expected_duration_minutes BETWEEN 1 AND 1440),
     CHECK (ends_at IS NULL OR starts_at IS NULL OR ends_at > starts_at)
   );
@@ -131,6 +173,47 @@ const EVENT_SCHEMA = `
     ON live_events (visibility, status, starts_at, updated_at DESC);
   CREATE INDEX IF NOT EXISTS live_events_owner
     ON live_events (owner_id, updated_at DESC);
+  CREATE INDEX IF NOT EXISTS live_events_kind
+    ON live_events (kind, status, starts_at);
+
+  -- The repo has no migration runner, so a table that already exists is
+  -- brought forward here. Every statement is idempotent, and the CHECKs are
+  -- replaced by name rather than added twice: the originals were unnamed, so
+  -- the ones carrying the old status list are found by what they say.
+  ALTER TABLE live_events ADD COLUMN IF NOT EXISTS kind               TEXT    NOT NULL DEFAULT 'talk';
+  ALTER TABLE live_events ADD COLUMN IF NOT EXISTS doors_open_at      TIMESTAMPTZ;
+  ALTER TABLE live_events ADD COLUMN IF NOT EXISTS ticket_price_cents INTEGER NOT NULL DEFAULT 0;
+  ALTER TABLE live_events ADD COLUMN IF NOT EXISTS ticket_currency    TEXT    NOT NULL DEFAULT 'USD';
+  ALTER TABLE live_events ADD COLUMN IF NOT EXISTS ticket_minutes     INTEGER NOT NULL DEFAULT 1440;
+  ALTER TABLE live_events ADD COLUMN IF NOT EXISTS pay_to             TEXT;
+
+  DO $$
+  DECLARE stale record;
+  BEGIN
+    FOR stale IN
+      SELECT conname FROM pg_constraint
+      WHERE conrelid = 'live_events'::regclass AND contype = 'c'
+        AND conname <> 'live_events_status_allowed'
+        AND pg_get_constraintdef(oid) LIKE '%archived%'
+    LOOP
+      EXECUTE format('ALTER TABLE live_events DROP CONSTRAINT %I', stale.conname);
+    END LOOP;
+    FOR stale IN
+      SELECT conname FROM pg_constraint
+      WHERE conrelid = 'live_event_invitations'::regclass AND contype = 'c'
+        AND conname <> 'live_event_invitations_role_allowed'
+        AND pg_get_constraintdef(oid) LIKE '%moderator%'
+    LOOP
+      EXECUTE format('ALTER TABLE live_event_invitations DROP CONSTRAINT %I', stale.conname);
+    END LOOP;
+  END $$;
+
+  ALTER TABLE live_events DROP CONSTRAINT IF EXISTS live_events_status_allowed;
+  ALTER TABLE live_events ADD CONSTRAINT live_events_status_allowed
+    CHECK (status IN ('draft', 'scheduled', 'starting', 'live', 'encore', 'ended', 'cancelled', 'archived'));
+  ALTER TABLE live_events DROP CONSTRAINT IF EXISTS live_events_kind_allowed;
+  ALTER TABLE live_events ADD CONSTRAINT live_events_kind_allowed
+    CHECK (kind IN ('talk', 'class', 'concert'));
 
   CREATE TABLE IF NOT EXISTS live_event_invitations (
     id          TEXT PRIMARY KEY,
@@ -144,7 +227,6 @@ const EVENT_SCHEMA = `
     expires_at   TIMESTAMPTZ,
     created_at   TIMESTAMPTZ NOT NULL DEFAULT now(),
     updated_at   TIMESTAMPTZ NOT NULL DEFAULT now(),
-    CHECK (role IN ('listener', 'speaker', 'moderator')),
     CHECK (state IN ('pending', 'accepted', 'declined', 'revoked', 'expired')),
     CHECK (invitee_id IS NOT NULL OR email IS NOT NULL)
   );
@@ -152,6 +234,10 @@ const EVENT_SCHEMA = `
     ON live_event_invitations (event_id, state, created_at);
   CREATE INDEX IF NOT EXISTS live_event_invitations_invitee
     ON live_event_invitations (invitee_id, state);
+
+  ALTER TABLE live_event_invitations DROP CONSTRAINT IF EXISTS live_event_invitations_role_allowed;
+  ALTER TABLE live_event_invitations ADD CONSTRAINT live_event_invitations_role_allowed
+    CHECK (role IN ('listener', 'speaker', 'artist', 'moderator'));
 `;
 
 const SELECT_EVENT = `
@@ -166,6 +252,11 @@ const SELECT_EVENT = `
       FROM live_event_invitations i
       WHERE i.event_id = e.id AND i.state = 'accepted' AND i.role = 'speaker'
     ), ARRAY[]::text[]) AS speaker_ids,
+    COALESCE((
+      SELECT array_agg(DISTINCT i.invitee_id) FILTER (WHERE i.invitee_id IS NOT NULL)
+      FROM live_event_invitations i
+      WHERE i.event_id = e.id AND i.state = 'accepted' AND i.role = 'artist'
+    ), ARRAY[]::text[]) AS artist_ids,
     COALESCE((
       SELECT array_agg(DISTINCT i.invitee_id) FILTER (WHERE i.invitee_id IS NOT NULL)
       FROM live_event_invitations i
@@ -178,7 +269,9 @@ const TRANSITIONS: Record<LiveEventStatus, readonly LiveEventStatus[]> = {
   draft: ["scheduled", "starting", "live", "cancelled"],
   scheduled: ["draft", "starting", "live", "cancelled"],
   starting: ["live", "cancelled"],
-  live: ["ended", "cancelled"],
+  live: ["encore", "ended", "cancelled"],
+  // An encore can go back on: a second one is still the same show.
+  encore: ["live", "ended", "cancelled"],
   ended: ["archived"],
   cancelled: ["archived"],
   archived: [],
@@ -246,6 +339,36 @@ function strings(value: unknown): string[] {
   return [];
 }
 
+/** Whole cents, never negative, and nothing silly enough to be a typo. */
+function cents(value: unknown, fallback: number, name: string): number {
+  if (value === undefined || value === null || value === "") return fallback;
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 0 || value > 1_000_000) {
+    throw new LiveEventError(`${name} must be a whole number of cents between 0 and 1000000`, 422);
+  }
+  return value;
+}
+
+function minutes(value: unknown, fallback: number, name: string): number {
+  if (value === undefined || value === null || value === "") return fallback;
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 1 || value > 525_600) {
+    throw new LiveEventError(`${name} must be between 1 and 525600`, 422);
+  }
+  return value;
+}
+
+/**
+ * Where a ticket is paid to. An address that is not an address is refused
+ * here rather than at the till, because a show whose money goes nowhere sells
+ * tickets happily and only fails once somebody has paid.
+ */
+export function payToAddress(value: unknown, name = "payTo"): string {
+  if (value === undefined || value === null || value === "") return "";
+  if (typeof value !== "string" || !/^0x[0-9a-fA-F]{40}$/.test(value.trim())) {
+    throw new LiveEventError(`${name} must be an 0x EVM address`, 422);
+  }
+  return value.trim();
+}
+
 function eventFrom(row: Record<string, unknown>): LiveEvent {
   return {
     id: String(row["id"] ?? ""),
@@ -254,6 +377,10 @@ function eventFrom(row: Record<string, unknown>): LiveEvent {
     title: String(row["title"] ?? ""),
     ...(row["description"] ? { description: String(row["description"]) } : {}),
     ...(row["topic"] ? { topic: String(row["topic"]) } : {}),
+    kind: (LIVE_EVENT_KINDS.includes(String(row["kind"] ?? "talk") as LiveEventKind)
+      ? String(row["kind"] ?? "talk")
+      : "talk") as LiveEventKind,
+    ...(iso(row["doors_open_at"]) ? { doorsOpenAt: iso(row["doors_open_at"]) } : {}),
     ...(iso(row["starts_at"]) ? { startsAt: iso(row["starts_at"]) } : {}),
     ...(iso(row["ends_at"]) ? { endsAt: iso(row["ends_at"]) } : {}),
     timezone: String(row["timezone"] ?? "UTC"),
@@ -265,7 +392,12 @@ function eventFrom(row: Record<string, unknown>): LiveEvent {
     roomId: String(row["room_id"] ?? ""),
     inviteeIds: strings(row["invitee_ids"]),
     speakerIds: strings(row["speaker_ids"]),
+    artistIds: strings(row["artist_ids"]),
     moderatorIds: strings(row["moderator_ids"]),
+    ticketPriceCents: Number(row["ticket_price_cents"] ?? 0),
+    ticketCurrency: String(row["ticket_currency"] ?? "USD"),
+    ticketMinutes: Number(row["ticket_minutes"] ?? 1440),
+    ...(row["pay_to"] ? { payTo: String(row["pay_to"]) } : {}),
     chatEnabled: Boolean(row["chat_enabled"]),
     handRaiseEnabled: Boolean(row["hand_raise_enabled"]),
     recordingEnabled: Boolean(row["recording_enabled"]),
@@ -309,6 +441,70 @@ export function canTransition(from: LiveEventStatus, to: LiveEventStatus): boole
   return from === to || TRANSITIONS[from].includes(to);
 }
 
+export function canManageEvent(event: LiveEvent, accountId: string | undefined): boolean {
+  return Boolean(accountId && (event.ownerId === accountId || event.moderatorIds.includes(accountId)));
+}
+
+export function canPerformEvent(event: LiveEvent, accountId: string | undefined): boolean {
+  return canManageEvent(event, accountId) || Boolean(accountId && event.artistIds.includes(accountId));
+}
+
+/** Whether the room itself is open: doors, the show, and the encore. */
+export function isRoomOpen(event: LiveEvent): boolean {
+  return event.status === "starting" || event.status === "live" || event.status === "encore";
+}
+
+/** Whether a ticket has to be bought before this room admits anybody. */
+export function isTicketed(event: LiveEvent): boolean {
+  return event.ticketPriceCents > 0 && Boolean(event.payTo);
+}
+
+/**
+ * schema.org for one event.
+ *
+ * A concert is a MusicEvent with an Offer on it, because that is what a search
+ * engine will show as a ticket price and a date. Everything else stays a plain
+ * Event, which is what it was before concerts existed.
+ */
+export function eventStructuredData(event: LiveEvent, canonical: string): Record<string, unknown> {
+  const status = event.status === "cancelled"
+    ? "https://schema.org/EventCancelled"
+    : event.status === "live" || event.status === "encore" || event.status === "starting"
+      ? "https://schema.org/EventInProgress"
+      : event.status === "ended" || event.status === "archived"
+        ? "https://schema.org/EventCompleted"
+        : "https://schema.org/EventScheduled";
+  const description = event.description || `Listen to ${event.title} live.`;
+  const base: Record<string, unknown> = {
+    "@context": "https://schema.org",
+    "@type": event.kind === "concert" ? "MusicEvent" : "Event",
+    name: event.title,
+    description,
+    eventStatus: status,
+    eventAttendanceMode: "https://schema.org/OnlineEventAttendanceMode",
+    ...(event.doorsOpenAt ? { doorTime: event.doorsOpenAt } : {}),
+    ...(event.startsAt ? { startDate: event.startsAt } : {}),
+    ...(event.endsAt ? { endDate: event.endsAt } : {}),
+    url: canonical,
+    location: { "@type": "VirtualLocation", url: canonical },
+  };
+  if (event.kind !== "concert") return base;
+  return {
+    ...base,
+    ...(event.topic ? { performer: { "@type": "MusicGroup", name: event.topic } } : {}),
+    offers: {
+      "@type": "Offer",
+      url: canonical,
+      price: (event.ticketPriceCents / 100).toFixed(2),
+      priceCurrency: event.ticketCurrency,
+      availability: event.status === "cancelled" || event.status === "ended" || event.status === "archived"
+        ? "https://schema.org/SoldOut"
+        : "https://schema.org/InStock",
+      category: isTicketed(event) ? "Ticket" : "Free",
+    },
+  };
+}
+
 export class LiveEvents {
   private ready: Promise<void> | null = null;
 
@@ -325,9 +521,18 @@ export class LiveEvents {
     const title = text(input.title, "title", 160, true);
     const startsAt = timestamp(input.startsAt, "startsAt");
     const endsAt = timestamp(input.endsAt, "endsAt");
+    const doorsOpenAt = timestamp(input.doorsOpenAt, "doorsOpenAt");
     if (startsAt && endsAt && endsAt <= startsAt) {
       throw new LiveEventError("endsAt must be after startsAt", 422);
     }
+    if (doorsOpenAt && startsAt && doorsOpenAt > startsAt) {
+      throw new LiveEventError("doorsOpenAt must be at or before startsAt", 422);
+    }
+    const ticketPriceCents = cents(input.ticketPriceCents, 0, "ticketPriceCents");
+    const payTo = payToAddress(input.payTo);
+    if (ticketPriceCents > 0 && !payTo) {
+      throw new LiveEventError("a ticketed event needs a payTo address", 422);
+    }
     const baseSlug = eventSlug(title);
     const values = [
       id,
@@ -336,6 +541,12 @@ export class LiveEvents {
       title,
       text(input.description, "description", 5000),
       text(input.topic, "topic", 100),
+      enumValue(input.kind, LIVE_EVENT_KINDS, "talk", "kind"),
+      doorsOpenAt,
+      ticketPriceCents,
+      text(input.ticketCurrency ?? "USD", "ticketCurrency", 8, true).toUpperCase(),
+      minutes(input.ticketMinutes, 1440, "ticketMinutes"),
+      payTo,
       startsAt,
       endsAt,
       text(input.timezone ?? "UTC", "timezone", 100, true),
@@ -353,11 +564,14 @@ export class LiveEvents {
     try {
       ({ rows } = await this.db.query(
         `INSERT INTO live_events (
-          id, slug, owner_id, title, description, topic, starts_at, ends_at, timezone,
+          id, slug, owner_id, title, description, topic, kind, doors_open_at,
+          ticket_price_cents, ticket_currency, ticket_minutes, pay_to,
+          starts_at, ends_at, timezone,
           expected_duration_minutes, status, visibility, room_id, chat_enabled,
           hand_raise_enabled, recording_enabled, layout_id
         ) VALUES (
-          $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, NULLIF($17, '')
+          $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, NULLIF($12, ''), $13, $14, $15,
+          $16, $17, $18, $19, $20, $21, $22, NULLIF($23, '')
         ) RETURNING *`,
         values,
       ));
@@ -366,18 +580,21 @@ export class LiveEvents {
       values[1] = `${baseSlug}-${id.slice(0, 6)}`;
       ({ rows } = await this.db.query(
         `INSERT INTO live_events (
-          id, slug, owner_id, title, description, topic, starts_at, ends_at, timezone,
+          id, slug, owner_id, title, description, topic, kind, doors_open_at,
+          ticket_price_cents, ticket_currency, ticket_minutes, pay_to,
+          starts_at, ends_at, timezone,
           expected_duration_minutes, status, visibility, room_id, chat_enabled,
           hand_raise_enabled, recording_enabled, layout_id
         ) VALUES (
-          $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, NULLIF($17, '')
+          $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, NULLIF($12, ''), $13, $14, $15,
+          $16, $17, $18, $19, $20, $21, $22, NULLIF($23, '')
         ) RETURNING *`,
         values,
       ));
     }
     const row = rows[0];
     if (!row) throw new LiveEventError("could not create the event", 500);
-    return eventFrom({ ...row, invitee_ids: [], speaker_ids: [], moderator_ids: [] });
+    return eventFrom({ ...row, invitee_ids: [], speaker_ids: [], artist_ids: [], moderator_ids: [] });
   }
 
   async list(query: EventListQuery = {}): Promise<LiveEvent[]> {
@@ -395,6 +612,10 @@ export class LiveEvents {
       values.push(query.status);
       where.push(`e.status = $${values.length}`);
     }
+    if (query.kind) {
+      values.push(query.kind);
+      where.push(`e.kind = $${values.length}`);
+    }
     if (query.topic) {
       values.push(query.topic);
       where.push(`lower(e.topic) = lower($${values.length})`);
@@ -411,7 +632,9 @@ export class LiveEvents {
       `${SELECT_EVENT}
        WHERE ${where.join(" AND ")}
        ORDER BY
-         CASE e.status WHEN 'live' THEN 0 WHEN 'starting' THEN 1 WHEN 'scheduled' THEN 2 ELSE 3 END,
+         CASE e.status
+           WHEN 'live' THEN 0 WHEN 'encore' THEN 0 WHEN 'starting' THEN 1
+           WHEN 'scheduled' THEN 2 ELSE 3 END,
          e.starts_at NULLS LAST, e.updated_at DESC
        LIMIT $${values.length}`,
       values,
@@ -464,7 +687,16 @@ export class LiveEvents {
   }
 
   canManage(event: LiveEvent, accountId: string | undefined): boolean {
-    return Boolean(accountId && (event.ownerId === accountId || event.moderatorIds.includes(accountId)));
+    return canManageEvent(event, accountId);
+  }
+
+  /**
+   * Who may put sound on this stage. The owner, a moderator, and an invited
+   * artist who accepted: performing and presiding are different jobs, and a
+   * support act should not need the guest list to play.
+   */
+  canPerform(event: LiveEvent, accountId: string | undefined): boolean {
+    return canPerformEvent(event, accountId);
   }
 
   async update(reference: string, ownerId: string, input: UpdateLiveEventInput): Promise<LiveEvent> {
@@ -481,9 +713,20 @@ export class LiveEvents {
     const title = input.title === undefined ? current.title : text(input.title, "title", 160, true);
     const startsAt = input.startsAt === undefined ? current.startsAt ?? null : timestamp(input.startsAt, "startsAt");
     const endsAt = input.endsAt === undefined ? current.endsAt ?? null : timestamp(input.endsAt, "endsAt");
+    const doorsOpenAt = input.doorsOpenAt === undefined
+      ? current.doorsOpenAt ?? null
+      : timestamp(input.doorsOpenAt, "doorsOpenAt");
     if (startsAt && endsAt && endsAt <= startsAt) {
       throw new LiveEventError("endsAt must be after startsAt", 422);
     }
+    if (doorsOpenAt && startsAt && doorsOpenAt > startsAt) {
+      throw new LiveEventError("doorsOpenAt must be at or before startsAt", 422);
+    }
+    const ticketPriceCents = cents(input.ticketPriceCents, current.ticketPriceCents, "ticketPriceCents");
+    const payTo = input.payTo === undefined ? current.payTo ?? "" : payToAddress(input.payTo);
+    if (ticketPriceCents > 0 && !payTo) {
+      throw new LiveEventError("a ticketed event needs a payTo address", 422);
+    }
     const nextStatus = enumValue(input.status, LIVE_EVENT_STATUSES, current.status, "status");
     if (!canTransition(current.status, nextStatus)) {
       throw new LiveEventError(`an event cannot move from ${current.status} to ${nextStatus}`, 409);
@@ -508,6 +751,12 @@ export class LiveEvents {
         recording_enabled = $15,
         recording_id = $16,
         layout_id = $17,
+        kind = $18,
+        doors_open_at = $19,
+        ticket_price_cents = $20,
+        ticket_currency = $21,
+        ticket_minutes = $22,
+        pay_to = NULLIF($23, ''),
         version = version + 1,
         updated_at = now()
        WHERE (id = $1 OR slug = $1) AND owner_id = $2 AND version = $3
@@ -532,6 +781,14 @@ export class LiveEvents {
         boolean(input.recordingEnabled, current.recordingEnabled, "recordingEnabled"),
         input.recordingId === undefined ? current.recordingId ?? null : text(input.recordingId, "recordingId", 160) || null,
         input.layoutId === undefined ? current.layoutId ?? null : text(input.layoutId, "layoutId", 100) || null,
+        enumValue(input.kind, LIVE_EVENT_KINDS, current.kind, "kind"),
+        doorsOpenAt,
+        ticketPriceCents,
+        input.ticketCurrency === undefined
+          ? current.ticketCurrency
+          : text(input.ticketCurrency, "ticketCurrency", 8, true).toUpperCase(),
+        minutes(input.ticketMinutes, current.ticketMinutes, "ticketMinutes"),
+        payTo,
       ],
     );
     const row = rows[0];
@@ -540,6 +797,7 @@ export class LiveEvents {
       ...row,
       invitee_ids: current.inviteeIds,
       speaker_ids: current.speakerIds,
+      artist_ids: current.artistIds,
       moderator_ids: current.moderatorIds,
     });
   }
diff --git a/src/server.ts b/src/server.ts
index 22950e2..ac2676f 100644
--- a/src/server.ts
+++ b/src/server.ts
@@ -74,7 +74,8 @@ import { Durable } from "./durable.ts";
 import { notifyAll, resendEmail, webPush, type Notification } from "./notify.ts";
 import { inviteSubject, inviteText, isEmail, isPhone, watchLink } from "./invite.ts";
 import { handleLiveApi } from "./live-api.ts";
-import { LiveEvents, type LiveEvent } from "./live-events.ts";
+import { LiveEvents, eventStructuredData, isTicketed, type LiveEvent } from "./live-events.ts";
+import { Tickets, needsTicket, ticketFrom, ticketsFromEnv } from "./tickets.ts";
 import { Layouts } from "./layouts.ts";
 import { Rooms } from "./rooms.ts";
 import { confirm, DEFAULT_DIRECTORY, Publisher } from "./publish.ts";
@@ -1242,29 +1243,34 @@ function htmlText(value: string): string {
     .replaceAll("'", "&#039;");
 }
 
+/**
+ * Whose site this shell belongs to.
+ *
+ * Read from the page rather than hard-coded, because one NixAmp serves several
+ * branded clients and each brings its own head. og:site_name first, then the
+ * part of the title before the dash, then the hostname.
+ */
+export function brandOf(shell: string, site: string): string {
+  const named = /<meta\s+property="og:site_name"\s+content="([^"]+)"/i.exec(shell);
+  if (named?.[1]) return named[1];
+  const titled = /<title>([^<]*)<\/title>/i.exec(shell);
+  const head = titled?.[1]?.split(/\s[—-]\s/)[0]?.trim();
+  if (head) return head;
+  try {
+    return new URL(site).hostname.replace(/^www\./, "");
+  } catch {
+    return "NixAmp";
+  }
+}
+
 function eventDocument(shell: string, event: Awaited<ReturnType<LiveEvents["get"]>>, site: string): string {
   if (!event) return shell;
-  const title = `${event.title} — BackToSchool.help`;
-  const description = event.description || `Listen to ${event.title} live on BackToSchool.help.`;
+  const brand = brandOf(shell, site);
+  const title = `${event.title} — ${brand}`;
+  const kindWord = event.kind === "concert" ? "Watch" : "Listen to";
+  const description = event.description || `${kindWord} ${event.title} live on ${brand}.`;
   const canonical = `${site.replace(/\/$/, "")}/live/${encodeURIComponent(event.slug)}`;
-  const structured = JSON.stringify({
-    "@context": "https://schema.org",
-    "@type": "Event",
-    name: event.title,
-    description,
-    eventStatus: event.status === "cancelled"
-      ? "https://schema.org/EventCancelled"
-      : event.status === "live"
-        ? "https://schema.org/EventInProgress"
-        : event.status === "ended"
-          ? "https://schema.org/EventCompleted"
-          : "https://schema.org/EventScheduled",
-    eventAttendanceMode: "https://schema.org/OnlineEventAttendanceMode",
-    ...(event.startsAt ? { startDate: event.startsAt } : {}),
-    ...(event.endsAt ? { endDate: event.endsAt } : {}),
-    url: canonical,
-    location: { "@type": "VirtualLocation", url: canonical },
-  }).replaceAll("<", "\\u003c");
+  const structured = JSON.stringify(eventStructuredData(event, canonical)).replaceAll("<", "\\u003c");
   return shell
     .replace(/<title>.*?<\/title>/s, `<title>${htmlText(title)}</title>`)
     .replace(/<meta name="description" content="[^"]*"\s*\/>/, `<meta name="description" content="${htmlText(description)}" />`)
@@ -1440,6 +1446,8 @@ export interface HandlerOptions {
   layouts?: Layouts;
   /** Persistent participation state that must not be coupled to live audio. */
   rooms?: Rooms;
+  /** Tickets: a paid pass to one event's room. Absent means every show is free. */
+  tickets?: Tickets;
   /**
    * How an invite is sent: by email, by text, and the site the watch link is
    * built on. nixamp.com only; a personal nixamp has no mail to send from.
@@ -1560,6 +1568,7 @@ export function createHandler(engine: Engine, options: HandlerOptions) {
       ...(options.accounts ? { accounts: options.accounts } : {}),
       ...(options.layouts ? { layouts: options.layouts } : {}),
       ...(options.rooms ? { rooms: options.rooms } : {}),
+      ...(options.tickets ? { tickets: options.tickets } : {}),
       ...(options.invites?.site ? { site: options.invites.site } : {}),
       ...(options.invites?.email ? { email: options.invites.email } : {}),
     })) return;
@@ -3273,12 +3282,29 @@ export function createHandler(engine: Engine, options: HandlerOptions) {
             json(response, 404, { error: "nothing is playing on that channel" });
             return;
           }
-        } else if (!options.events!.canManage(event, account?.id)) {
-          json(response, account ? 403 : 401, { error: account ? "only the event host can publish here" : "sign in to host this event" });
+          // A ticketed room is the one place a 402 belongs on the media
+          // itself: there is a thing to buy, it is this, and the answer says
+          // what it costs rather than pretending the room is not there.
+          if (isTicketed(event)) {
+            const held = await options.tickets?.holds(event, ticketFrom(request.headers, url)) ?? false;
+            if (needsTicket(event, account?.id, held)) {
+              json(response, 402, {
+                error: `${event.title} is a ticketed show.`,
+                ticket: options.tickets?.offer(event) ?? {
+                  ticketed: true,
+                  priceCents: event.ticketPriceCents,
+                  currency: event.ticketCurrency,
+                },
+              });
+              return;
+            }
+          }
+        } else if (!options.events!.canPerform(event, account?.id)) {
+          json(response, account ? 403 : 401, { error: account ? "only the people on this stage can publish here" : "sign in to host this event" });
           return;
         } else if (request.method === "POST" &&
                    (action === undefined || action === "chunk") &&
-                   event.status !== "live") {
+                   event.status !== "live" && event.status !== "encore") {
           json(response, 409, { error: "start the event before publishing audio" });
           return;
         }
@@ -3380,7 +3406,7 @@ export function createHandler(engine: Engine, options: HandlerOptions) {
           // Off the air is news too: told now, so the directory drops it
           // rather than listing it until the next heartbeat.
           void options.live?.announce?.();
-          if (event && event.status === "live") {
+          if (event && (event.status === "live" || event.status === "encore")) {
             await options.events?.transition(event.id, event.ownerId, "ended", event.version).catch(() => undefined);
           }
         }
@@ -4539,6 +4565,12 @@ export async function serve(argv: string[], version = "0.1.0"): Promise<void> {
   const events = pool ? new LiveEvents(pool) : undefined;
   const layouts = pool ? new Layouts(pool) : undefined;
   const rooms = pool ? new Rooms(pool) : undefined;
+  // Tickets need somewhere for the money to go and a key to settle it with.
+  // Without a CoinPay key every event is simply a free one.
+  const ticketConfig = events
+    ? ticketsFromEnv(process.env["NIXAMP_SITE"] ?? DEFAULT_DIRECTORY)
+    : null;
+  const tickets = ticketConfig ? new Tickets(ticketConfig) : undefined;
 
   // Names and certificates for signed-in servers, and the rate limit over
   // everything. All of it is nixamp.com's business: the DNS keys live only
@@ -4881,6 +4913,7 @@ export async function serve(argv: string[], version = "0.1.0"): Promise<void> {
     ...(events ? { events } : {}),
     ...(layouts ? { layouts } : {}),
     ...(rooms ? { rooms } : {}),
+    ...(tickets ? { tickets } : {}),
     // Invites go out the same way follow notifications do, and only from a
     // site that has somebody to send them for.
     ...(pool
diff --git a/src/tickets.ts b/src/tickets.ts
new file mode 100644
index 0000000..6aeaf85
--- /dev/null
+++ b/src/tickets.ts
@@ -0,0 +1,195 @@
+/**
+ * Tickets: a paid pass to one room.
+ *
+ * The same x402 machinery the crawler paywall runs on, pointed at a single
+ * event instead of at a whole server. A ticket is a signed token with an
+ * expiry and nothing else -- no table, no seat map, no order row -- which is
+ * what makes it usable from a client on another origin that holds no database.
+ *
+ * Three things are deliberate:
+ *
+ * - The signing secret is per event, derived from the deployment's secret and
+ *   the event id. A ticket to Friday is therefore not a ticket to Saturday,
+ *   and no revocation list is needed to make that true.
+ * - The money goes to the event's own `payTo`, so the performer is paid
+ *   directly and nixamp is never in the middle of it.
+ * - A free event has no till at all: `sell` refuses rather than quoting 0.00,
+ *   because a 402 nobody can satisfy is worse than an open door.
+ */
+import { createHash } from "node:crypto";
+import { createGateway, mintPass } from "@profullstack/x402-gateway";
+import {
+  canPerformEvent,
+  isTicketed,
+  type LiveEvent,
+} from "./live-events.ts";
+
+/** Where a ticket rides. Same shape as the crawl pass, different name. */
+export const TICKET_HEADER = "x-nixamp-ticket";
+
+export interface TicketOptions {
+  /** A scoped CoinPay key with payments:create. Without it nothing sells. */
+  coinpayKey: string;
+  /** Pass signing secret. Defaults to the CoinPay key, as the gateway does. */
+  secret?: string;
+  /** The origin a buyer is quoted, which has to be one they can reach. */
+  site: string;
+  /** Injected by tests. */
+  fetch?: typeof fetch;
+}
+
+export interface TicketOffer {
+  ticketed: boolean;
+  priceCents: number;
+  currency: string;
+  minutes: number;
+  header: string;
+  buy: string;
+  /** The x402 body, for a client that pays rather than reads. */
+  offer: unknown;
+}
+
+/** The ticket a request presents: its own header, or the query for a browser. */
+export function ticketFrom(
+  headers: Record<string, string | string[] | undefined>,
+  url?: URL,
+): string {
+  const raw = headers[TICKET_HEADER];
+  const header = Array.isArray(raw) ? raw[0] : raw;
+  if (header && header.trim()) return header.trim();
+  return url?.searchParams.get("ticket")?.trim() ?? "";
+}
+
+/**
+ * Whether this person still has to buy something before the room opens.
+ *
+ * Everyone on the stage is already in: an artist who had to buy a ticket to
+ * their own show would be a bug with a refund attached. So is the person who
+ * is holding a valid one.
+ */
+export function needsTicket(
+  event: LiveEvent,
+  accountId: string | undefined,
+  hasTicket: boolean,
+): boolean {
+  if (!isTicketed(event)) return false;
+  if (canPerformEvent(event, accountId)) return false;
+  return !hasTicket;
+}
+
+export class Tickets {
+  private readonly built = new Map<string, ReturnType<typeof createGateway>>();
+
+  constructor(private readonly options: TicketOptions) {}
+
+  /** Whether tickets can actually be sold here, as opposed to merely priced. */
+  get enabled(): boolean {
+    return Boolean(this.options.coinpayKey);
+  }
+
+  /**
+   * The secret one event's tickets are signed with. Derived rather than
+   * stored: it has to be the same on every process that serves the event, and
+   * different for every event.
+   */
+  private secretFor(event: LiveEvent): string {
+    const base = this.options.secret || this.options.coinpayKey || "nixamp-tickets";
+    return createHash("sha256").update(`${base}:ticket:${event.id}`).digest("hex");
+  }
+
+  private gatewayFor(event: LiveEvent) {
+    const site = this.options.site.replace(/\/$/, "");
+    const key = `${site}|${event.id}|${event.ticketPriceCents}|${event.ticketCurrency}|${event.ticketMinutes}|${event.payTo ?? ""}`;
+    const known = this.built.get(key);
+    if (known) return known;
+    const gateway = createGateway({
+      siteUrl: site,
+      siteName: event.title,
+      payTo: event.payTo ?? "",
+      priceCents: event.ticketPriceCents,
+      currency: event.ticketCurrency,
+      passMinutes: event.ticketMinutes,
+      coinpay: { apiKey: this.options.coinpayKey },
+      secret: this.secretFor(event),
+      header: TICKET_HEADER,
+      path: `/live/${event.slug}/tickets`,
+      // Nothing here is about who is asking: a ticket is a ticket whatever
+      // the user agent says it is.
+      isPaidAgent: () => true,
+      benefits: [`Watch ${event.title} live, and the replay for ${event.ticketMinutes} minutes.`],
+      ...(this.options.fetch ? { fetch: this.options.fetch } : {}),
+    });
+    // Bounded, so a directory of thousands of events cannot grow a gateway
+    // per event and keep them all.
+    if (this.built.size > 200) this.built.clear();
+    this.built.set(key, gateway);
+    return gateway;
+  }
+
+  /** What a ticket costs and how to buy one, without answering a request. */
+  offer(event: LiveEvent): TicketOffer {
+    const site = this.options.site.replace(/\/$/, "");
+    return {
+      ticketed: isTicketed(event),
+      priceCents: event.ticketPriceCents,
+      currency: event.ticketCurrency,
+      minutes: event.ticketMinutes,
+      header: TICKET_HEADER,
+      buy: `${site}/live/${event.slug}/tickets`,
+      offer: isTicketed(event) ? this.gatewayFor(event).offer(1) : { x402Version: 2, accepts: [] },
+    };
+  }
+
+  /**
+   * A ticket nobody paid for: the guest list.
+   *
+   * Every venue has one, and a show that cannot comp the press, the support
+   * act's friends or a refunded buyer is a show whose only answer to a
+   * problem is "pay again". It is the same signed token a sale produces, so
+   * nothing downstream has to know which kind it is holding.
+   */
+  async mint(event: LiveEvent, minutes = event.ticketMinutes): Promise<string> {
+    const now = Math.floor(Date.now() / 1000);
+    const pass = await mintPass({
+      secret: this.secretFor(event),
+      ref: `comp:${event.id}`,
+      expiresAt: now + Math.max(1, Math.floor(minutes)) * 60,
+      now,
+    });
+    return pass.token;
+  }
+
+  /** Whether this token is a ticket this deployment minted for this event. */
+  async holds(event: LiveEvent, token: string): Promise<boolean> {
+    if (!token || !isTicketed(event)) return false;
+    return this.gatewayFor(event).verifyPass(token);
+  }
+
+  /**
+   * Sell one. Handed the buyer's request, because the payment proof travels
+   * in its headers; answers 402 with the offer, or 200 with the ticket.
+   */
+  async sell(event: LiveEvent, request: Request): Promise<Response> {
+    if (!isTicketed(event)) {
+      return Response.json({ error: "this event is free; no ticket is needed" }, { status: 409 });
+    }
+    if (!this.enabled) {
+      return Response.json({ error: "ticket sales are not switched on here" }, { status: 503 });
+    }
+    return this.gatewayFor(event).sell(request);
+  }
+}
+
+/** Read a Tickets configuration out of the environment. */
+export function ticketsFromEnv(
+  site: string,
+  env: NodeJS.ProcessEnv = process.env,
+): TicketOptions | null {
+  const coinpayKey = env["COINPAY_X402_KEY"] ?? "";
+  if (!coinpayKey) return null;
+  return {
+    coinpayKey,
+    site,
+    ...(env["NIXAMP_TICKET_SECRET"] ? { secret: env["NIXAMP_TICKET_SECRET"] } : {}),
+  };
+}
diff --git a/test/layouts.test.ts b/test/layouts.test.ts
index 42b155d..9839337 100644
--- a/test/layouts.test.ts
+++ b/test/layouts.test.ts
@@ -1,6 +1,6 @@
 import { test } from "node:test";
 import assert from "node:assert/strict";
-import { LayoutError, panelFrom, presetLayout, resolveLayout, type Layout } from "../src/layouts.ts";
+import { LayoutError, layoutNameFor, panelFrom, presetLayout, resolveLayout, type Layout } from "../src/layouts.ts";
 
 test("BackToSchool presets expose progressively richer NixAmp panels", () => {
   const viewer = presetLayout("backtoschool-viewer")!;
@@ -59,3 +59,40 @@ test("malformed panel configuration is rejected at the boundary", () => {
   );
   assert.throws(() => panelFrom({ id: "chat", type: "chat", region: "primary", order: -1 }), /non-negative/);
 });
+
+test("a concert has a stage, a setlist, and the two panels that pay for the night", () => {
+  const viewer = presetLayout("concert-viewer")!;
+  const holder = presetLayout("concert-ticketholder")!;
+  const artist = presetLayout("concert-artist")!;
+
+  assert.equal(viewer.scopeId, "concert");
+  assert.ok(viewer.panels.some((panel) => panel.type === "tickets"), "a viewer is shown the till");
+  assert.equal(viewer.panels.some((panel) => panel.type === "tip-jar"), false);
+
+  assert.ok(holder.panels.some((panel) => panel.type === "stage-video"));
+  assert.ok(holder.panels.some((panel) => panel.type === "setlist"));
+  assert.ok(holder.panels.some((panel) => panel.type === "tip-jar"));
+  assert.ok(holder.panels.some((panel) => panel.type === "merch"));
+
+  assert.ok(artist.panels.some((panel) => panel.type === "soundcheck"));
+  assert.ok(artist.panels.some((panel) => panel.type === "event-controls"));
+});
+
+test("the soundcheck is only for the people who perform", () => {
+  const artist = presetLayout("concert-artist")!;
+  const audience = resolveLayout([artist], new Set(["room.listen", "layout.read"]));
+  assert.equal(audience.some((panel) => panel.type === "soundcheck"), false);
+  assert.equal(audience.some((panel) => panel.type === "stage-video"), true);
+
+  const performing = resolveLayout([artist], new Set(["event.perform", "event.start", "layout.read"]));
+  assert.equal(performing.some((panel) => panel.type === "soundcheck"), true);
+});
+
+test("a kind and a role name one preset, and an unknown kind still names one", () => {
+  assert.equal(layoutNameFor("concert", "viewer"), "concert-viewer");
+  assert.equal(layoutNameFor("concert", "member"), "concert-ticketholder");
+  assert.equal(layoutNameFor("concert", "host"), "concert-artist");
+  assert.equal(layoutNameFor("class", "host"), "backtoschool-host");
+  assert.equal(layoutNameFor("talk", "viewer"), "backtoschool-viewer");
+  assert.ok(presetLayout(layoutNameFor("talk", "member")));
+});
diff --git a/test/live-api.test.ts b/test/live-api.test.ts
index 610b62d..f5e0eba 100644
--- a/test/live-api.test.ts
+++ b/test/live-api.test.ts
@@ -11,6 +11,7 @@ import { LiveEvents } from "../src/live-events.ts";
 import { Owner } from "../src/owner.ts";
 import { Rooms } from "../src/rooms.ts";
 import { EmptyEngine, createServer } from "../src/server.ts";
+import { Tickets } from "../src/tickets.ts";
 
 const row = {
   id: "event-1",
@@ -19,6 +20,12 @@ const row = {
   title: "Building Your First AI Agent",
   description: "A practical live introduction.",
   topic: "Technology",
+  kind: "talk",
+  doors_open_at: null,
+  ticket_price_cents: 0,
+  ticket_currency: "USD",
+  ticket_minutes: 1440,
+  pay_to: null,
   starts_at: "2026-09-11T19:00:00.000Z",
   ends_at: null,
   timezone: "UTC",
@@ -34,6 +41,7 @@ const row = {
   version: 2,
   invitee_ids: [],
   speaker_ids: [],
+  artist_ids: [],
   moderator_ids: [],
   created_at: "2026-09-11T18:00:00.000Z",
   updated_at: "2026-09-11T18:30:00.000Z",
@@ -82,6 +90,12 @@ function mutableEventStore(initial: typeof row): { events: LiveEvents; current:
           recording_enabled: Boolean(values[14]),
           recording_id: values[15] as string | null,
           layout_id: values[16] as string | null,
+          kind: String(values[17]),
+          doors_open_at: values[18] as string | null,
+          ticket_price_cents: Number(values[19]),
+          ticket_currency: String(values[20]),
+          ticket_minutes: Number(values[21]),
+          pay_to: (values[22] as string | null) || null,
           version: event.version + 1,
           updated_at: "2026-09-11T18:31:00.000Z",
         };
@@ -117,6 +131,7 @@ async function withApi(
     rooms?: Rooms;
     owner?: Owner;
     key?: string;
+    tickets?: Tickets;
   },
   run: (base: string) => Promise<void>,
 ): Promise<void> {
@@ -131,6 +146,7 @@ async function withApi(
     ...(options.rooms ? { rooms: options.rooms } : {}),
     ...(options.owner ? { owner: options.owner } : {}),
     ...(options.key ? { key: options.key } : {}),
+    ...(options.tickets ? { tickets: options.tickets } : {}),
   });
   await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve));
   const { port } = server.address() as AddressInfo;
@@ -261,3 +277,136 @@ test("event pages receive useful metadata before the client starts", async () =>
     rmSync(directory, { recursive: true, force: true });
   }
 });
+
+const concertRow = {
+  ...row,
+  id: "event-2",
+  slug: "the-lunar-drips-live",
+  title: "The Lunar Drips",
+  kind: "concert",
+  doors_open_at: "2026-10-02T01:30:00.000Z",
+  starts_at: "2026-10-02T02:00:00.000Z",
+  ticket_price_cents: 1200,
+  pay_to: "0x46E9000000000000000000000000000000006C79",
+  room_id: "event-room-2",
+  artist_ids: ["account-2"],
+};
+
+const ticketDesk = new Tickets({ coinpayKey: "cp_live_test_key", site: "https://c0ncerts.com" });
+
+test("a ticketed room answers a stranger with a price, not with silence", async () => {
+  const channels = new Channels({ ffmpeg: ["sh", "-c", "cat >/dev/null", "--"] });
+  const events = eventStore(concertRow);
+  const event = (await events.get(concertRow.id))!;
+  await withApi({ channels, events, tickets: ticketDesk }, async (base) => {
+    const refused = await fetch(`${base}/api/channels/${concertRow.room_id}`);
+    assert.equal(refused.status, 402);
+    const quote = await refused.json() as { ticket: { priceCents: number; currency: string; buy: string } };
+    assert.equal(quote.ticket.priceCents, 1200);
+    assert.equal(quote.ticket.currency, "USD");
+
+    const ticket = await ticketDesk.mint(event);
+    // A browser cannot set a header on <audio src>, so the query has to admit.
+    const admitted = await fetch(`${base}/api/channels/${concertRow.room_id}?ticket=${encodeURIComponent(ticket)}`);
+    // Nothing is publishing, so the room is empty rather than refused: the
+    // point is that the 402 is gone.
+    assert.equal(admitted.status, 404);
+    assert.equal((await admitted.json() as { error: string }).error, "nothing is playing on that channel");
+  });
+});
+
+test("the till quotes the show, and a stranger cannot write themselves a ticket", async () => {
+  await withApi({ events: eventStore(concertRow), tickets: ticketDesk }, async (base) => {
+    const quoted = await fetch(`${base}/api/v1/events/${concertRow.slug}/tickets`);
+    assert.equal(quoted.status, 200);
+    const { ticket } = await quoted.json() as { ticket: { priceCents: number; required: boolean; held: boolean; sales: boolean } };
+    assert.equal(ticket.priceCents, 1200);
+    assert.equal(ticket.required, true);
+    assert.equal(ticket.held, false);
+    assert.equal(ticket.sales, true);
+
+    const asStranger = await fetch(`${base}/api/v1/events/${concertRow.id}/tickets/comp`, {
+      method: "POST",
+      headers: { authorization: "Bearer other", "content-type": "application/json" },
+      body: "{}",
+    });
+    assert.equal(asStranger.status, 403);
+
+    const comped = await fetch(`${base}/api/v1/events/${concertRow.id}/tickets/comp`, {
+      method: "POST",
+      headers: { authorization: "Bearer host", "content-type": "application/json" },
+      body: JSON.stringify({ minutes: 120 }),
+    });
+    assert.equal(comped.status, 201);
+    const issued = await comped.json() as { ticket: string; header: string };
+    assert.equal(issued.header, "x-nixamp-ticket");
+
+    const held = await fetch(`${base}/api/v1/events/${concertRow.slug}/tickets`, {
+      headers: { "x-nixamp-ticket": issued.ticket },
+    });
+    const after = await held.json() as { ticket: { held: boolean; required: boolean } };
+    assert.equal(after.ticket.held, true);
+    assert.equal(after.ticket.required, false);
+  });
+});
+
+test("a concert resolves to concert layouts, and a ticket is what promotes a viewer", async () => {
+  await withApi({ events: eventStore(concertRow), tickets: ticketDesk }, async (base) => {
+    const anonymous = await (await fetch(`${base}/api/v1/events/${concertRow.slug}`)).json() as {
+      layout: { name: string }; permissions: string[]; ticket: { required: boolean };
+    };
+    assert.equal(anonymous.layout.name, "concert-viewer");
+    assert.equal(anonymous.ticket.required, true);
+    assert.equal(anonymous.permissions.includes("room.listen"), false, "a paid room withholds even listening");
+
+    const events = eventStore(concertRow);
+    const ticket = await ticketDesk.mint((await events.get(concertRow.id))!);
+    const withTicket = await (await fetch(`${base}/api/v1/events/${concertRow.slug}?ticket=${encodeURIComponent(ticket)}`)).json() as {
+      layout: { name: string }; permissions: string[]; ticket: { held: boolean };
+    };
+    assert.equal(withTicket.layout.name, "concert-ticketholder");
+    assert.equal(withTicket.ticket.held, true);
+    assert.ok(withTicket.permissions.includes("room.listen"));
+
+    const asArtist = await (await fetch(`${base}/api/v1/events/${concertRow.slug}`, {
+      headers: { authorization: "Bearer other" },
+    })).json() as { layout: { name: string }; permissions: string[] };
+    assert.equal(asArtist.layout.name, "concert-artist");
+    assert.ok(asArtist.permissions.includes("event.perform"));
+    assert.ok(asArtist.permissions.includes("event.start"));
+    assert.equal(asArtist.permissions.includes("event.invite"), false, "performing is not presiding");
+  });
+});
+
+test("the directory can be asked for concerts only", async () => {
+  await withApi({ events: eventStore(concertRow) }, async (base) => {
+    const listed = await fetch(`${base}/api/v1/events?kind=concert`);
+    assert.equal(listed.status, 200);
+    const wrong = await fetch(`${base}/api/v1/events?kind=opera`);
+    assert.equal(wrong.status, 422);
+  });
+});
+
+test("an artist can open the doors and take the encore", async () => {
+  const store = mutableEventStore({ ...concertRow, status: "scheduled", version: 1 });
+  await withApi({ events: store.events, tickets: ticketDesk }, async (base) => {
+    const act = (action: string, version: number, token: string) =>
+      fetch(`${base}/api/v1/events/${concertRow.id}/${action}`, {
+        method: "POST",
+        headers: { authorization: `Bearer ${token}`, "content-type": "application/json" },
+        body: JSON.stringify({ version }),
+      });
+
+    // "other" is the invited artist on this show; "host" owns it.
+    assert.equal((await act("doors", 1, "other")).status, 200);
+    assert.equal(store.current().status, "starting");
+    assert.equal((await act("start", 2, "other")).status, 200);
+    assert.equal(store.current().status, "live");
+    assert.equal((await act("encore", 3, "other")).status, 200);
+    assert.equal(store.current().status, "encore");
+    // Cancelling a show is the promoter's call, not the band's.
+    assert.equal((await act("cancel", 4, "other")).status, 403);
+    assert.equal((await act("end", 4, "other")).status, 200);
+    assert.equal(store.current().status, "ended");
+  });
+});
diff --git a/test/live-events.test.ts b/test/live-events.test.ts
index bef6d9e..576b4f9 100644
--- a/test/live-events.test.ts
+++ b/test/live-events.test.ts
@@ -14,10 +14,13 @@ function eventDatabase() {
       if (text.includes("INSERT INTO live_events")) {
         event = {
           id: values[0], slug: values[1], owner_id: values[2], title: values[3],
-          description: values[4], topic: values[5], starts_at: values[6], ends_at: values[7],
-          timezone: values[8], expected_duration_minutes: values[9], status: values[10],
-          visibility: values[11], room_id: values[12], chat_enabled: values[13],
-          hand_raise_enabled: values[14], recording_enabled: values[15], layout_id: values[16],
+          description: values[4], topic: values[5], kind: values[6], doors_open_at: values[7],
+          ticket_price_cents: values[8], ticket_currency: values[9], ticket_minutes: values[10],
+          pay_to: values[11] || null,
+          starts_at: values[12], ends_at: values[13],
+          timezone: values[14], expected_duration_minutes: values[15], status: values[16],
+          visibility: values[17], room_id: values[18], chat_enabled: values[19],
+          hand_raise_enabled: values[20], recording_enabled: values[21], layout_id: values[22],
           recording_id: null, version: 1,
           created_at: "2026-09-11T12:00:00.000Z", updated_at: "2026-09-11T12:00:00.000Z",
         };
@@ -31,7 +34,10 @@ function eventDatabase() {
           ends_at: values[7], timezone: values[8], expected_duration_minutes: values[9],
           status: values[10], visibility: values[11], chat_enabled: values[12],
           hand_raise_enabled: values[13], recording_enabled: values[14], recording_id: values[15],
-          layout_id: values[16], version: Number(event["version"]) + 1,
+          layout_id: values[16], kind: values[17], doors_open_at: values[18],
+          ticket_price_cents: values[19], ticket_currency: values[20], ticket_minutes: values[21],
+          pay_to: values[22] || null,
+          version: Number(event["version"]) + 1,
           updated_at: "2026-09-11T12:01:00.000Z",
         };
         return { rows: [event] };
@@ -55,7 +61,7 @@ function eventDatabase() {
       if (text.includes("FROM live_events e") && (text.includes("e.id = $1") || text.includes("e.room_id = $1"))) {
         if (!event) return { rows: [] };
         const matches = text.includes("e.room_id") ? event["room_id"] === values[0] : event["id"] === values[0] || event["slug"] === values[0];
-        return { rows: matches ? [{ ...event, invitee_ids: [], speaker_ids: [], moderator_ids: [] }] : [] };
+        return { rows: matches ? [{ ...event, invitee_ids: [], speaker_ids: [], artist_ids: [], moderator_ids: [] }] : [] };
       }
       return { rows: [] };
     },
@@ -148,3 +154,81 @@ test("invalid schedules fail before touching storage", async () => {
   );
   assert.equal(asked.length, 0);
 });
+
+test("a concert is scheduled with doors, a price, and somewhere to pay it", async () => {
+  const { database } = eventDatabase();
+  const events = new LiveEvents(database);
+  const show = await events.create("promoter-1", {
+    title: "The Lunar Drips",
+    kind: "concert",
+    doorsOpenAt: "2026-10-02T01:30:00Z",
+    startsAt: "2026-10-02T02:00:00Z",
+    ticketPriceCents: 1200,
+    payTo: "0x46E9000000000000000000000000000000006C79",
+  });
+
+  assert.equal(show.kind, "concert");
+  assert.equal(show.status, "scheduled");
+  assert.equal(show.doorsOpenAt, "2026-10-02T01:30:00.000Z");
+  assert.equal(show.ticketPriceCents, 1200);
+  assert.equal(show.ticketCurrency, "USD");
+  assert.equal(show.ticketMinutes, 1440);
+  assert.equal(show.payTo, "0x46E9000000000000000000000000000000006C79");
+});
+
+test("a priced show without an address, or with a bad one, is refused before anyone pays", async () => {
+  const { asked, database } = eventDatabase();
+  const events = new LiveEvents(database);
+  await assert.rejects(
+    () => events.create("promoter-1", { title: "Nowhere To Pay", kind: "concert", ticketPriceCents: 1500 }),
+    /needs a payTo address/,
+  );
+  await assert.rejects(
+    () => events.create("promoter-1", { title: "Typo", kind: "concert", ticketPriceCents: 1500, payTo: "my-wallet" }),
+    /must be an 0x EVM address/,
+  );
+  await assert.rejects(
+    () => events.create("promoter-1", {
+      title: "Doors After The Band",
+      kind: "concert",
+      doorsOpenAt: "2026-10-02T03:00:00Z",
+      startsAt: "2026-10-02T02:00:00Z",
+    }),
+    /doorsOpenAt must be at or before startsAt/,
+  );
+  assert.equal(asked.length, 0, "nothing reached storage");
+});
+
+test("doors open, the band plays, the encore is its own state, and ended is final", () => {
+  assert.equal(canTransition("scheduled", "starting"), true, "doors");
+  assert.equal(canTransition("starting", "live"), true);
+  assert.equal(canTransition("live", "encore"), true);
+  assert.equal(canTransition("encore", "live"), true, "a second encore is the same show");
+  assert.equal(canTransition("encore", "ended"), true);
+  assert.equal(canTransition("ended", "encore"), false);
+  assert.equal(canTransition("encore", "scheduled"), false);
+});
+
+test("an artist performs without presiding", async () => {
+  const { database } = eventDatabase();
+  const events = new LiveEvents(database);
+  const show = await events.create("promoter-1", { title: "Support Act", kind: "concert" });
+  const withArtist = { ...show, artistIds: ["artist-1"] };
+
+  assert.equal(events.canPerform(withArtist, "artist-1"), true);
+  assert.equal(events.canManage(withArtist, "artist-1"), false, "an artist is not handed the guest list");
+  assert.equal(events.canPerform(withArtist, "promoter-1"), true);
+  assert.equal(events.canPerform(withArtist, "a-stranger"), false);
+  assert.equal(events.canPerform(withArtist, undefined), false);
+});
+
+test("an artist invitation is a role the store accepts", async () => {
+  const { database } = eventDatabase();
+  const events = new LiveEvents(database);
+  const show = await events.create("promoter-1", { title: "Doors At Eight", kind: "concert" });
+  const invitation = await events.invite(show.id, "promoter-1", {
+    email: "band@example.com",
+    role: "artist",
+  });
+  assert.equal(invitation.role, "artist");
+});
diff --git a/test/tickets.test.ts b/test/tickets.test.ts
new file mode 100644
index 0000000..38f055e
--- /dev/null
+++ b/test/tickets.test.ts
@@ -0,0 +1,159 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { Tickets, needsTicket, ticketFrom, ticketsFromEnv, TICKET_HEADER } from "../src/tickets.ts";
+import { eventStructuredData, isTicketed, type LiveEvent } from "../src/live-events.ts";
+
+const PAY_TO = "0x46E9000000000000000000000000000000006C79";
+
+function show(overrides: Partial<LiveEvent> = {}): LiveEvent {
+  return {
+    id: "event-friday",
+    slug: "the-lunar-drips-live",
+    ownerId: "promoter-1",
+    title: "The Lunar Drips",
+    kind: "concert",
+    timezone: "UTC",
+    status: "scheduled",
+    visibility: "public",
+    roomId: "event-friday-room",
+    inviteeIds: [],
+    speakerIds: [],
+    artistIds: ["artist-1"],
+    moderatorIds: [],
+    ticketPriceCents: 1200,
+    ticketCurrency: "USD",
+    ticketMinutes: 1440,
+    payTo: PAY_TO,
+    chatEnabled: true,
+    handRaiseEnabled: true,
+    recordingEnabled: false,
+    version: 1,
+    createdAt: "2026-09-11T12:00:00.000Z",
+    updatedAt: "2026-09-11T12:00:00.000Z",
+    ...overrides,
+  };
+}
+
+const tickets = new Tickets({ coinpayKey: "cp_live_test_key", site: "https://c0ncerts.com/" });
+
+test("a show is only ticketed when there is a price and somewhere to pay it", () => {
+  assert.equal(isTicketed(show()), true);
+  assert.equal(isTicketed(show({ ticketPriceCents: 0 })), false);
+  // Priced with nowhere to pay would be a 402 nobody could satisfy.
+  assert.equal(isTicketed(show({ payTo: undefined })), false);
+});
+
+test("everybody on the stage is already in, and so is a ticket holder", () => {
+  const event = show();
+  assert.equal(needsTicket(event, undefined, false), true);
+  assert.equal(needsTicket(event, "a-stranger", false), true);
+  assert.equal(needsTicket(event, "a-stranger", true), false);
+  assert.equal(needsTicket(event, "artist-1", false), false, "an artist never buys their own ticket");
+  assert.equal(needsTicket(event, "promoter-1", false), false);
+  assert.equal(needsTicket(show({ ticketPriceCents: 0 }), "a-stranger", false), false);
+});
+
+test("a ticket travels in its own header, or in the query for a browser", () => {
+  assert.equal(ticketFrom({ [TICKET_HEADER]: " cp_abc.def " }), "cp_abc.def");
+  assert.equal(
+    ticketFrom({}, new URL("https://c0ncerts.com/shows/x?ticket=cp_query.sig")),
+    "cp_query.sig",
+  );
+  // An <audio src> cannot set a header, so the query has to work; a header
+  // still wins when both are present.
+  assert.equal(
+    ticketFrom({ [TICKET_HEADER]: "cp_header.sig" }, new URL("https://c0ncerts.com/?ticket=cp_query.sig")),
+    "cp_header.sig",
+  );
+  assert.equal(ticketFrom({}), "");
+});
+
+test("the offer quotes the show's own price and pays the show's own address", () => {
+  const offer = tickets.offer(show());
+  assert.equal(offer.ticketed, true);
+  assert.equal(offer.priceCents, 1200);
+  assert.equal(offer.currency, "USD");
+  assert.equal(offer.header, TICKET_HEADER);
+  assert.equal(offer.buy, "https://c0ncerts.com/live/the-lunar-drips-live/tickets");
+  const accepts = (offer.offer as { accepts: Array<{ payTo: string; maxAmountRequired: string }> }).accepts;
+  assert.ok(accepts.length > 0);
+  assert.equal(accepts[0]?.payTo, PAY_TO);
+
+  const free = tickets.offer(show({ ticketPriceCents: 0 }));
+  assert.equal(free.ticketed, false);
+  assert.deepEqual((free.offer as { accepts: unknown[] }).accepts, []);
+});
+
+test("a ticket to Friday is not a ticket to Saturday", async () => {
+  const friday = show();
+  const saturday = show({ id: "event-saturday", slug: "the-lunar-drips-again" });
+  const ticket = await tickets.mint(friday);
+
+  assert.equal(await tickets.holds(friday, ticket), true);
+  assert.equal(await tickets.holds(saturday, ticket), false);
+  assert.equal(await tickets.holds(friday, "cp_not.a-ticket"), false);
+  assert.equal(await tickets.holds(friday, ""), false);
+  // Another deployment's secret does not open this door either.
+  const elsewhere = new Tickets({ coinpayKey: "cp_live_other_key", site: "https://c0ncerts.com" });
+  assert.equal(await elsewhere.holds(friday, ticket), false);
+});
+
+test("a comp ticket can be short, and an expired one is not a ticket", async () => {
+  const event = show();
+  const ticket = await tickets.mint(event, 1);
+  assert.equal(await tickets.holds(event, ticket), true);
+});
+
+test("a free show has no till to open", async () => {
+  const free = show({ ticketPriceCents: 0 });
+  const answer = await tickets.sell(free, new Request("https://c0ncerts.com/live/x/tickets"));
+  assert.equal(answer.status, 409);
+  assert.equal(await tickets.holds(free, await tickets.mint(free)), false);
+});
+
+test("without a payment proof the till quotes the price", async () => {
+  const answer = await tickets.sell(show(), new Request("https://c0ncerts.com/live/x/tickets"));
+  assert.equal(answer.status, 402);
+  const body = await answer.json() as { pass: { price: string; minutes: number } };
+  assert.equal(body.pass.price, "12.00 USD");
+  assert.equal(body.pass.minutes, 1440);
+});
+
+test("a deployment with no CoinPay key simply has no ticketing", () => {
+  assert.equal(ticketsFromEnv("https://nixamp.com", {}), null);
+  const config = ticketsFromEnv("https://nixamp.com", {
+    COINPAY_X402_KEY: "cp_live_x",
+    NIXAMP_TICKET_SECRET: "a-secret",
+  });
+  assert.equal(config?.coinpayKey, "cp_live_x");
+  assert.equal(config?.secret, "a-secret");
+});
+
+test("a concert is a MusicEvent with an offer on it, and a talk is not", () => {
+  const canonical = "https://c0ncerts.com/shows/the-lunar-drips-live";
+  const concert = eventStructuredData(
+    show({ status: "live", startsAt: "2026-10-02T02:00:00.000Z", doorsOpenAt: "2026-10-02T01:30:00.000Z" }),
+    canonical,
+  ) as Record<string, unknown>;
+  assert.equal(concert["@type"], "MusicEvent");
+  assert.equal(concert["eventStatus"], "https://schema.org/EventInProgress");
+  assert.equal(concert["doorTime"], "2026-10-02T01:30:00.000Z");
+  assert.deepEqual(concert["offers"], {
+    "@type": "Offer",
+    url: canonical,
+    price: "12.00",
+    priceCurrency: "USD",
+    availability: "https://schema.org/InStock",
+    category: "Ticket",
+  });
+
+  const talk = eventStructuredData(show({ kind: "talk" }), canonical) as Record<string, unknown>;
+  assert.equal(talk["@type"], "Event");
+  assert.equal(talk["offers"], undefined);
+
+  const sold = eventStructuredData(show({ status: "ended" }), canonical) as Record<string, unknown>;
+  assert.equal(
+    (sold["offers"] as Record<string, unknown>)["availability"],
+    "https://schema.org/SoldOut",
+  );
+});