@seatlayer/js 0.43.2 → 0.45.0

package/dist/index.cjs

@@ -408,6 +408,7 @@ __export(index_exports, {
   SeatManager: () => SeatManager,
   SeatPicker: () => SeatPicker,
   SeatingChart: () => SeatingChart,
+  accessIntentDescription: () => accessIntentDescription,
   accessIntentLabel: () => accessIntentLabel,
   accessLine: () => accessLine,
   accessLinkBadge: () => accessLinkBadge,
@@ -420,6 +421,8 @@ __export(index_exports, {
   createBuyerAccessContext: () => createBuyerAccessContext,
   createControllerSink: () => createControllerSink,
   dropReviewRows: () => dropReviewRows,
+  intentForbidsCopy: () => intentForbidsCopy,
+  intentSwitchBlockedCopy: () => intentSwitchBlockedCopy,
   isPublicChannelId: () => isPublicChannelId,
   markerLetter: () => markerLetter,
   markerOf: () => markerOf,
@@ -6901,13 +6904,59 @@ function retryAfterCopy(details) {
 }
 function accessLine(access) {
   if (!access || !access.intent) return "\u2014";
-  const base = access.intent === "server" ? "Website integration" : access.intent === "hosted_link" ? "Buyer link" : "Not distributed yet";
+  const base = access.intent === "server" ? "Website integration" : access.intent === "hosted_link" ? "Buyer link" : access.intent === "internal" ? "Your staff sell these" : "Protected reserve";
   const grants = access.hasActiveGrants ? "in use now" : access.lastMintAt ? `last used ${new Date(access.lastMintAt).toLocaleDateString()}` : null;
   const detail = access.detail ?? grants;
   return detail ? `${base} \xB7 ${detail}` : base;
 }
 function accessIntentLabel(intent) {
-  return intent === "internal" ? "Internal selling \u2014 our own staff sell these" : intent === "server" ? "Server integration \u2014 our backend lets buyers in" : intent === "hosted_link" ? "Hosted access link \u2014 SeatLayer issues the link" : "No buyer access yet \u2014 the allocation is just protected";
+  return intent === "internal" ? "Sell through your own staff" : intent === "server" ? "Integrate a website or app" : intent === "hosted_link" ? "Sell with a buyer link" : "Keep as protected reserve";
+}
+function accessIntentDescription(intent) {
+  switch (intent) {
+    case "internal":
+      return "Only your own box office can sell these seats, through your secret key. Buyer links and website integrations are refused.";
+    case "server":
+      return "Your website's backend mints each buyer a short-lived session for these seats. Buyer links are refused; the code lives on the Embed page.";
+    case "hosted_link":
+      return "SeatLayer makes a link you send to a named group. They open it and buy only these seats. No other route can sell them.";
+    default:
+      return "Nobody can buy these seats. Every way of letting a buyer in \u2014 a buyer link, your website, even your own staff \u2014 is refused while this is the route. The seats stay out of public sale.";
+  }
+}
+function intentForRoute(route) {
+  return route === "hosted_link" ? "hosted_link" : route === "server" ? "server" : route === "staff" ? "internal" : null;
+}
+function intentForbidsCopy(details) {
+  const current = parseIntent(details?.accessIntent);
+  const wanted = intentForRoute(details?.route);
+  const head = `This channel is set to "${accessIntentLabel(current)}"`;
+  return wanted ? `${head}, so it cannot do that. Switch it to "${accessIntentLabel(wanted)}" first.` : `${head}, so it cannot do that. Choose a different route for this channel first.`;
+}
+function parseIntent(value) {
+  return value === "internal" || value === "server" || value === "hosted_link" || value === "none" ? value : "none";
+}
+function plural(count, one, many) {
+  return `${count.toLocaleString()} ${count === 1 ? one : many}`;
+}
+function intentSwitchBlockedCopy(details) {
+  const links = Math.max(0, details?.liveAccessLinks ?? 0);
+  const sessions = Math.max(0, details?.activeSessions ?? 0);
+  const from = parseIntent(details?.from);
+  const to = parseIntent(details?.to);
+  const live = [
+    links ? plural(links, "buyer link is live", "buyer links are live") : null,
+    sessions ? plural(sessions, "buyer is in a checkout", "buyers are in a checkout") : null
+  ].filter(Boolean).join(", and ");
+  const headline = `${live || "Buyers are inside this channel"} on "${accessIntentLabel(from)}". Moving it to "${accessIntentLabel(to)}" changes what happens to them.`;
+  const consequences = [];
+  if (links) {
+    consequences.push(`${plural(links, "buyer link closes", "buyer links close")} immediately. Anyone who has not opened it yet never will \u2014 send a new link if you still need one.`);
+  }
+  if (sessions) {
+    consequences.push(`${plural(sessions, "buyer who is already in a checkout keeps", "buyers who are already in a checkout keep")} their seats and can finish paying. Nobody is thrown out. No new buyers come in this way, so the old route empties on its own within 12 hours.`);
+  }
+  return { headline, consequences };
 }
 var ACCESS_LINK_DEFAULTS = {
   maxRedemptions: 100,
@@ -6972,6 +7021,11 @@ function accessLinkErrorCopy(err) {
       return "That link is no longer active, so it cannot be rotated or revoked.";
     case "channel_unavailable":
       return "This channel is paused or archived, so it cannot let new buyers in. Resume it first.";
+    // The channel declares a different sale route. The UI declares `hosted_link`
+    // before it creates, so reaching this means the declaration itself was
+    // refused or raced — say which route is in the way, not the code.
+    case "channel_access_intent_forbids":
+      return intentForbidsCopy(err?.details);
     case "end_active_sessions_required":
       return "Choose what happens to the buyers who already came in through this link.";
     case "not_found":
@@ -7205,13 +7259,31 @@ var ManageApi = class {
     const qs = params.toString();
     return this.auth(`/v1/events/${encodeURIComponent(key)}/channels/preview${qs ? `?${qs}` : ""}`);
   }
-  /** Declare how buyers are meant to reach this channel. Drives the rail's
-   *  access line and turns "No buyer access configured" from information into a
-   *  warning when the organizer says the channel is for buyer self-service. */
-  setChannelAccessIntent(key, channelId, accessIntent) {
+  /**
+   * Choose which sale route this channel opens.
+   *
+   * Since the server's 2026-08-06 change this is AUTHORIZATION, not a label:
+   * exactly one of the four routes may mint buyer access for the channel and the
+   * other three refuse with 409 `channel_access_intent_forbids`. The default is
+   * `none`, which refuses all four — so a route has to be declared before any
+   * buyer-facing action on the channel can succeed.
+   *
+   * Switching the route while buyers are already inside the current one is
+   * refused with 409 `channel_intent_switch_blocked`, whose `details` name what
+   * is live (`liveAccessLinks`, `activeSessions`). Retry with
+   * `acknowledgeLiveAccess: true`: hosted links on the channel are revoked,
+   * while sessions already minted keep their holds and drain on their own.
+   * `intentSwitch` is present on the response ONLY when the switch disturbed
+   * something, so the ordinary case stays the two-key body it has always been.
+   */
+  setChannelAccessIntent(key, channelId, accessIntent, opts = {}) {
     return this.auth(`/v1/events/${encodeURIComponent(key)}/channels/${encodeURIComponent(channelId)}`, {
       method: "PATCH",
-      body: { accessIntent }
+      body: {
+        accessIntent,
+        ...opts.acknowledgeLiveAccess ? { acknowledgeLiveAccess: true } : {},
+        ...opts.reason ? { reason: opts.reason } : {}
+      }
     });
   }
   // ---- hosted access links (M8) ----
@@ -7226,8 +7298,11 @@ var ManageApi = class {
    * Platform bounds are enforced server-side and reported as 422 with the rule
    * spelled out in `ManageApiError.serverMessage`.
    *
-   * Side effect by design: this also declares the channel's access intent as
-   * `hosted_link`, so the rail stops saying "no buyer access configured".
+   * NOT a side effect any more. This used to SET the channel's access intent to
+   * `hosted_link`; since 2026-08-06 it REQUIRES it, and a channel declaring any
+   * other route refuses with 409 `channel_access_intent_forbids`. Callers must
+   * declare the route first — `ChannelsMode` does exactly that before it
+   * creates, so a first buyer link on a fresh channel is still one gesture.
    */
   createAccessLink(key, channelId, input = {}) {
     return this.auth(
@@ -7384,7 +7459,23 @@ var CHANNELS_CSS = (
 .slm-ch-counts b.bump{animation:slm-ch-bump var(--slm-mo-base) var(--slm-mo-spring)}
 @keyframes slm-ch-bump{0%,100%{transform:none}35%{transform:translateY(-2px) scale(1.08)}}
 .slm-ch-access{margin-top:6px;font-size:10.5px;color:var(--slm-muted)}
-.slm-ch-more{flex:none;color:var(--slm-muted);font-weight:800;padding:0 4px;min-height:28px}
+/* A row that opens its channel must READ as pressable, and be one for a keyboard
+   too. It is a role="button" div rather than a <button> because the \u22EF control
+   lives inside it, and a button inside a button is not valid HTML. */
+.slm-ch-row.open{cursor:pointer}
+.slm-ch-row.open:hover{border-color:var(--slm-accent);background:color-mix(in srgb,var(--slm-accent) 6%,var(--slm-surface))}
+.slm-ch-row.open:focus-visible{outline:2px solid var(--slm-accent);outline-offset:2px}
+.slm-ch-row.open:active{border-color:var(--slm-accent)}
+.slm-ch-more{flex:none;color:var(--slm-muted);font-weight:800;padding:0 4px;min-height:28px;border-radius:6px}
+.slm-ch-more:hover{color:var(--slm-text)}
+.slm-ch-more:focus-visible{outline:2px solid var(--slm-accent);outline-offset:1px;color:var(--slm-text)}
+.slm-ch-menu{display:flex;flex-direction:column;gap:8px}
+.slm-ch-menu .slm-btn{width:100%}
+/* loading is a state, never a flash of empty: same slot, visibly working */
+.slm-ch-busy{display:flex;align-items:center;gap:9px;font-size:12.5px;color:var(--slm-muted);padding:12px 0}
+.slm-ch-busy::before{content:"";width:9px;height:9px;border-radius:50%;background:var(--slm-accent);flex:none;
+  animation:slm-ch-pulse var(--slm-mo-ambient) var(--slm-mo-in-out) infinite}
+@keyframes slm-ch-pulse{0%,100%{opacity:.25;transform:scale(.7)}50%{opacity:1;transform:scale(1)}}
 .slm-ch-selsrc{display:flex;flex-direction:column;gap:5px;margin:8px 0 12px}
 .slm-ch-selsrc-row{display:flex;align-items:center;gap:8px;font-size:12px;font-variant-numeric:tabular-nums}
 .slm-ch-selsrc-row .mk{width:15px;height:15px;border-radius:4px;display:grid;place-items:center;font-size:8px;
@@ -7394,10 +7485,14 @@ var CHANNELS_CSS = (
 .slm-ch-selnum.bump{animation:slm-ch-bump var(--slm-mo-base) var(--slm-mo-spring)}
 .slm-ch-row2{display:flex;gap:8px;margin-top:8px}
 .slm-ch-row2 .slm-btn{flex:1;min-width:0}
-/* distribute options \u2014 two actions, each with the one sentence that explains it */
+/* distribute routes \u2014 four choices, each with the one sentence that explains it.
+   The current one is NAMED in its own card, never signalled by colour alone. */
 .slm-ch-dist{display:flex;flex-direction:column;gap:6px;padding:12px;margin-bottom:8px;border:1px solid var(--slm-line);
   border-radius:10px;background:var(--slm-surface)}
-.slm-ch-dist b{font-size:13px;font-weight:800}
+.slm-ch-dist.on{border-color:var(--slm-accent,#8b7cf6)}
+.slm-ch-dist b{font-size:13px;font-weight:800;display:flex;align-items:center;gap:8px;justify-content:space-between}
+.slm-ch-dist b .cur{font-size:10.5px;font-weight:700;letter-spacing:.04em;text-transform:uppercase;
+  color:var(--slm-accent,#8b7cf6);white-space:nowrap}
 .slm-ch-dist .why{color:var(--slm-muted);font-size:11.5px;line-height:1.45}
 .slm-ch-dist .slm-btn{width:100%;margin-top:2px}
 .slm-ch-alert{display:flex;align-items:flex-start;gap:9px;padding:11px 13px;border-radius:10px;font-size:12.5px;
@@ -7516,6 +7611,7 @@ var CHANNELS_CSS = (
   .slm-ch-meter i,.slm-ch-radio{transition:none!important}
   .slm-ch-staged.shake,.slm-ch-tick,.slm-ch-bucket,.slm-ch-scrim,.slm-ch-dialog,
   .slm-ch-counts b.bump,.slm-ch-selnum.bump{animation:none!important}
+  .slm-ch-busy::before{animation:none!important;opacity:1}
   .slm-ch-staged.shake{outline:2px solid #e5484d;outline-offset:2px}
   .slm-ch-staged.done{outline:2px solid #5bd39b;outline-offset:2px}
 }
@@ -7576,6 +7672,18 @@ var ChannelsMode = class {
     this.focusedSectionId = null;
     this.showArchived = false;
     this.detailChannelId = null;
+    /**
+     * Whether the organizer has asked to assign seats.
+     *
+     * The list rail leads with the CHANNELS. The assignment tooling — destination
+     * picker plus five select-by routes — used to paint unconditionally above that
+     * list, so a first-time organizer met a workbench for a job they had not asked
+     * to do, with the thing they came for pushed below the fold. It is now
+     * disclosed on intent: the "Assign seats to a channel" action under the list,
+     * the map's own "Assign seats" segment, or simply having a selection. The
+     * selection rail always shows the tools, because there the intent is proven.
+     */
+    this.assignOpen = false;
     this.targetChannelId = "";
     this.conflict = false;
     this.dialog = null;
@@ -7602,8 +7710,16 @@ var ChannelsMode = class {
     this.previewAudience = [];
     this.previewIncludePublic = false;
     this.previewProjection = null;
-    this.previewSupported = null;
-    // null = not yet probed
+    /**
+     * The buyer-preview read, as one honest state rather than a boolean.
+     *
+     * `previewSupported: boolean | null` could say "this worker has no projection
+     * route", but it could not say "the read is in flight" or "the read failed" —
+     * both of those painted an audience picker with no result underneath, which
+     * reads as "this audience can buy nothing". Loading and error are now states
+     * of their own, and the error one offers a retry.
+     */
+    this.previewState = "idle";
     this.pollTimer = null;
     this.layer = null;
     this.canvas = null;
@@ -7641,6 +7757,7 @@ var ChannelsMode = class {
     if (this.active) return;
     this.active = true;
     this.mapIntent = "pan";
+    this.assignOpen = false;
     this.focusedSectionId = null;
     this.assignmentRowsCache = null;
     this.railHtml = null;
@@ -8150,6 +8267,7 @@ var ChannelsMode = class {
     this.view = view;
     if (view === "inspect") {
       this.previewProjection = null;
+      this.previewState = "idle";
       this.setBanner(false);
     } else {
       if (!this.previewAudience.length) {
@@ -8167,6 +8285,9 @@ var ChannelsMode = class {
     const audience = [...this.previewAudience];
     const names = audience.map((id) => this.nameOf(id) ?? PUBLIC_CHANNEL_NAME).join(" + ");
     this.setBanner(true, names);
+    this.previewProjection = null;
+    this.previewState = "loading";
+    if (this.active) this.paintRail();
     try {
       this.previewProjection = await this.host.api.channelPreview(this.host.eventKey, audience, {
         // Naming Public sale as the audience IS asking for public inventory; the
@@ -8174,14 +8295,14 @@ var ChannelsMode = class {
         // this the request would resolve to an empty scope and 422.
         includePublic: this.previewIncludePublic || audience.some(isPublicChannelId)
       });
-      this.previewSupported = true;
+      this.previewState = "ready";
       const eligibleSeats = this.previewProjection.available === false ? void 0 : this.previewProjection.counts?.eligible ?? this.previewProjection.eligible?.length;
       this.setBanner(true, names, eligibleSeats);
     } catch (err) {
       const status = err instanceof ManageApiError ? err.status : 0;
-      this.previewSupported = !(status === 404 || status === 405 || status === 501);
+      this.previewState = status === 404 || status === 405 || status === 501 ? "unsupported" : "error";
       this.previewProjection = null;
-      if (this.previewSupported) this.host.onError(err);
+      if (this.previewState === "error") this.host.onError(err);
     }
     if (this.active) {
       this.paintRail();
@@ -8222,13 +8343,14 @@ var ChannelsMode = class {
     }
     if (this.loading && !this.list) {
       this.setRailHtml(`<p class="slm-eyebrow">Sales channels</p>
-        <div class="slm-empty">Loading allocations\u2026</div>`);
+        <div class="slm-ch-busy" role="status" data-ch-state="list-loading">Loading channels and allocations\u2026</div>`);
       return;
     }
     if (!this.list && this.loadError) {
       if (this.setRailHtml(`<p class="slm-eyebrow">Sales channels</p>
-        <div class="slm-ch-alert err" role="alert"><span>\u26A0</span>
-        <span><b>Couldn't load sales channels.</b> Everything else on this event still works.
+        <div class="slm-ch-alert err" role="alert" data-ch-state="list-error"><span>\u26A0</span>
+        <span><b>Couldn't load sales channels.</b> This event may well have channels \u2014 we could not read them.
+        Everything else on this event still works.
         <button type="button" data-ch-act="retry">Try again</button></span></div>`)) {
         rail.querySelector('[data-ch-act="retry"]')?.addEventListener("click", () => {
           void this.refresh();
@@ -8287,10 +8409,13 @@ var ChannelsMode = class {
     const marker = this.markerFor(channel.id);
     const badgeKind = opts.builtin ? "builtin" : channel.state;
     const dim = channel.state === "paused" || channel.state === "archived" ? " dim" : "";
-    const cls = `slm-ch-row${opts.builtin ? " public" : ""}${channel.state === "archived" ? " archived" : ""}${this.detailChannelId === channel.id ? " on" : ""}`;
-    const more = !opts.builtin && this.caps.manage ? `<button type="button" class="slm-ch-more" data-ch-detail="${esc(channel.id)}"
-          aria-label="Manage ${esc(channel.name)}">\u22EF</button>` : "";
-    return `<div class="${cls}">
+    const opens = !opts.builtin && this.caps.manage && this.detailChannelId !== channel.id;
+    const cls = `slm-ch-row${opts.builtin ? " public" : ""}${channel.state === "archived" ? " archived" : ""}${this.detailChannelId === channel.id ? " on" : ""}${opens ? " open" : ""}`;
+    const more = !opts.builtin && this.caps.manage ? `<button type="button" class="slm-ch-more" data-ch-menu="${esc(channel.id)}"
+          aria-label="More actions for ${esc(channel.name)}" aria-haspopup="dialog">\u22EF</button>` : "";
+    const rowAttrs = opens ? ` role="button" tabindex="0" data-ch-open="${esc(channel.id)}"
+          aria-label="Open ${esc(channel.name)}"` : "";
+    return `<div class="${cls}"${rowAttrs}>
       <span class="slm-ch-head">
         <span class="slm-ch-mk${dim}" style="background:${esc(marker.color)}" aria-hidden="true">${esc(marker.letter)}</span>
         <span class="slm-ch-name">${esc(channel.name)}</span>
@@ -8304,41 +8429,68 @@ var ChannelsMode = class {
   listRailHtml() {
     const list = this.list;
     const archivedCount = list.channels.filter((channel) => channel.state === "archived").length;
+    const visible = list.channels.filter((channel) => this.showArchived || channel.state !== "archived");
     const rows = [
       this.channelRowHtml(list.publicSale, { builtin: true }),
-      ...list.channels.filter((channel) => this.showArchived || channel.state !== "archived").map((channel, index) => this.channelRowHtml(channel, { index }))
+      ...visible.map((channel, index) => this.channelRowHtml(channel, { index }))
     ].join("");
+    const empty = visible.length ? "" : `<p class="slm-note" data-ch-state="list-empty">${archivedCount && !this.showArchived ? `No open channels \u2014 every seat is on public sale. ${archivedCount.toLocaleString()} archived channel${archivedCount === 1 ? " is" : "s are"} hidden below.` : "No private channels yet \u2014 every seat is on public sale."}</p>`;
     const create = this.caps.manage ? `<button type="button" class="slm-btn ghost" style="width:100%" data-ch-act="create">+ Create channel</button>` : "";
     const readOnly = this.caps.manage ? "" : `<p class="slm-note">You can see how inventory is allocated. Changing it needs channel-management permission.</p>`;
     return `
-      ${this.caps.manage ? this.assignmentToolsHtml() : ""}
       <p class="slm-eyebrow">Sales channels</p>
       <p class="slm-hint">Channel colours and names are only visible to organizers, never to buyers.</p>
       <div class="slm-ch-list">${rows}</div>
+      ${empty}
       ${create}
       ${readOnly}
+      ${this.assignEntryHtml()}
       <p class="slm-note" style="margin-top:10px">
         <button type="button" class="slm-linkbtn" data-ch-act="toggle-archived" aria-pressed="${this.showArchived}"
           style="text-align:left">${this.showArchived ? "Hide" : "Show"} archived${archivedCount ? ` (${archivedCount})` : ""}</button>
       </p>`;
   }
+  /**
+   * The assignment entry point on the list rail.
+   *
+   * Collapsed it is ONE plain-language action, so the channels the organizer came
+   * for stay at the top of the panel. Opened it is the same tool set that has
+   * always worked, in the same order, plus the way back out — and opening it is
+   * also what the map's "Assign seats" segment does, so the two routes into the
+   * job cannot disagree about whether it is running.
+   */
+  assignEntryHtml() {
+    if (!this.caps.manage) return "";
+    if (!this.assignOpen) {
+      return `
+        <button type="button" class="slm-btn ghost" style="width:100%;margin-top:8px"
+          data-ch-act="assign-open" aria-expanded="false">Assign seats to a channel</button>
+        <p class="slm-note">Move whole sections, rows, a dragged area or single seats out of public sale
+          and into a channel. Nothing moves until you review and apply.</p>`;
+    }
+    return `<div style="margin-top:8px">${this.assignmentToolsHtml({ collapsible: true })}</div>`;
+  }
   /**
    * Destination-first assignment controls.
    *
    * These used to live only inside the selection rail, which meant every route
    * into them was gated behind "select a seat on the map first" — the section,
    * row and category choosers were invisible until the organizer had already
-   * done the work by hand. They now paint above the channel list too, so the
-   * destination is chosen first and whole sections and rows are discoverable
-   * without learning a hidden seat-first workflow.
+   * done the work by hand. They are still reachable before a seat is selected,
+   * but they are no longer the first thing in the panel: on the list rail they
+   * are disclosed by `assignEntryHtml`, and there they carry a way back out
+   * (`collapsible`). In the selection rail there is nothing to disclose — a
+   * selection IS the intent — so they paint unconditionally and without Done.
    */
-  assignmentToolsHtml() {
+  assignmentToolsHtml(opts = {}) {
     const options = this.assignableChannels().map((channel) => `<option value="${esc(channel.id)}"${channel.id === this.targetChannelId ? " selected" : ""}>${esc(channel.name)}</option>`).join("");
     const sections = this.host.sections().length ? '<button type="button" class="slm-btn ghost" data-ch-act="pick-sections">Sections</button>' : "";
     const rows = this.assignmentRows().length ? '<button type="button" class="slm-btn ghost" data-ch-act="pick-rows">Rows</button>' : "";
     const dragClass = this.mapIntent === "assign" ? "slm-btn" : "slm-btn ghost";
+    const done = opts.collapsible ? `<button type="button" class="slm-linkbtn" data-ch-act="assign-close"
+          aria-expanded="true" style="float:right;font-weight:800">Done</button>` : "";
     return `
-      <p class="slm-eyebrow">Assign inventory</p>
+      <p class="slm-eyebrow">${done}Assign inventory</p>
       <div class="slm-field">
         <label for="slm-ch-target">Assign to</label>
         <select class="slm-select" id="slm-ch-target" data-ch-target>${options}</select>
@@ -8388,8 +8540,16 @@ var ChannelsMode = class {
       <p class="slm-note">The seat list offers the same selection with checkboxes for keyboard and screen-reader use.</p>`;
   }
   detailRailHtml(channelId) {
+    const back = `<p class="slm-eyebrow">
+      <button type="button" class="slm-linkbtn" data-ch-act="back" style="text-align:left">\u2039 All channels</button>
+    </p>`;
     const channel = this.list?.channels.find((item) => item.id === channelId);
-    if (!channel) return this.listRailHtml();
+    if (!channel) {
+      return `${back}
+        <div class="slm-ch-alert warn" role="status" data-ch-state="detail-gone"><span>\u2139</span>
+          <span><b>This channel is no longer on this event.</b> It was archived or removed while you had it open.
+          ${this.showArchived ? "" : "Archived channels are hidden \u2014 use \u201CShow archived\u201D on the list to see it."}</span></div>`;
+    }
     const lifecycle = this.caps.manage ? `
       <p class="slm-eyebrow" style="margin-top:18px">Lifecycle</p>
       <div class="slm-ch-row2" style="margin-top:2px">
@@ -8400,58 +8560,59 @@ var ChannelsMode = class {
       <p class="slm-note">Archive returns the allocation to a destination you choose. Nothing is ever deleted silently.</p>` : "";
     const access = this.caps.manage ? this.distributeHtml(channel) : "";
     return `
-      <p class="slm-eyebrow">
-        <button type="button" class="slm-linkbtn" data-ch-act="back" style="text-align:left">\u2039 All channels</button>
-      </p>
+      ${back}
       <p class="slm-eyebrow">Channel \xB7 ${esc(channel.name)}</p>
       <div class="slm-ch-list">${this.channelRowHtml(channel)}</div>
       ${access}
       ${lifecycle}`;
   }
   /**
-   * "Distribute" — how the seats in this channel actually reach a buyer.
+   * "Distribute" — the ONE way this channel's seats reach a buyer.
+   *
+   * All four routes are here, and this is a real chooser again. It was cut down
+   * to two actions in 0.42.0 for a good reason: `access_intent` was stored,
+   * audited, and read by nothing, so "Keep as protected reserve" and "Sell
+   * through your own staff" were labels an organizer could set and then wait
+   * forever for something to happen. The server closed that hole on 2026-08-06 —
+   * each declaration now opens exactly one route and REFUSES the other three —
+   * so all four are honest choices and belong on the surface.
    *
-   * This replaced a four-value "access intent" picker (none / internal /
-   * hosted_link / server). Two of those values did nothing anywhere: no buyer or
-   * inventory path reads `access_intent`, so `none` and `internal` were labels an
-   * organizer could set and then wait forever for something to happen. A third,
-   * `hosted_link`, is not the organizer's to choose at all — the server sets it
-   * when a buyer link is created and clears it when the last live one is revoked.
+   * None of the old copy came back with them. These sentences are written
+   * against the enforcement matrix (`accessIntentDescription`), which is why
+   * each one says what the route refuses as well as what it allows.
    *
-   * So this is two ACTIONS, not a setting: create a buyer link, or point the
-   * channel at a website integration. Both of them do something the moment they
-   * are pressed. A legacy row still carrying `none` or `internal` renders the
-   * neutral "not distributed yet" state with both actions offered — the stored
-   * value is left alone (it is organizer-declared metadata and the API that
-   * writes it is unchanged), it simply no longer has a control of its own.
+   * The current route is stated, not merely styled: a chooser whose selection
+   * you have to infer from a border is not a chooser. Its card carries a
+   * "Current route" marker and drops its own select button, because pressing it
+   * would do nothing.
    */
   distributeHtml(channel) {
     const intent = channel.access?.intent ?? "none";
     const live = channel.access?.hasActiveGrants === true;
-    const state = live ? intent === "server" ? "Your website is letting buyers in. Only they can buy these seats." : "A buyer link is live. Only people with that link can buy these seats." : intent === "server" ? "Set up for your website \u2014 no buyer has come through yet. Seats stay reserved." : "Not distributed yet \u2014 seats stay reserved.";
-    const option = (title, why, action, cta, primary) => `<div class="slm-ch-dist">
-      <b>${esc(title)}</b>
-      <span class="why">${esc(why)}</span>
-      <button type="button" class="slm-btn${primary ? "" : " ghost"}" data-ch-act="${esc(action)}">${esc(cta)}</button>
-    </div>`;
     const linksSupported = this.linksState !== "unsupported";
+    const hasLiveLink = this.links.some(accessLinkIsLive);
+    const state = intent === "none" ? "Protected reserve \u2014 no route can sell these seats. Every buyer path is refused." : intent === "internal" ? "Your staff sell these seats. No buyer-facing route is open." : live ? intent === "server" ? "Your website is letting buyers in. Only they can buy these seats." : "A buyer link is live. Only people with that link can buy these seats." : intent === "server" ? "Set up for your website \u2014 no buyer has come through yet. Seats stay reserved." : "Set up for buyer links \u2014 no buyer has come through yet. Seats stay reserved.";
+    const option = (route, action, cta, primary) => {
+      const current = route === intent;
+      return `<div class="slm-ch-dist${current ? " on" : ""}" data-ch-route="${esc(route)}">
+        <b>${esc(accessIntentLabel(route))}${current ? '<span class="cur">Current route</span>' : ""}</b>
+        <span class="why">${esc(accessIntentDescription(route))}</span>
+        ${current && !cta ? "" : `<button type="button" class="slm-btn${primary && !current ? "" : " ghost"}"
+          data-ch-act="${esc(action)}">${esc(cta)}</button>`}
+      </div>`;
+    };
     return `
       <p class="slm-eyebrow" style="margin-top:14px">Distribute</p>
       <p class="slm-hint">${esc(state)}</p>
       ${linksSupported ? option(
-      "Sell with a buyer link",
-      "SeatLayer makes a link you send to a named group. They open it and buy only these seats.",
+      "hosted_link",
       "link-create",
-      this.links.some(accessLinkIsLive) ? "Create another buyer link" : "Create buyer link",
+      hasLiveLink ? "Create another buyer link" : "Create buyer link",
       true
     ) : ""}
-      ${option(
-      "Integrate a website or app",
-      "Your website's backend grants each buyer access \u2014 set up on the Embed page.",
-      "embed-code",
-      "Get embed code",
-      false
-    )}
+      ${option("server", "embed-code", intent === "server" ? "Get embed code" : "Use a website or app", false)}
+      ${option("internal", "route-internal", intent === "internal" ? "" : "Hand to your staff", false)}
+      ${option("none", "route-none", intent === "none" ? "" : "Keep as reserve", false)}
       ${this.hostedLinksHtml()}
       ${intent === "server" ? SERVER_INTEGRATION_HTML : ""}`;
   }
@@ -8499,16 +8660,17 @@ var ChannelsMode = class {
   hostedLinksHtml() {
     const eyebrow = `<p class="slm-eyebrow" style="margin-top:18px">Buyer links</p>`;
     if (this.linksState === "unsupported") {
-      return `${eyebrow}<div class="slm-ch-alert warn"><span>\u2139</span>
+      return `${eyebrow}<div class="slm-ch-alert warn" data-ch-state="links-unsupported"><span>\u2139</span>
         <span><b>Buyer links need a newer server.</b> Everything else on this channel works normally.</span></div>`;
     }
     if (this.linksState === "error") {
-      return `${eyebrow}<div class="slm-ch-alert err" role="alert"><span>\u26A0</span>
-        <span><b>Couldn't load this channel's links.</b>
+      return `${eyebrow}<div class="slm-ch-alert err" role="alert" data-ch-state="links-error"><span>\u26A0</span>
+        <span><b>Couldn't load this channel's links.</b> This is a failed read, not an empty list \u2014
+        any live link is still working.
         <button type="button" data-ch-act="link-reload">Try again</button></span></div>`;
     }
-    if (this.linksState === "loading" && !this.links.length) {
-      return `${eyebrow}<div class="slm-empty">Loading links\u2026</div>`;
+    if (this.linksState === "idle" || this.linksState === "loading" && !this.links.length) {
+      return `${eyebrow}<div class="slm-ch-busy" role="status" data-ch-state="links-loading">Loading buyer links\u2026</div>`;
     }
     if (!this.links.length) return "";
     return `${eyebrow}
@@ -8550,9 +8712,14 @@ var ChannelsMode = class {
     ];
     const current = this.previewAudience[0] ?? PUBLIC_CHANNEL_ID;
     const options = audienceOptions.map((entry) => `<option value="${esc(entry.id)}"${entry.id === current ? " selected" : ""}>${esc(entry.name)}</option>`).join("");
-    const unsupported = this.previewSupported === false ? `<div class="slm-ch-alert warn"><span>\u2139</span>
+    const unsupported = this.previewState === "unsupported" ? `<div class="slm-ch-alert warn" data-ch-state="preview-unsupported"><span>\u2139</span>
           <span><b>Preview needs a newer server.</b> Allocation management works normally;
           the buyer-view simulation will appear once this event's API is updated.</span></div>` : "";
+    const busy = this.previewState === "loading" ? `<div class="slm-ch-busy" role="status" data-ch-state="preview-loading">Asking the server what this audience sees\u2026</div>` : "";
+    const failed = this.previewState === "error" ? `<div class="slm-ch-alert err" role="alert" data-ch-state="preview-error"><span>\u26A0</span>
+          <span><b>Couldn't load the buyer preview.</b> Nothing is wrong with this audience's seats \u2014
+          the simulation itself failed to load.
+          <button type="button" data-ch-act="preview-retry">Try again</button></span></div>` : "";
     const unavailable = this.previewProjection?.available === false ? `<div class="slm-ch-alert warn" role="status"><span>\u23F8</span>
           <span><b>This private sale is not available.</b> ${esc((this.previewProjection.unavailable ?? []).map((entry) => `${this.nameOf(entry.channelId) ?? "This channel"} is ${entry.state}`).join("; ") || "The audience cannot buy right now")}.
           A buyer arriving with this access sees this message, not these seats.</span></div>` : "";
@@ -8573,7 +8740,7 @@ var ChannelsMode = class {
       ${includePublic}
       <p class="slm-hint">This is the same projection the buyer SDK receives for this audience \u2014 not a local
         approximation. It is read-only: clicks open seat details, and no holds are created.</p>
-      ${unsupported}${unavailable}
+      ${busy}${failed}${unsupported}${unavailable}
       <div class="slm-ch-legend">
         <div class="r"><span class="sw" style="background:#6e7bff"></span> Eligible &amp; free \u2014 buyable by this audience</div>
         <div class="r"><span class="sw" style="background:#3a4051"></span> Unavailable to this audience (one neutral state)</div>
@@ -8582,6 +8749,7 @@ var ChannelsMode = class {
       ${summary}`;
   }
   paintSelection() {
+    if (this.caps.manage && this.host.selectionLabels().length) this.assignOpen = true;
     if (this.view === "inspect" && !this.detailChannelId) this.paintRail();
   }
   wireRail() {
@@ -8592,16 +8760,27 @@ var ChannelsMode = class {
     rail.querySelectorAll("[data-ch-map]").forEach((button) => {
       button.addEventListener("click", () => {
         this.mapIntent = button.dataset.chMap === "assign" ? "assign" : "pan";
+        if (this.mapIntent === "assign") this.assignOpen = true;
         this.paintRail();
         this.onInteractionChange?.();
       });
     });
-    rail.querySelectorAll("[data-ch-detail]").forEach((button) => {
-      button.addEventListener("click", () => {
-        const channelId = button.dataset.chDetail;
-        this.detailChannelId = channelId;
-        this.paintRail();
-        void this.loadLinks(channelId).then(() => this.paintRail());
+    rail.querySelectorAll("[data-ch-open]").forEach((row) => {
+      const open = () => this.openChannel(row.dataset.chOpen);
+      row.addEventListener("click", open);
+      row.addEventListener("keydown", (event) => {
+        if (event.key !== "Enter" && event.key !== " " && event.key !== "Spacebar") return;
+        event.preventDefault();
+        open();
+      });
+    });
+    rail.querySelectorAll("[data-ch-menu]").forEach((button) => {
+      button.addEventListener("click", (event) => {
+        event.stopPropagation();
+        this.openDialog({ kind: "menu", channelId: button.dataset.chMenu });
+      });
+      button.addEventListener("keydown", (event) => {
+        event.stopPropagation();
       });
     });
     rail.querySelectorAll("[data-ch-rotate]").forEach((button) => {
@@ -8640,6 +8819,12 @@ var ChannelsMode = class {
       button.addEventListener("click", () => this.railAction(button.dataset.chAct));
     });
   }
+  /** Open a channel's detail panel and start its buyer-link read. */
+  openChannel(channelId) {
+    this.detailChannelId = channelId;
+    this.paintRail();
+    void this.loadLinks(channelId).then(() => this.paintRail());
+  }
   railAction(action) {
     switch (action) {
       case "sections":
@@ -8675,16 +8860,25 @@ var ChannelsMode = class {
         this.linksState = "idle";
         this.paintRail();
         break;
+      // Choosing the buyer-link route IS creating the first link — the dialog
+      // declares the route on submit (see `createLink`), so this stays one
+      // gesture whether the channel is already on `hosted_link` or not.
       case "link-create":
         this.openDialog({ kind: "linkCreate", channelId: this.detailChannelId });
         break;
       // The one thing this screen can actually do for a website integration is
-      // record that the channel is meant for one — which is exactly the flag the
-      // dashboard's Embed page reads before it offers the snippet. Saying so is
-      // honest; a fake "copy code" button on a screen with no code would not be.
+      // record that the channel is meant for one — and since 2026-08-06 that
+      // record is what AUTHORIZES the integration to mint buyer sessions at all,
+      // so it is the substantive half of the job, not a flag.
       case "embed-code":
         void this.chooseWebsiteIntegration();
         break;
+      case "route-internal":
+        void this.setAccessIntent("internal");
+        break;
+      case "route-none":
+        void this.setAccessIntent("none");
+        break;
       case "link-reload":
         if (this.detailChannelId) void this.reloadLinks();
         break;
@@ -8713,6 +8907,22 @@ var ChannelsMode = class {
       case "pick-category":
         this.pickCategory();
         break;
+      case "assign-open":
+        this.assignOpen = true;
+        this.paintRail();
+        break;
+      // Collapsing the tools must also disarm the marquee. Leaving it armed
+      // would hide a mode the map is still in — the organizer would drag to pan
+      // and select seats instead, with no control on screen saying why.
+      case "assign-close":
+        this.assignOpen = false;
+        this.mapIntent = "pan";
+        this.paintRail();
+        this.onInteractionChange?.();
+        break;
+      case "preview-retry":
+        void this.loadPreview();
+        break;
       default:
         break;
     }
@@ -8862,7 +9072,8 @@ var ChannelsMode = class {
               blocks.push(`<p class="slm-ch-scopehint">${(matches.length - visible.length).toLocaleString()} more row${matches.length - visible.length === 1 ? "" : "s"}. Search to narrow the list.</p>`);
             }
           });
-          list.innerHTML = blocks.join("") || `<div class="slm-ch-scope-empty">No sections or rows match \u201C${esc(query)}\u201D.</div>`;
+          list.innerHTML = blocks.join("") || (query ? `<div class="slm-ch-scope-empty" data-ch-state="scope-nomatch">No sections or rows match \u201C${esc(query)}\u201D.</div>` : `<div class="slm-ch-scope-empty" data-ch-state="scope-empty">This chart has no rows with selectable seats.
+                  Use Drag box or the seat list instead.</div>`);
           filterHint.textContent = query ? `Showing ${rendered.toLocaleString()} of ${totalMatches.toLocaleString()} matching rows. Section checkboxes still select every row in that section.` : "Showing section groups. Expand one or search to see rows.";
           list.querySelectorAll("[data-ch-scope-group]").forEach((button) => button.addEventListener("click", () => {
             const items = groups[Number(button.dataset.chScopeGroup)]?.[1] ?? [];
@@ -8912,7 +9123,8 @@ var ChannelsMode = class {
     this.renderScrim(`
       <h3 id="slm-ch-dlg-title">Add whole sections</h3>
       <p class="sub">Choose one or more. They are added to the seats already selected on the map.</p>
-      <div class="slm-ch-seatlist">${body || `<div class="slm-empty">No sections are available.</div>`}</div>
+      <div class="slm-ch-seatlist">${body || `<div class="slm-ch-scope-empty" data-ch-state="scope-empty">This chart has no sections with selectable seats.
+        Use Drag box or the seat list instead.</div>`}</div>
       <p class="slm-ch-err" data-ch-error hidden></p>
       <div class="foot">
         <button type="button" class="quiet" data-ch-close>Cancel</button>
@@ -8969,9 +9181,81 @@ var ChannelsMode = class {
     else if (state.kind === "archive") this.renderArchiveDialog(state);
     else if (state.kind === "rename") this.renderRenameDialog(state);
     else if (state.kind === "seatlist") this.renderSeatListDialog();
+    else if (state.kind === "menu") this.renderMenuDialog(state);
     else if (state.kind === "linkCreate") this.renderLinkCreateDialog(state);
     else if (state.kind === "linkRotate") this.renderLinkRotateDialog(state);
     else if (state.kind === "linkRevoke") this.renderLinkRevokeDialog(state);
+    else if (state.kind === "intentSwitch") this.renderIntentSwitchDialog(state);
+  }
+  /**
+   * `channel_intent_switch_blocked` — buyers are inside the route being left.
+   *
+   * The same review-then-acknowledge shape as the archive and chart-drop guards,
+   * because it is the same kind of decision: the server refuses once, names
+   * exactly what is at stake, and only a deliberate second press goes through.
+   * What acknowledging does is spelled out per consequence — links close now,
+   * checkouts already running survive and drain — rather than hidden behind a
+   * word like "force".
+   */
+  renderIntentSwitchDialog(state) {
+    const channel = this.list?.channels.find((item) => item.id === state.channelId);
+    const to = state.intentTo;
+    if (!channel || !to || !this.caps.manage) {
+      this.closeDialog();
+      return;
+    }
+    const { headline, consequences } = intentSwitchBlockedCopy(state.switchBlocked);
+    this.renderScrim(`
+      <h3 id="slm-ch-dlg-title">Change how ${esc(channel.name)} reaches buyers?</h3>
+      <p class="sub">${esc(headline)}</p>
+      <div class="slm-ch-alert warn" role="alert"><span>\u26A0</span><span>
+        ${consequences.map((line) => `<span style="display:block;margin-bottom:6px">${esc(line)}</span>`).join("")}
+      </span></div>
+      ${state.pendingLink ? `<p class="slm-note">Your new buyer link is created as soon as
+        the route changes \u2014 you will not have to fill the form in again.</p>` : ""}
+      <p class="slm-ch-err" data-ch-error ${state.error ? "" : "hidden"}>${esc(state.error ?? "")}</p>
+      <div class="foot">
+        <button type="button" class="quiet" data-ch-close>Leave it as it is</button>
+        <button type="button" class="slm-btn" data-ch-intent-ack${state.busy ? " disabled" : ""}>
+          ${state.busy ? "Changing\u2026" : `Change to "${esc(accessIntentLabel(to))}"`}</button>
+      </div>`, (dialog) => {
+      dialog.querySelector("[data-ch-intent-ack]")?.addEventListener("click", () => {
+        void this.acknowledgeIntentSwitch(to, state.pendingLink ?? null);
+      });
+    });
+  }
+  /**
+   * The acknowledged retry. The declare and the create stay one gesture across
+   * the sheet: if this switch was the first half of a declare-then-create, the
+   * held form finishes on the far side of the acknowledgement.
+   */
+  async acknowledgeIntentSwitch(intent, pendingLink) {
+    const channelId = this.detailChannelId;
+    if (!channelId) {
+      this.closeDialog();
+      return;
+    }
+    if (this.dialog) {
+      this.dialog.busy = true;
+      this.renderDialog();
+    }
+    const ok = await this.setAccessIntent(intent, { acknowledgeLiveAccess: true });
+    if (!ok) {
+      if (this.dialog?.kind === "intentSwitch") {
+        this.dialog.busy = false;
+        this.renderDialog();
+      }
+      return;
+    }
+    if (!pendingLink) {
+      this.closeDialog();
+      return;
+    }
+    if (this.dialog?.kind === "intentSwitch") {
+      this.dialog.busy = false;
+      this.renderDialog();
+    }
+    await this.mintLink(channelId, pendingLink);
   }
   /**
    * Mount a modal: `aria-modal` dialog, programmatic name, focus moved inside,
@@ -9224,6 +9508,59 @@ var ChannelsMode = class {
     void bar.offsetWidth;
     bar.classList.add("shake");
   }
+  /**
+   * The ⋯ menu.
+   *
+   * Opening a channel is the ROW's job now, so ⋯ carries what is left: the
+   * secondary and destructive lifecycle actions. It is rendered through the same
+   * scrim primitive as every other sheet, which is what gives it a focus trap,
+   * Escape, and a name — a bare absolutely-positioned popup would have had none
+   * of those. Archive keeps its own confirmation dialog; this menu never
+   * destroys anything by itself.
+   */
+  renderMenuDialog(state) {
+    const channel = this.list?.channels.find((item) => item.id === state.channelId);
+    if (!channel || !this.caps.manage) {
+      this.closeDialog();
+      return;
+    }
+    const paused = channel.state === "paused";
+    this.renderScrim(`
+      <h3 id="slm-ch-dlg-title">${esc(channel.name)}</h3>
+      <p class="sub">Open the channel to allocate seats and hand out buyer access.
+        These are the rest of its actions.</p>
+      <div class="slm-ch-menu">
+        <button type="button" class="slm-btn" data-ch-menu-act="open">Open channel</button>
+        <button type="button" class="slm-btn ghost" data-ch-menu-act="rename">Rename</button>
+        <button type="button" class="slm-btn ghost" data-ch-menu-act="pause">${paused ? "Resume selling" : "Pause selling"}</button>
+        <button type="button" class="slm-btn ghost" data-ch-menu-act="archive">Archive\u2026</button>
+      </div>
+      <p class="slm-note">Pausing stops new buyer access; checkouts already running can finish.
+        Archiving closes the channel for good and returns its free seats to a destination you choose.
+        Nothing is ever deleted silently.</p>
+      <div class="foot"><button type="button" class="quiet" data-ch-close>Cancel</button></div>`, (dialog) => {
+      dialog.querySelectorAll("[data-ch-menu-act]").forEach((button) => {
+        button.addEventListener("click", () => {
+          const act = button.dataset.chMenuAct;
+          if (act === "open") {
+            this.closeDialog();
+            this.openChannel(channel.id);
+            return;
+          }
+          if (act === "rename") {
+            this.openDialog({ kind: "rename", channelId: channel.id });
+            return;
+          }
+          if (act === "archive") {
+            this.openDialog({ kind: "archive", channelId: channel.id });
+            return;
+          }
+          this.closeDialog();
+          void this.togglePause(channel.id);
+        });
+      });
+    });
+  }
   renderRenameDialog(state) {
     const channel = this.list?.channels.find((item) => item.id === state.channelId);
     if (!channel) {
@@ -9259,34 +9596,74 @@ var ChannelsMode = class {
     });
   }
   /**
-   * "Get embed code" — mark the channel as reached through the organizer's own
-   * backend. The write itself is `setChannelAccessIntent(…, 'server')`, the same
-   * API the old picker called; the difference is that it is now a deliberate
-   * action with a consequence the organizer is told about, rather than one of
-   * four dropdown values with no observable effect.
+   * "Use a website or app" — declare the channel's route as `server`.
+   *
+   * This is no longer a flag the Embed page happens to read: since 2026-08-06 it
+   * is what AUTHORIZES `POST /v1/events/:key/buyer-access-sessions` to mint for
+   * this channel at all. Without it, an integration that is otherwise perfectly
+   * wired up gets a 409 on every buyer.
    */
   async chooseWebsiteIntegration() {
     const channelId = this.detailChannelId;
     if (!channelId) return;
     await this.setAccessIntent("server");
   }
-  async setAccessIntent(accessIntent) {
+  /**
+   * Declare this channel's sale route.
+   *
+   * Reports through the toast lane the rest of the rail's direct actions use.
+   * The two enforcement refusals get real answers rather than a generic failure:
+   * `channel_intent_switch_blocked` opens the review sheet (there is a decision
+   * to make, and a sheet is where decisions live), and
+   * `channel_access_intent_forbids` — which the organizer can hit by racing
+   * their own second tab — says which route is in the way.
+   */
+  async setAccessIntent(accessIntent, opts = {}) {
     const channelId = this.detailChannelId;
-    if (!channelId || !this.caps.manage) return;
+    if (!channelId || !this.caps.manage) return false;
     try {
-      await this.host.api.setChannelAccessIntent(this.host.eventKey, channelId, accessIntent);
+      const result = await this.host.api.setChannelAccessIntent(
+        this.host.eventKey,
+        channelId,
+        accessIntent,
+        opts
+      );
       await this.refresh();
-      if (accessIntent === "server") {
-        this.host.toast("Marked for your website. The embed code is on the Embed page.", "ok");
-      }
+      this.host.toast(this.intentSavedCopy(accessIntent, result?.intentSwitch), "ok");
+      return true;
     } catch (err) {
-      this.host.toast("Couldn't save how buyers reach this channel.", "err");
+      if (err instanceof ManageApiError && err.code === "channel_intent_switch_blocked") {
+        this.openDialog({
+          kind: "intentSwitch",
+          channelId,
+          intentTo: accessIntent,
+          switchBlocked: err.details
+        });
+        return false;
+      }
+      if (err instanceof ManageApiError && err.code === "channel_access_intent_forbids") {
+        this.host.toast(intentForbidsCopy(err.details), "err");
+        return false;
+      }
+      this.host.toast("Couldn't change how this channel reaches buyers.", "err");
       this.host.onError(err);
+      return false;
     }
   }
-  async togglePause() {
-    const channel = this.list?.channels.find((item) => item.id === this.detailChannelId);
-    if (!channel) return;
+  /** What just happened, including anything the switch took down with it — the
+   *  server reports `intentSwitch` only when it actually disturbed something. */
+  intentSavedCopy(intent, disturbed) {
+    const head = intent === "server" ? "Set to your website or app. The embed code is on the Embed page." : intent === "internal" ? "Only your own staff can sell this channel now." : intent === "hosted_link" ? "Set to buyer links. Create one to let buyers in." : "Kept as a protected reserve. No route can sell these seats.";
+    if (!disturbed) return head;
+    const closed = disturbed.closedLinks ? ` ${disturbed.closedLinks.toLocaleString()} buyer link${disturbed.closedLinks === 1 ? "" : "s"} closed.` : "";
+    const kept = disturbed.keptSessions ? ` ${disturbed.keptSessions.toLocaleString()} buyer${disturbed.keptSessions === 1 ? "" : "s"} already in a checkout can still finish.` : "";
+    return `${head}${closed}${kept}`;
+  }
+  /** `channelId` is explicit because this is reachable from the ⋯ menu on a row
+   *  that is NOT the open channel, as well as from the detail panel itself. */
+  async togglePause(channelId = this.detailChannelId) {
+    const channel = this.list?.channels.find((item) => item.id === channelId);
+    if (!channel || !this.caps.manage) return;
     const paused = channel.state !== "paused";
     try {
       await this.host.api.setChannelPaused(this.host.eventKey, channel.id, paused);
@@ -9534,7 +9911,35 @@ var ChannelsMode = class {
       });
     });
   }
+  /**
+   * DECLARE, then create.
+   *
+   * `createAccessLink` used to set the channel's route to `hosted_link` as a
+   * side effect, which is exactly why the picker could never refuse anything.
+   * The server took that side effect away and now REQUIRES the declaration —
+   * and channels default to `none`, so a create that did not declare first
+   * would 409 on the organizer's very first "Create buyer link".
+   *
+   * So the route is declared here, immediately before the create. It stays ONE
+   * gesture: nothing is declared while the organizer is still filling the form
+   * in (cancelling changes nothing), and if the declaration is the part that is
+   * refused, the review sheet holds this form and finishes the job on the far
+   * side of the acknowledgement.
+   */
   async createLink(channelId, input) {
+    if (!await this.ensureHostedLinkRoute(channelId, input)) return;
+    await this.mintLink(channelId, input);
+  }
+  /**
+   * The create half, on its own.
+   *
+   * Separate from `createLink` because the acknowledge path has ALREADY declared
+   * the route — with the very acknowledgement the plain declaration was refused
+   * for. Sending it back through `ensureHostedLinkRoute` would re-derive the
+   * route from a channel list that has not necessarily caught up, and could
+   * refuse the organizer a second time for a decision they just made.
+   */
+  async mintLink(channelId, input) {
     try {
       const reveal = await this.host.api.createAccessLink(this.host.eventKey, channelId, input);
       this.revealLink(reveal, { channelId });
@@ -9544,6 +9949,37 @@ var ChannelsMode = class {
       if (!(err instanceof ManageApiError)) this.host.onError(err);
     }
   }
+  /**
+   * Make sure the channel declares the buyer-link route before a link is minted.
+   *
+   * Returns false when the create must NOT proceed — either it was refused, or
+   * the decision has been handed to the switch-review sheet, which resumes it.
+   * A channel already on `hosted_link` costs no request at all, so creating a
+   * second link is the same single call it has always been.
+   */
+  async ensureHostedLinkRoute(channelId, pendingLink) {
+    const channel = this.list?.channels.find((item) => item.id === channelId);
+    if ((channel?.access?.intent ?? "none") === "hosted_link") return true;
+    try {
+      await this.host.api.setChannelAccessIntent(this.host.eventKey, channelId, "hosted_link");
+      await this.refresh();
+      return true;
+    } catch (err) {
+      if (err instanceof ManageApiError && err.code === "channel_intent_switch_blocked") {
+        this.openDialog({
+          kind: "intentSwitch",
+          channelId,
+          intentTo: "hosted_link",
+          switchBlocked: err.details,
+          pendingLink
+        });
+        return false;
+      }
+      this.showDialogError(err instanceof ManageApiError && err.code === "channel_access_intent_forbids" ? intentForbidsCopy(err.details) : "Couldn't set this channel up for buyer links. Try again.");
+      if (!(err instanceof ManageApiError)) this.host.onError(err);
+      return false;
+    }
+  }
   /**
    * The ONE-TIME reveal.
    *
@@ -12210,6 +12646,7 @@ var SeatManager = class {
   SeatManager,
   SeatPicker,
   SeatingChart,
+  accessIntentDescription,
   accessIntentLabel,
   accessLine,
   accessLinkBadge,
@@ -12222,6 +12659,8 @@ var SeatManager = class {
   createBuyerAccessContext,
   createControllerSink,
   dropReviewRows,
+  intentForbidsCopy,
+  intentSwitchBlockedCopy,
   isPublicChannelId,
   markerLetter,
   markerOf,