@seatlayer/js 0.36.1 → 0.36.3

package/dist/index.cjs

@@ -38,6 +38,7 @@ var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "acce
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  ACCESS_LINK_DEFAULTS: () => ACCESS_LINK_DEFAULTS,
   ApiError: () => ApiError,
   BuyerAccessContext: () => BuyerAccessContext,
   BuyerAccessUnavailableError: () => BuyerAccessUnavailableError,
@@ -53,12 +54,18 @@ __export(index_exports, {
   SeatingChart: () => SeatingChart,
   accessIntentLabel: () => accessIntentLabel,
   accessLine: () => accessLine,
+  accessLinkBadge: () => accessLinkBadge,
+  accessLinkErrorCopy: () => accessLinkErrorCopy,
+  accessLinkIsLive: () => accessLinkIsLive,
+  accessLinkPolicyLines: () => accessLinkPolicyLines,
   attachPickerFrame: () => attachPickerFrame,
   bucketRows: () => bucketRows,
   bucketRowsHtml: () => bucketRowsHtml,
   createBuyerAccessContext: () => createBuyerAccessContext,
   createControllerSink: () => createControllerSink,
   dropReviewRows: () => dropReviewRows,
+  isPublicChannelId: () => isPublicChannelId,
+  markerLetter: () => markerLetter,
   markerOf: () => markerOf,
   mutationCount: () => mutationCount,
   needsMoveConfirmation: () => needsMoveConfirmation,
@@ -5989,8 +5996,11 @@ function attachPickerFrame(iframe, opts = {}) {
 var import_core3 = require("@seatlayer/core");
 
 // src/channelPlan.ts
-var PUBLIC_CHANNEL_ID = "";
+var PUBLIC_CHANNEL_ID = "public";
 var PUBLIC_CHANNEL_NAME = "Public sale";
+function isPublicChannelId(id) {
+  return id == null || id === "" || id === PUBLIC_CHANNEL_ID;
+}
 var CHANNEL_COLORS = [
   "#a78bfa",
   "#2dd4bf",
@@ -6005,27 +6015,35 @@ var CHANNEL_COLORS = [
 ];
 var PUBLIC_CHANNEL_COLOR = "#f4b740";
 var LETTERS = "ABCDEFGHJKLMNPQRSTUVWXYZ";
+function markerLetter(raw, fallback) {
+  const text = (raw ?? "").trim();
+  const letter = /\p{L}/u.exec(text)?.[0] ?? text[0] ?? "";
+  return (letter || fallback).toUpperCase().slice(0, 1);
+}
 function suggestMarker(name, taken) {
-  const used = new Set([...taken].map((m) => m.trim().toUpperCase()).filter(Boolean));
-  const first = (name.trim()[0] ?? "").toUpperCase();
+  const used = new Set([...taken].map((m) => markerLetter(m, "")).filter(Boolean));
+  const first = markerLetter(name, "");
   const letter = LETTERS.includes(first) && !used.has(first) ? first : [...LETTERS].find((candidate) => !used.has(candidate)) ?? (first || "X");
   return { letter, color: CHANNEL_COLORS[used.size % CHANNEL_COLORS.length] };
 }
 function markerOf(channel, index = 0) {
-  if (channel.id === PUBLIC_CHANNEL_ID) {
-    return { letter: (channel.marker || "P").slice(0, 2).toUpperCase(), color: channel.color || PUBLIC_CHANNEL_COLOR };
+  if (isPublicChannelId(channel.id)) {
+    return {
+      letter: markerLetter(channel.marker, "P"),
+      color: channel.color || PUBLIC_CHANNEL_COLOR
+    };
   }
-  const letter = (channel.marker || channel.name.trim()[0] || "?").slice(0, 2).toUpperCase();
+  const letter = markerLetter(channel.marker || channel.name, "?");
   return { letter, color: channel.color || CHANNEL_COLORS[index % CHANNEL_COLORS.length] };
 }
 function selectionSources(labels, allocation, list) {
   const counts = /* @__PURE__ */ new Map();
   for (const label of labels) {
-    const channelId = allocation.get(label) ?? PUBLIC_CHANNEL_ID;
+    const channelId = normalizeChannelId(allocation.get(label));
     counts.set(channelId, (counts.get(channelId) ?? 0) + 1);
   }
   const order = [
-    { id: PUBLIC_CHANNEL_ID, name: list?.publicSale.name ?? PUBLIC_CHANNEL_NAME },
+    { id: PUBLIC_CHANNEL_ID, name: list?.publicSale?.name ?? PUBLIC_CHANNEL_NAME },
     ...(list?.channels ?? []).map((channel) => ({ id: channel.id, name: channel.name }))
   ];
   const rows = [];
@@ -6035,10 +6053,17 @@ function selectionSources(labels, allocation, list) {
     counts.delete(entry.id);
   }
   for (const [channelId, count] of counts) {
-    rows.push({ channelId, name: channelId ? "Another channel" : PUBLIC_CHANNEL_NAME, count });
+    rows.push({
+      channelId,
+      name: isPublicChannelId(channelId) ? PUBLIC_CHANNEL_NAME : "Another channel",
+      count
+    });
   }
   return rows;
 }
+function normalizeChannelId(id) {
+  return isPublicChannelId(id) ? PUBLIC_CHANNEL_ID : id;
+}
 var SKIP_SAMPLE = 12;
 function skipBucket(labels) {
   return {
@@ -6048,7 +6073,8 @@ function skipBucket(labels) {
   };
 }
 function planAssignment(input) {
-  const { labels, targetChannelId, allocation, statusOf, nameOf } = input;
+  const { labels, allocation, statusOf, nameOf } = input;
+  const targetChannelId = normalizeChannelId(input.targetChannelId);
   const seen = /* @__PURE__ */ new Set();
   let fromPublic = 0;
   let alreadyIn = 0;
@@ -6064,7 +6090,7 @@ function planAssignment(input) {
       missing.push(label);
       continue;
     }
-    const current = allocation.get(label) ?? PUBLIC_CHANNEL_ID;
+    const current = normalizeChannelId(allocation.get(label));
     if (current === targetChannelId) {
       alreadyIn += 1;
       continue;
@@ -6185,6 +6211,78 @@ function accessLine(access) {
 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";
 }
+var ACCESS_LINK_DEFAULTS = {
+  maxRedemptions: 100,
+  maxQuantity: 4
+};
+function accessLinkBadge(link) {
+  switch (link.status ?? link.state) {
+    case "active":
+      return { text: "Active", kind: "active" };
+    case "expired":
+      return { text: "Expired", kind: "archived" };
+    case "exhausted":
+      return { text: "All used", kind: "paused" };
+    case "rotated":
+      return { text: "Replaced", kind: "archived" };
+    default:
+      return { text: "Revoked", kind: "archived" };
+  }
+}
+function accessLinkIsLive(link) {
+  return link.state === "active" && link.status === "active";
+}
+function formatMoment(ms) {
+  if (!Number.isFinite(ms)) return "\u2014";
+  return new Date(ms).toLocaleString(void 0, {
+    day: "numeric",
+    month: "short",
+    year: "numeric",
+    hour: "numeric",
+    minute: "2-digit"
+  });
+}
+function accessLinkPolicyLines(link) {
+  return [
+    { k: "Expires", v: formatMoment(link.expiresAt) },
+    {
+      k: "Redemptions",
+      v: `${link.redemptions.toLocaleString()} of ${link.maxRedemptions.toLocaleString()} used`
+    },
+    {
+      k: "Seats per buyer",
+      v: `${link.maxQuantity.toLocaleString()} seat${link.maxQuantity === 1 ? "" : "s"} maximum`
+    },
+    {
+      k: "Covers",
+      v: link.includePublic ? "This channel's allocation and Public sale seats" : "This channel's allocation only"
+    }
+  ];
+}
+function accessLinkErrorCopy(err) {
+  const fromServer = err?.serverMessage?.trim();
+  switch (err?.code) {
+    case "invalid_expiry":
+    case "invalid_max_redemptions":
+    case "invalid_max_quantity":
+    case "invalid_session_ttl":
+    case "invalid_label":
+      return fromServer || "That setting is outside what a hosted link allows. Adjust it and try again.";
+    case "too_many_access_links":
+      return fromServer || "This channel already has as many live links as it can hold. Revoke one before creating another.";
+    case "access_link_not_active":
+      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.";
+    case "end_active_sessions_required":
+      return "Choose what happens to the buyers who already came in through this link.";
+    case "not_found":
+      return "That link is no longer here. Refresh and try again.";
+    default:
+      if (err?.status === 403) return "Hosted access links need channel-management permission.";
+      return fromServer || "That did not go through. Try again.";
+  }
+}
 function dropReviewRows(details) {
   return (details?.channels ?? []).map((channel) => ({
     kind: "skip",
@@ -6201,13 +6299,14 @@ function stateBadge(state) {
 
 // src/manageApi.ts
 var ManageApiError = class extends Error {
-  constructor(status, message, code, conflicts, details) {
+  constructor(status, message, code, conflicts, details, serverMessage) {
     super(message);
     this.name = "ManageApiError";
     this.status = status;
     this.code = code;
     this.conflicts = conflicts;
     this.details = details;
+    this.serverMessage = serverMessage;
   }
 };
 async function parse(res) {
@@ -6220,7 +6319,8 @@ async function parse(res) {
       err?.error ?? `request_failed_${res.status}`,
       err?.code,
       err?.conflicts,
-      err?.details
+      err?.details,
+      typeof err?.message === "string" ? err.message : void 0
     );
   }
   return data;
@@ -6247,12 +6347,38 @@ var ManageApi = class {
   pub(path) {
     return fetch(`${this.base}${path}`, { credentials: "omit" }).then((r) => parse(r));
   }
-  // ---- realtime read (public, no token) ----
+  // ---- realtime read ----
+  /** The chart geometry. Genuinely public — it is the same map buyers see. */
   chart(key) {
     return this.pub(`/pub/events/${encodeURIComponent(key)}/chart`);
   }
+  /**
+   * The ORGANIZER's seat map: physical state, token-authed.
+   *
+   * This used to read `/pub/events/:key/objects` with no credential, which
+   * answers with the BUYER projection — every unit the caller may not buy
+   * collapses to a neutral `blocked`. An anonymous caller may buy only Public
+   * sale inventory, so the cockpit rendered every channel-allocated seat as
+   * blocked and then computed its KPIs, sell-through and (worse) its
+   * block/unblock target sets from that. `/v1/events/:key/objects` returns the
+   * unprojected snapshot the control-room read model already trusts.
+   */
   objects(key) {
-    return this.pub(`/pub/events/${encodeURIComponent(key)}/objects`);
+    return this.auth(`/v1/events/${encodeURIComponent(key)}/objects`);
+  }
+  /**
+   * Exchange the manage token for a one-use organizer socket ticket.
+   *
+   * A browser `WebSocket` cannot send an Authorization header, so the socket's
+   * scope is established here, over ordinary HTTPS. Without it the DO treats a
+   * manager socket as an anonymous public buyer and projects its deltas — so a
+   * hold inside a private allocation is structurally suppressed and the map
+   * drifts away from the truth `objects()` just established.
+   *
+   * Tickets are single-redemption and expire in ~30s: mint one per connect.
+   */
+  subscribeTicket(key) {
+    return this.auth(`/v1/events/${encodeURIComponent(key)}/subscribe-tickets`, { method: "POST" });
   }
   socketUrl(key) {
     return `${this.base.replace(/^http/, "ws")}/pub/events/${encodeURIComponent(key)}/subscribe?surface=manager`;
@@ -6390,6 +6516,58 @@ var ManageApi = class {
       body: { accessIntent }
     });
   }
+  // ---- hosted access links (M8) ----
+  /**
+   * Mint a hosted access link. The 201 is the ONE and ONLY time `url` and
+   * `capability` exist outside the buyer's browser — SeatLayer keeps a hash, so
+   * there is no route, cache, or support escalation that can produce this string
+   * again. Callers must reveal it immediately and then let it go.
+   *
+   * Every omitted field takes the server's default: expiry = when the event
+   * starts, 100 redemptions, 4 seats per buyer, this channel's allocation only.
+   * 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".
+   */
+  createAccessLink(key, channelId, input = {}) {
+    return this.auth(
+      `/v1/events/${encodeURIComponent(key)}/channels/${encodeURIComponent(channelId)}/access-links`,
+      { method: "POST", body: input }
+    );
+  }
+  /** Status only — label, expiry, redemptions, per-buyer cap, lineage, and the
+   *  live session count. Never the url, never the capability. Needs `:view`. */
+  accessLinks(key, channelId) {
+    return this.auth(
+      `/v1/events/${encodeURIComponent(key)}/channels/${encodeURIComponent(channelId)}/access-links`
+    );
+  }
+  /**
+   * Rotate — the ONLY recovery for a link nobody kept. The old URL stops opening
+   * immediately and the response is a fresh one-time reveal.
+   *
+   * `endActiveSessions` is REQUIRED, not defaulted: the organizer must say
+   * whether buyers already inside finish their checkout or lose access now. The
+   * server answers 422 `end_active_sessions_required` if it is omitted, and that
+   * refusal is correct — a UI must not pick either branch on their behalf.
+   */
+  rotateAccessLink(key, channelId, linkId, endActiveSessions) {
+    return this.auth(
+      `/v1/events/${encodeURIComponent(key)}/channels/${encodeURIComponent(channelId)}/access-links/${encodeURIComponent(linkId)}/rotate`,
+      { method: "POST", body: { endActiveSessions } }
+    );
+  }
+  /** Revoke. The link stops opening immediately; `endActiveSessions` decides
+   *  whether the buyers already inside keep their sessions. */
+  revokeAccessLink(key, channelId, linkId, endActiveSessions = false) {
+    const qs = endActiveSessions ? "?endActiveSessions=1" : "";
+    return this.auth(
+      `/v1/events/${encodeURIComponent(key)}/channels/${encodeURIComponent(channelId)}/access-links/${encodeURIComponent(linkId)}${qs}`,
+      { method: "DELETE" }
+    );
+  }
   // ---- reports (token) ----
   report(key) {
     return this.auth(`/v1/events/${encodeURIComponent(key)}/report`);
@@ -6542,6 +6720,26 @@ var CHANNELS_CSS = `
   border-radius:10px;background:rgba(244,183,64,.06);font-family:ui-monospace,Menlo,monospace;font-size:11px;
   overflow:hidden;white-space:nowrap;text-overflow:ellipsis}
 .slm-ch-err{color:#f1a4a6;font-size:11.5px;margin-top:6px}
+
+/* hosted access links \u2014 STATUS only; there is no Copy control on this card */
+.slm-ch-link{padding:10px 11px;border:1px solid var(--slm-line);border-radius:10px;background:var(--slm-surface);
+  margin-bottom:8px}
+.slm-ch-link .lk-head{display:flex;align-items:center;gap:8px}
+.slm-ch-link .lk-name{flex:1;min-width:0;font-size:12.5px;font-weight:800;overflow:hidden;text-overflow:ellipsis;
+  white-space:nowrap}
+.slm-ch-lkrow{display:flex;gap:8px;margin-top:5px;font-size:11px;color:var(--slm-muted)}
+.slm-ch-lkrow .k{flex:none;min-width:104px}
+.slm-ch-lkrow .v{color:var(--slm-text);font-variant-numeric:tabular-nums}
+.slm-ch-meter{height:5px;border-radius:3px;background:rgba(255,255,255,.09);overflow:hidden;margin-top:8px}
+.slm-ch-meter i{display:block;height:100%;background:var(--slm-accent);
+  transition:width var(--slm-mo-base) var(--slm-mo-out)}
+.slm-ch-radio{display:flex;gap:9px;align-items:flex-start;padding:11px 12px;border:1px solid var(--slm-line);
+  border-radius:10px;margin-top:8px;font-size:12.5px;cursor:pointer;
+  transition:border-color var(--slm-mo-quick) var(--slm-mo-out)}
+.slm-ch-radio:hover{border-color:var(--slm-muted)}
+.slm-ch-radio input{flex:none;margin-top:2px}
+.slm-ch-radio b{display:block;font-weight:800;margin-bottom:2px}
+.slm-ch-radio .why{display:block;color:var(--slm-muted);font-size:11.5px;line-height:1.45}
 .slm-ch-seatlist{max-height:44vh;overflow:auto;border:1px solid var(--slm-line);border-radius:10px;
   background:var(--slm-surface);margin-top:10px}
 .slm-ch-seatgroup{padding:8px 10px;border-bottom:1px solid var(--slm-line);display:flex;align-items:center;
@@ -6574,7 +6772,8 @@ var CHANNELS_CSS = `
 .slm.compact .slm-modes{display:none}
 
 @media (prefers-reduced-motion:reduce){
-  .slm-ch-layer,.slm-ch-banner,.slm-ch-staged,.slm-ch-row,.slm.compact.ch-sheet .slm-rail{transition:none!important}
+  .slm-ch-layer,.slm-ch-banner,.slm-ch-staged,.slm-ch-row,.slm.compact.ch-sheet .slm-rail,
+  .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-staged.shake{outline:2px solid #e5484d;outline-offset:2px}
@@ -6590,9 +6789,37 @@ function bucketRowsHtml(rows) {
       ${row.peek ? `<span class="peek">${esc(row.peek)}</span>` : "<span></span>"}
     </div>`).join("");
 }
+var SERVER_INTEGRATION_HTML = `
+  <p class="slm-eyebrow" style="margin-top:18px">Server integration</p>
+  <p class="slm-hint">There is nothing to set up on this screen. Your own server mints a short-lived buyer
+    access session for this channel with the SeatLayer server SDK and hands it to the widget. A channel name
+    on its own never grants access.</p>
+  <p class="slm-note"><a class="slm-linkbtn" href="https://docs.seatlayer.io/server-api/channels"
+    target="_blank" rel="noreferrer noopener">Read the server integration guide \u2192</a></p>`;
 function esc(value) {
   return String(value ?? "").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
 }
+function datetimeLocalValue(ms) {
+  const local = new Date(ms - new Date(ms).getTimezoneOffset() * 6e4);
+  return local.toISOString().slice(0, 16);
+}
+function intField(root, selector) {
+  const raw = root.querySelector(selector)?.value.trim() ?? "";
+  const value = Number(raw);
+  return raw !== "" && Number.isInteger(value) ? value : null;
+}
+function selectSecret(dialog) {
+  const node = dialog.querySelector("[data-ch-lk-url]");
+  if (!node) return;
+  try {
+    const range = document.createRange();
+    range.selectNodeContents(node);
+    const selection = window.getSelection();
+    selection?.removeAllRanges();
+    selection?.addRange(range);
+  } catch {
+  }
+}
 var ChannelsMode = class {
   constructor(host, capabilities) {
     this.active = false;
@@ -6609,6 +6836,15 @@ var ChannelsMode = class {
     this.dialog = null;
     this.detent = "medium";
     this.seatListLimit = SEAT_LIST_PAGE;
+    /**
+     * Hosted-link STATUS for the channel whose detail panel is open. This is the
+     * listing projection — it carries no url and no capability, because no route
+     * returns one. `unsupported` is the honest answer for a worker that predates
+     * M8, exactly like the buyer-preview probe.
+     */
+    this.links = [];
+    this.linksChannelId = null;
+    this.linksState = "idle";
     this.previewAudience = [];
     this.previewIncludePublic = false;
     this.previewProjection = null;
@@ -6652,6 +6888,9 @@ var ChannelsMode = class {
     if (this.pollTimer) clearInterval(this.pollTimer);
     this.pollTimer = null;
     this.closeDialog({ restoreFocus: false });
+    this.links = [];
+    this.linksChannelId = null;
+    this.linksState = "idle";
     this.layer?.classList.remove("on");
     this.host.root.classList.remove(
       "ch-mode",
@@ -6723,6 +6962,7 @@ var ChannelsMode = class {
         this.targetChannelId = list.channels.find((c) => c.state === "active")?.id ?? PUBLIC_CHANNEL_ID;
       }
       await this.loadAllocation();
+      if (this.detailChannelId) await this.loadLinks(this.detailChannelId);
       this.loading = false;
       if (this.active) {
         this.paintRail();
@@ -6749,7 +6989,7 @@ var ChannelsMode = class {
         limit: 1e3
       });
       for (const row of res.allocations) {
-        if (row.channelId && row.channelId !== PUBLIC_CHANNEL_ID) next.set(row.label, row.channelId);
+        if (!isPublicChannelId(row.channelId)) next.set(row.label, row.channelId);
       }
       this.assignmentVersion = res.assignmentVersion;
       if (!res.nextAfterLabel) break;
@@ -6759,8 +6999,13 @@ var ChannelsMode = class {
   }
   // ---- lookups --------------------------------------------------------------
   channelById(id) {
-    if (id === PUBLIC_CHANNEL_ID) {
-      return { id, name: this.list?.publicSale.name ?? PUBLIC_CHANNEL_NAME, marker: "P", color: null };
+    if (isPublicChannelId(id)) {
+      return {
+        id: PUBLIC_CHANNEL_ID,
+        name: this.list?.publicSale?.name ?? PUBLIC_CHANNEL_NAME,
+        marker: "P",
+        color: null
+      };
     }
     const found = this.list?.channels.find((channel) => channel.id === id);
     return found ? { id, name: found.name, marker: found.marker, color: found.color } : null;
@@ -6981,7 +7226,10 @@ var ChannelsMode = class {
     this.setBanner(true, names);
     try {
       this.previewProjection = await this.host.api.channelPreview(this.host.eventKey, audience, {
-        includePublic: this.previewIncludePublic
+        // Naming Public sale as the audience IS asking for public inventory; the
+        // route filters the 'public' sentinel out of `channelIds`, so without
+        // this the request would resolve to an empty scope and 422.
+        includePublic: this.previewIncludePublic || audience.some(isPublicChannelId)
       });
       this.previewSupported = true;
     } catch (err) {
@@ -7152,11 +7400,8 @@ var ChannelsMode = class {
       <p class="slm-hint">${channel.access?.hasActiveGrants ? "Buyer access is live. Only this audience can buy from the allocation." : "No buyer access is configured yet. The allocation is protected \u2014 it is not available to Public sale."}</p>
       ${selfServiceGap ? `<div class="slm-ch-alert warn"><span>\u26A0</span>
         <span>This channel is marked for buyer self-service but no buyer has been let in yet.</span></div>` : ""}
-      <button type="button" class="slm-btn" data-ch-act="hosted-link" disabled
-        title="Hosted access links ship in the next milestone">Create hosted access link \xB7 Coming soon</button>
-      <div class="slm-ch-row2"><button type="button" class="slm-btn ghost" data-ch-act="server-access" disabled
-        title="Guided server setup ships in the next milestone">Configure server integration \xB7 Coming soon</button></div>
-      <p class="slm-note">Your own server can already mint buyer access sessions for this channel with the server SDK.</p>` : "";
+      ${this.hostedLinksHtml()}
+      ${SERVER_INTEGRATION_HTML}` : "";
     return `
       <p class="slm-eyebrow">
         <button type="button" class="slm-linkbtn" data-ch-act="back" style="text-align:left">\u2039 All channels</button>
@@ -7166,6 +7411,90 @@ var ChannelsMode = class {
       ${access}
       ${lifecycle}`;
   }
+  // ---- hosted access links --------------------------------------------------
+  /**
+   * Read the status projection for the open channel. Never paints — the caller
+   * decides when the rail repaints, so a poll-driven reload does not fight a
+   * user-driven one. A worker without M8 answers 404/405 and gets the honest
+   * "needs a newer server" line rather than an error toast.
+   */
+  async loadLinks(channelId) {
+    if (!this.caps.view) return;
+    if (this.linksChannelId !== channelId) {
+      this.links = [];
+      this.linksChannelId = channelId;
+      this.linksState = "loading";
+    }
+    try {
+      const res = await this.host.api.accessLinks(this.host.eventKey, channelId);
+      if (this.linksChannelId !== channelId) return;
+      this.links = res.links ?? [];
+      this.linksState = "ready";
+    } catch (err) {
+      if (this.linksChannelId !== channelId) return;
+      const status = err instanceof ManageApiError ? err.status : 0;
+      this.links = [];
+      this.linksState = status === 404 || status === 405 || status === 501 ? "unsupported" : "error";
+      if (this.linksState === "error") this.host.onError(err);
+    }
+  }
+  /**
+   * The hosted-link section of the detail panel.
+   *
+   * STATUS ONLY, by design (comp 06 `hosted`): label, state, expiry,
+   * redemptions, seats per buyer, live sessions. There is no Copy control here
+   * and no field to hang one on — the URL was shown once at creation and cannot
+   * be produced again. Rotation is the recovery path, and it says so.
+   */
+  hostedLinksHtml() {
+    const eyebrow = `<p class="slm-eyebrow" style="margin-top:18px">Hosted access links</p>`;
+    if (this.linksState === "unsupported") {
+      return `${eyebrow}<div class="slm-ch-alert warn"><span>\u2139</span>
+        <span><b>Hosted 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>
+        <button type="button" data-ch-act="link-reload">Try again</button></span></div>`;
+    }
+    const live = this.links.filter(accessLinkIsLive).length;
+    const cards = this.linksState === "loading" && !this.links.length ? `<div class="slm-empty">Loading links\u2026</div>` : this.links.length ? this.links.map((link) => this.linkCardHtml(link)).join("") : `<p class="slm-hint">No hosted link yet. Create one to send this allocation to a named group \u2014
+            they open the link and buy only these seats.</p>`;
+    const create = this.caps.manage ? `<button type="button" class="slm-btn" style="width:100%" data-ch-act="link-create">
+          ${live ? "Create another hosted link" : "Create hosted access link"}</button>` : "";
+    return `${eyebrow}
+      ${cards}
+      ${create}
+      <p class="slm-note">A link is shown once, when you create it. SeatLayer keeps only a fingerprint of it, so it
+        can never be shown again \u2014 if a link is lost, rotate it and send the fresh one.</p>`;
+  }
+  linkCardHtml(link) {
+    const badge = accessLinkBadge(link);
+    const used = link.maxRedemptions > 0 ? Math.min(100, Math.round(link.redemptions / link.maxRedemptions * 100)) : 0;
+    const rows = accessLinkPolicyLines(link).map((row) => `<div class="slm-ch-lkrow"><span class="k">${esc(row.k)}</span>
+        <span class="v">${esc(row.v)}</span></div>`).join("");
+    const sessions = link.activeSessions ? `<div class="slm-ch-lkrow"><span class="k">Buyers inside now</span>
+          <span class="v">${link.activeSessions.toLocaleString()}</span></div>` : "";
+    const lastUsed = link.lastRedeemedAt ? `<div class="slm-ch-lkrow"><span class="k">Last opened</span>
+          <span class="v">${esc(new Date(link.lastRedeemedAt).toLocaleString())}</span></div>` : "";
+    const actions = this.caps.manage && accessLinkIsLive(link) ? `<div class="slm-ch-row2">
+          <button type="button" class="slm-btn ghost" data-ch-rotate="${esc(link.id)}">Rotate</button>
+          <button type="button" class="slm-btn ghost" data-ch-revoke="${esc(link.id)}">Revoke</button>
+        </div>` : "";
+    return `<div class="slm-ch-link">
+      <span class="lk-head">
+        <span class="lk-name">${esc(link.label || "Hosted link")}</span>
+        <span class="slm-ch-badge ${badge.kind}">${esc(badge.text)}</span>
+      </span>
+      <div class="slm-ch-meter" role="img"
+        aria-label="${link.redemptions.toLocaleString()} of ${link.maxRedemptions.toLocaleString()} redemptions used">
+        <i style="width:${used}%"></i></div>
+      ${rows}${sessions}${lastUsed}
+      <div class="slm-ch-lkrow"><span class="k">The URL</span>
+        <span class="v">Revealed once at creation \u2014 not recoverable</span></div>
+      ${actions}
+    </div>`;
+  }
   previewRailHtml() {
     const audienceOptions = [
       { id: PUBLIC_CHANNEL_ID, name: this.list?.publicSale.name ?? PUBLIC_CHANNEL_NAME },
@@ -7182,7 +7511,7 @@ var ChannelsMode = class {
     const counts = this.previewProjection?.counts;
     const summary = counts?.eligible != null && this.previewProjection?.available !== false ? `<div class="slm-ch-alert warn"><span>\u2139</span><span>${counts.eligible.toLocaleString()} seats are buyable
           through this access.${this.previewProjection?.includePublic === false ? " Public sale seats are <b>not</b> included in this grant." : ""}</span></div>` : "";
-    const includePublic = current === PUBLIC_CHANNEL_ID ? "" : `
+    const includePublic = isPublicChannelId(current) ? "" : `
       <label class="slm-note" style="display:flex;gap:8px;align-items:center;margin:10px 0">
         <input type="checkbox" data-ch-includepublic ${this.previewIncludePublic ? "checked" : ""} />
         Also include Public sale seats in this grant
@@ -7214,10 +7543,26 @@ var ChannelsMode = class {
     });
     rail.querySelectorAll("[data-ch-detail]").forEach((button) => {
       button.addEventListener("click", () => {
-        this.detailChannelId = button.dataset.chDetail;
+        const channelId = button.dataset.chDetail;
+        this.detailChannelId = channelId;
         this.paintRail();
+        void this.loadLinks(channelId).then(() => this.paintRail());
       });
     });
+    rail.querySelectorAll("[data-ch-rotate]").forEach((button) => {
+      button.addEventListener("click", () => this.openDialog({
+        kind: "linkRotate",
+        channelId: this.detailChannelId,
+        linkId: button.dataset.chRotate
+      }));
+    });
+    rail.querySelectorAll("[data-ch-revoke]").forEach((button) => {
+      button.addEventListener("click", () => this.openDialog({
+        kind: "linkRevoke",
+        channelId: this.detailChannelId,
+        linkId: button.dataset.chRevoke
+      }));
+    });
     const target = rail.querySelector("[data-ch-target]");
     target?.addEventListener("change", () => {
       this.targetChannelId = target.value;
@@ -7269,8 +7614,17 @@ var ChannelsMode = class {
         break;
       case "back":
         this.detailChannelId = null;
+        this.linksChannelId = null;
+        this.links = [];
+        this.linksState = "idle";
         this.paintRail();
         break;
+      case "link-create":
+        this.openDialog({ kind: "linkCreate", channelId: this.detailChannelId });
+        break;
+      case "link-reload":
+        if (this.detailChannelId) void this.reloadLinks();
+        break;
       case "retry":
         void this.refresh();
         break;
@@ -7342,6 +7696,9 @@ 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 === "linkCreate") this.renderLinkCreateDialog(state);
+    else if (state.kind === "linkRotate") this.renderLinkRotateDialog(state);
+    else if (state.kind === "linkRevoke") this.renderLinkRevokeDialog(state);
   }
   /**
    * Mount a modal: `aria-modal` dialog, programmatic name, focus moved inside,
@@ -7394,7 +7751,7 @@ var ChannelsMode = class {
     this.lastFocus = null;
   }
   renderCreateDialog(state) {
-    const taken = (this.list?.channels ?? []).map((channel) => channel.marker ?? channel.name[0] ?? "");
+    const taken = (this.list?.channels ?? []).map((channel) => markerLetter(channel.marker || channel.name, ""));
     const suggestion = suggestMarker("", taken);
     this.renderScrim(`
       <h3 id="slm-ch-dlg-title">Create channel</h3>
@@ -7452,7 +7809,8 @@ var ChannelsMode = class {
     try {
       const res = await this.host.api.createChannel(this.host.eventKey, {
         name: trimmed,
-        marker: letter || null,
+        // The column is free text; we only ever store what the chip can draw.
+        marker: markerLetter(letter, "") || null,
         color: color || null,
         externalRef: externalRef.trim() || null
       });
@@ -7521,7 +7879,9 @@ var ChannelsMode = class {
     this.renderDialog();
     try {
       const result = await this.host.api.applyChannelAssignment(this.host.eventKey, {
-        targetChannelId: this.targetChannelId || null,
+        // `null` is the wire spelling of "back to public sale" every worker
+        // accepts, including ones that predate the 'public' sentinel.
+        targetChannelId: isPublicChannelId(this.targetChannelId) ? null : this.targetChannelId,
         labels,
         assignmentVersion: this.assignmentVersion
       });
@@ -7748,6 +8108,284 @@ var ChannelsMode = class {
       });
     });
   }
+  // ---- hosted-link dialogs --------------------------------------------------
+  async reloadLinks() {
+    const channelId = this.detailChannelId;
+    if (!channelId) return;
+    this.linksState = this.links.length ? this.linksState : "loading";
+    await this.loadLinks(channelId);
+    this.paintRail();
+  }
+  linkById(linkId) {
+    return this.links.find((link) => link.id === linkId) ?? null;
+  }
+  /**
+   * Create. The three policy fields carry the owner's defaults and every one of
+   * them is editable; the PLATFORM bounds (60s–180d, 1–10 000, 1–100, 20 live
+   * links) are the server's to enforce and the server's to explain, so this form
+   * checks only that a number is a number and surfaces the server's sentence for
+   * everything else.
+   */
+  renderLinkCreateDialog(state) {
+    const channel = this.list?.channels.find((item) => item.id === state.channelId);
+    if (!channel || !this.caps.manage) {
+      this.closeDialog();
+      return;
+    }
+    this.renderScrim(`
+      <h3 id="slm-ch-dlg-title">Create a hosted access link for ${esc(channel.name)}</h3>
+      <p class="sub">Anyone who opens the link can buy from this channel's allocation \u2014 and only from it.
+        You'll see the link once, right after you create it.</p>
+      <div class="slm-field">
+        <label for="slm-ch-lk-label">Label <span style="text-transform:none;font-weight:500">(optional)</span></label>
+        <input class="slm-input" id="slm-ch-lk-label" maxlength="80" placeholder="e.g. VIP list Nov 14" />
+        <p class="slm-note">So you can tell your links apart later. Buyers never see it.</p>
+      </div>
+      <div class="slm-field">
+        <label for="slm-ch-lk-expiry">Stops working</label>
+        <select class="slm-select" id="slm-ch-lk-expiry" data-ch-lk-expiry>
+          <option value="event" selected>When the event starts</option>
+          <option value="custom">On a date I choose</option>
+        </select>
+      </div>
+      <div class="slm-field" data-ch-lk-when-field hidden>
+        <label for="slm-ch-lk-when">Date and time</label>
+        <input class="slm-input" type="datetime-local" id="slm-ch-lk-when" />
+      </div>
+      <div class="slm-field">
+        <label for="slm-ch-lk-redemptions">How many people can use it</label>
+        <input class="slm-input" type="number" id="slm-ch-lk-redemptions" inputmode="numeric"
+          value="${ACCESS_LINK_DEFAULTS.maxRedemptions}" />
+        <p class="slm-note">Each buyer who opens the link uses one.</p>
+      </div>
+      <div class="slm-field">
+        <label for="slm-ch-lk-quantity">Seats per buyer</label>
+        <input class="slm-input" type="number" id="slm-ch-lk-quantity" inputmode="numeric"
+          value="${ACCESS_LINK_DEFAULTS.maxQuantity}" />
+      </div>
+      <label class="slm-note" style="display:flex;gap:8px;align-items:center;margin:2px 0 6px">
+        <input type="checkbox" id="slm-ch-lk-public" />
+        Also let this link buy Public sale seats
+      </label>
+      <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>Cancel</button>
+        <button type="button" class="slm-btn" data-ch-lk-create>Create link</button>
+      </div>`, (dialog) => {
+      const expiry = dialog.querySelector("[data-ch-lk-expiry]");
+      const whenField = dialog.querySelector("[data-ch-lk-when-field]");
+      const when = dialog.querySelector("#slm-ch-lk-when");
+      expiry.addEventListener("change", () => {
+        const custom = expiry.value === "custom";
+        whenField.hidden = !custom;
+        if (custom && !when.value) when.value = datetimeLocalValue(Date.now() + 7 * 864e5);
+      });
+      dialog.querySelector("[data-ch-lk-create]")?.addEventListener("click", () => {
+        const maxRedemptions = intField(dialog, "#slm-ch-lk-redemptions");
+        const maxQuantity = intField(dialog, "#slm-ch-lk-quantity");
+        if (maxRedemptions == null || maxQuantity == null) {
+          this.showDialogError("Those two settings need to be whole numbers.");
+          return;
+        }
+        let expiresAt;
+        if (expiry.value === "custom") {
+          expiresAt = Date.parse(when.value);
+          if (!Number.isFinite(expiresAt)) {
+            this.showDialogError("Pick the date and time the link should stop working.");
+            return;
+          }
+        }
+        void this.createLink(channel.id, {
+          label: dialog.querySelector("#slm-ch-lk-label")?.value.trim() || null,
+          includePublic: dialog.querySelector("#slm-ch-lk-public")?.checked ?? false,
+          ...expiresAt === void 0 ? {} : { expiresAt },
+          maxRedemptions,
+          maxQuantity
+        });
+      });
+    });
+  }
+  async createLink(channelId, input) {
+    try {
+      const reveal = await this.host.api.createAccessLink(this.host.eventKey, channelId, input);
+      this.revealLink(reveal, { channelId });
+      await this.refresh({ quiet: true });
+    } catch (err) {
+      this.showDialogError(accessLinkErrorCopy(err instanceof ManageApiError ? err : void 0));
+      if (!(err instanceof ManageApiError)) this.host.onError(err);
+    }
+  }
+  /**
+   * The ONE-TIME reveal.
+   *
+   * Three things make this unrecoverable rather than merely "not shown twice":
+   *
+   *   1. `url` is a local const. It is never assigned to a field on this class,
+   *      never handed to the host, never put in a `DialogState`.
+   *   2. `this.dialog` is cleared FIRST, so `renderDialog()` — the only function
+   *      that rebuilds a sheet — has nothing to rebuild this one from.
+   *   3. The string exists in exactly one DOM node inside the scrim. Dismissing
+   *      the dialog removes the scrim, and the closure goes with it.
+   *
+   * The server holds only a hash, so even a compromised client cannot ask for it
+   * again. Rotation is the recovery path, and the copy says so.
+   */
+  revealLink(reveal, opts) {
+    const url = reveal.url;
+    this.dialog = null;
+    const rotated = opts.rotated ? `<div class="slm-ch-alert warn" role="status"><span>\u26A0</span><span>
+          <b>The old link has stopped working.</b> ${reveal.endedSessions ? `${reveal.endedSessions.toLocaleString()} buyer${reveal.endedSessions === 1 ? "" : "s"} lost access immediately.` : "Buyers who already came in can finish; every new visit needs this link."}</span></div>` : "";
+    const policy = accessLinkPolicyLines(reveal.link).map((row) => `<div class="slm-ch-lkrow"><span class="k">${esc(row.k)}</span>
+        <span class="v">${esc(row.v)}</span></div>`).join("");
+    this.renderScrim(`
+      <h3 id="slm-ch-dlg-title">Copy this link now</h3>
+      <p class="sub">This is the only time SeatLayer can show it. We keep just a fingerprint, so it cannot be
+        shown again \u2014 if it is lost, rotate the link for a fresh one.</p>
+      ${rotated}
+      <div class="slm-ch-secret" data-ch-lk-url>${esc(url)}</div>
+      <div class="slm-ch-row2" style="margin-top:8px">
+        <button type="button" class="slm-btn" data-ch-lk-copy>Copy link</button>
+      </div>
+      <div class="slm-ch-alert warn" style="margin-top:12px"><span>\u26A0</span>
+        <span>Anyone who opens this link can buy from this allocation. Send it only to the people it is meant
+        for \u2014 forwarding it hands on the same access, and SeatLayer cannot tell the difference.</span></div>
+      <p class="slm-eyebrow" style="margin-top:14px">What this link allows</p>
+      ${policy}
+      <div class="foot">
+        <button type="button" class="slm-btn" data-ch-close data-ch-lk-done>I've copied it</button>
+      </div>`, (dialog) => {
+      const copy = dialog.querySelector("[data-ch-lk-copy]");
+      copy?.addEventListener("click", () => {
+        const ok = () => {
+          copy.textContent = "Copied";
+          this.announce("Hosted access link copied.");
+        };
+        const clipboard = typeof navigator === "undefined" ? null : navigator.clipboard;
+        if (clipboard?.writeText) {
+          clipboard.writeText(url).then(ok, () => selectSecret(dialog));
+          return;
+        }
+        selectSecret(dialog);
+      });
+      dialog.querySelector("[data-ch-lk-done]")?.addEventListener("click", () => {
+        void this.loadLinks(opts.channelId).then(() => this.paintRail());
+      });
+    });
+    this.announce("Your hosted access link is ready and is shown once.");
+  }
+  /**
+   * Rotate. The organizer must SAY what happens to the buyers already inside —
+   * the confirm stays disabled until one of the two choices is picked, because
+   * the gentle branch and the destructive branch are both real decisions and the
+   * server refuses (422 `end_active_sessions_required`) to guess either.
+   */
+  renderLinkRotateDialog(state) {
+    const link = this.linkById(state.linkId);
+    if (!link || !this.caps.manage) {
+      this.closeDialog();
+      return;
+    }
+    const sessions = link.activeSessions ?? 0;
+    const warning = sessions ? `<div class="slm-ch-alert warn"><span>\u26A0</span>
+          <span><b>${sessions.toLocaleString()} buyer${sessions === 1 ? "" : "s"}</b> got in with the current link
+          and still ${sessions === 1 ? "has" : "have"} active access.</span></div>` : "";
+    this.renderScrim(`
+      <h3 id="slm-ch-dlg-title">Rotate the ${esc(link.label || "hosted")} link?</h3>
+      <p class="sub">The current link stops opening immediately and cannot be restored. You will get a new
+        link to copy \u2014 shown once.</p>
+      ${warning}
+      <label class="slm-ch-radio">
+        <input type="radio" name="slm-ch-rot" value="keep" data-ch-rot />
+        <span><b>Let them finish</b><span class="why">Access already handed out expires on its own; seats in
+          checkout are untouched. Every new visit needs the new link.</span></span>
+      </label>
+      <label class="slm-ch-radio">
+        <input type="radio" name="slm-ch-rot" value="end" data-ch-rot />
+        <span><b>End their access now</b><span class="why">All access from the old link ends immediately.
+          Buyers part-way through choosing seats lose access.</span></span>
+      </label>
+      <p class="slm-note">Choose one \u2014 SeatLayer will not decide this for you.</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>Cancel</button>
+        <button type="button" class="slm-btn" data-ch-lk-rotate disabled>Rotate and copy new link</button>
+      </div>`, (dialog) => {
+      const confirm = dialog.querySelector("[data-ch-lk-rotate]");
+      dialog.querySelectorAll("[data-ch-rot]").forEach((radio) => {
+        radio.addEventListener("change", () => {
+          confirm.disabled = false;
+        });
+      });
+      confirm.addEventListener("click", () => {
+        const picked = [...dialog.querySelectorAll("[data-ch-rot]")].find((radio) => radio.checked);
+        if (!picked) {
+          this.showDialogError(accessLinkErrorCopy({ code: "end_active_sessions_required" }));
+          return;
+        }
+        void this.rotateLink(state.channelId, link.id, picked.value === "end");
+      });
+    });
+  }
+  async rotateLink(channelId, linkId, endActiveSessions) {
+    try {
+      const reveal = await this.host.api.rotateAccessLink(
+        this.host.eventKey,
+        channelId,
+        linkId,
+        endActiveSessions
+      );
+      this.revealLink(reveal, { channelId, rotated: true });
+    } catch (err) {
+      this.showDialogError(accessLinkErrorCopy(err instanceof ManageApiError ? err : void 0));
+      if (!(err instanceof ManageApiError)) this.host.onError(err);
+    }
+  }
+  renderLinkRevokeDialog(state) {
+    const link = this.linkById(state.linkId);
+    if (!link || !this.caps.manage) {
+      this.closeDialog();
+      return;
+    }
+    const sessions = link.activeSessions ?? 0;
+    this.renderScrim(`
+      <h3 id="slm-ch-dlg-title">Revoke the ${esc(link.label || "hosted")} link?</h3>
+      <p class="sub">It stops opening immediately and cannot be restored \u2014 there is no undo, and no way to
+        bring the same URL back. Seats already bought through it keep their sale.</p>
+      ${sessions ? `<label class="slm-ch-radio">
+        <input type="checkbox" data-ch-lk-endsessions />
+        <span><b>Also end access for the ${sessions.toLocaleString()}
+          buyer${sessions === 1 ? "" : "s"} already inside</b><span class="why">Leave this off and they can
+          finish what they started; new visits are refused either way.</span></span>
+      </label>` : ""}
+      <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>Cancel</button>
+        <button type="button" class="slm-btn danger" data-ch-lk-revoke>Revoke link</button>
+      </div>`, (dialog) => {
+      dialog.querySelector("[data-ch-lk-revoke]")?.addEventListener("click", () => {
+        const end = dialog.querySelector("[data-ch-lk-endsessions]")?.checked ?? false;
+        void this.revokeLink(state.channelId, link.id, end);
+      });
+    });
+  }
+  async revokeLink(channelId, linkId, endActiveSessions) {
+    try {
+      const res = await this.host.api.revokeAccessLink(
+        this.host.eventKey,
+        channelId,
+        linkId,
+        endActiveSessions
+      );
+      this.closeDialog();
+      await this.loadLinks(channelId);
+      await this.refresh({ quiet: true });
+      this.paintRail();
+      this.host.toast(res.endedSessions ? `Link revoked. ${res.endedSessions.toLocaleString()} buyer${res.endedSessions === 1 ? "" : "s"} lost access.` : "Link revoked. It no longer opens for anyone.", "ok");
+    } catch (err) {
+      this.showDialogError(accessLinkErrorCopy(err instanceof ManageApiError ? err : void 0));
+      if (!(err instanceof ManageApiError)) this.host.onError(err);
+    }
+  }
   // ---- compact detents ------------------------------------------------------
   applySheetClasses() {
     const root = this.host.root;
@@ -8199,7 +8837,7 @@ var SeatManager = class {
       if (controlRoom?.activity) this.seedFeed(controlRoom.activity);
       else this.api.log(this.key, { limit: 24 }).then((page) => this.seedFeed(page.entries)).catch(() => {
       });
-      this.connect();
+      void this.connect();
       this.startFeedClock();
       this.ready = true;
       await this.resolveChannelCapabilities();
@@ -8623,11 +9261,33 @@ var SeatManager = class {
     });
   }
   // ---- realtime -------------------------------------------------------------
-  connect() {
+  /**
+   * Open the cockpit's realtime socket AS THE ORGANIZER.
+   *
+   * The scope has to be established before the upgrade, because a browser
+   * `WebSocket` cannot send an Authorization header: the manage token is traded
+   * over HTTPS for a one-use ticket which rides in `Sec-WebSocket-Protocol`.
+   * Without it the server treats this socket as an anonymous public buyer and
+   * projects its deltas, so any change inside a private channel allocation is
+   * structurally suppressed and the map silently drifts.
+   *
+   * If the mint fails (an expired token, a worker that predates the route) we
+   * still connect unticketed rather than going dark — the public-sale stream is
+   * worth having, and every `resnapshot()` re-establishes physical truth from
+   * the authenticated HTTP read.
+   */
+  async connect() {
+    if (this.closed) return;
+    let protocols;
+    try {
+      protocols = (await this.api.subscribeTicket(this.key)).protocols;
+    } catch {
+      protocols = void 0;
+    }
     if (this.closed) return;
     let ws;
     try {
-      ws = new WebSocket(this.api.socketUrl(this.key));
+      ws = protocols ? new WebSocket(this.api.socketUrl(this.key), protocols) : new WebSocket(this.api.socketUrl(this.key));
     } catch {
       this.scheduleReconnect();
       return;
@@ -8657,7 +9317,7 @@ var SeatManager = class {
     const delay = Math.min(1e3 * 2 ** Math.min(this.attempt++, 5), 15e3);
     this.reconnectTimer = setTimeout(() => {
       this.reconnectTimer = null;
-      this.connect();
+      void this.connect();
     }, delay);
   }
   onMessage(e) {
@@ -8687,7 +9347,7 @@ var SeatManager = class {
     }
     if (m.type === "hidden") return;
     if (m.seats && typeof m.seats === "object") {
-      this.applySnapshot(m.seats);
+      this.applySnapshot(m.seats, typeof m.default === "string" ? m.default : void 0);
     } else if (Array.isArray(m.changes)) {
       const ids = [];
       const groups = /* @__PURE__ */ new Map();
@@ -8727,10 +9387,23 @@ var SeatManager = class {
     } catch {
     }
   }
-  applySnapshot(seats) {
+  /**
+   * Replace the whole seat model.
+   *
+   * `fallback` is the compact frame's modal status: those snapshots list only
+   * the seats that DIFFER from it, so every other known label takes it. Without
+   * this the omitted majority would silently fall back to `free` — fine when
+   * the mode really is free, wrong the moment it is not.
+   */
+  applySnapshot(seats, fallback) {
+    const known = (st) => ["free", "held", "booked", "blocked"].includes(st) ? st : "free";
     const next = /* @__PURE__ */ new Map();
+    if (fallback !== void 0) {
+      const base = known(fallback);
+      for (const label of this.labelToId.keys()) next.set(label, base);
+    }
     for (const [label, st] of Object.entries(seats)) {
-      next.set(label, ["free", "held", "booked", "blocked"].includes(st) ? st : "free");
+      next.set(label, known(st));
     }
     this.status = next;
     this.lastSyncedAt = Date.now();
@@ -9930,6 +10603,7 @@ var SeatManager = class {
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  ACCESS_LINK_DEFAULTS,
   ApiError,
   BuyerAccessContext,
   BuyerAccessUnavailableError,
@@ -9945,12 +10619,18 @@ var SeatManager = class {
   SeatingChart,
   accessIntentLabel,
   accessLine,
+  accessLinkBadge,
+  accessLinkErrorCopy,
+  accessLinkIsLive,
+  accessLinkPolicyLines,
   attachPickerFrame,
   bucketRows,
   bucketRowsHtml,
   createBuyerAccessContext,
   createControllerSink,
   dropReviewRows,
+  isPublicChannelId,
+  markerLetter,
   markerOf,
   mutationCount,
   needsMoveConfirmation,