From 4ced86df57309799c0ee61503a36ccf35e512195 Mon Sep 17 00:00:00 2001
From: Anthony Ettinger <anthony@chovy.com>
Date: Fri, 11 Sep 2026 21:32:55 +0000
Subject: [PATCH] Live shows: a concert kind, an artist, doors and an encore,
 and a ticket

A live event now carries a kind (talk, class, concert), so one NixAmp serves
a school and a venue without either knowing about the other. Concerts bring
their own layout presets: a stage, a setlist, a tip jar, a merch shelf and a
till. The directory can be asked for one kind.

An artist is an invitation role beside moderator. They go on stage and drive
the show -- doors, start, encore, end -- without being handed the guest list;
cancelling and archiving stay with the host. The encore is its own state,
because a listener arriving during one is arriving at something and "ended"
would turn them away.

A ticket is a paid pass to one room, over x402 and settled by CoinPay: the
same machinery as the crawler paywall, scoped to a single event and paid to
the event's own address rather than to the platform. The room answers 402
with the price instead of pretending not to be there, the ticket rides in
x-nixamp-ticket or in ?ticket= for an element that cannot set a header, and
each event's passes are signed with a secret derived from the event id, so a
ticket to Friday is not a ticket to Saturday. Hosts can comp one, because a
venue with no guest list can only answer a problem with "pay again".

Nothing here is named after a site. The event page's brand is read from the
shell it is injected into rather than hard-coded, and a concert's JSON-LD is
a MusicEvent with an Offer on it.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01QuUkTrofSjQ15j79mRuy4f
---
 README.md                |  35 +++++
 src/layouts.ts           |  79 ++++++++++-
 src/live-api.ts          | 189 +++++++++++++++++++++++---
 src/live-events.ts       | 280 +++++++++++++++++++++++++++++++++++++--
 src/server.ts            |  83 ++++++++----
 src/tickets.ts           | 195 +++++++++++++++++++++++++++
 test/layouts.test.ts     |  39 +++++-
 test/live-api.test.ts    | 149 +++++++++++++++++++++
 test/live-events.test.ts |  96 +++++++++++++-
 test/tickets.test.ts     | 159 ++++++++++++++++++++++
 10 files changed, 1243 insertions(+), 61 deletions(-)
 create mode 100644 src/tickets.ts
 create mode 100644 test/tickets.test.ts

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",
+  );
+});