@seatlayer/js 0.44.0 → 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(
@@ -7410,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;
@@ -8488,49 +8567,52 @@ var ChannelsMode = class {
       ${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 : ""}`;
   }
@@ -8778,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;
@@ -9094,6 +9185,77 @@ var ChannelsMode = class {
     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,
@@ -9434,31 +9596,69 @@ 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;
     }
   }
+  /** 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) {
@@ -9711,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 });
@@ -9721,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.
    *
@@ -12387,6 +12646,7 @@ var SeatManager = class {
   SeatManager,
   SeatPicker,
   SeatingChart,
+  accessIntentDescription,
   accessIntentLabel,
   accessLine,
   accessLinkBadge,
@@ -12399,6 +12659,8 @@ var SeatManager = class {
   createBuyerAccessContext,
   createControllerSink,
   dropReviewRows,
+  intentForbidsCopy,
+  intentSwitchBlockedCopy,
   isPublicChannelId,
   markerLetter,
   markerOf,