@seatlayer/js 0.67.15 → 0.68.0

package/README.md

@@ -68,6 +68,7 @@ import { SeatingChart } from '@seatlayer/js';
 const chart = new SeatingChart({
   container: '#chart',
   event: 'ev_9f3a',
+  publicKey: 'pk_test_…',
   onHold: ({ holdId }) => bookOnYourServer(holdId),
 });
 
@@ -77,6 +78,15 @@ const hold = await chart.hold();          // null on a 409 conflict
 chart.destroy();
 ```
 
+For an ordinary Public sale on a Platform/SDK event, `publicKey` starts one
+direct bootstrap after SeatLayer validates the key, event mode, and browser's
+exact registered origin. The SDK keeps the returned Public-only bearer in
+memory, and the bootstrap carries the chart plus compact inventory status
+together. Login, presale, partner, and channel inventory instead use
+`buyerAccessTokenProvider` or `buyerAccessToken` from your authenticated
+backend; either explicit credential takes precedence over `publicKey`. Managed
+public/unlisted events retain anonymous event-key access and omit `publicKey`.
+
 ## Fixed Renewable Season (private-beta candidate)
 
 The Season source is merged for development, but it is not included in the
@@ -223,13 +233,28 @@ callers must use an event-scoped `mse_` grant.
 
 ## Embed the chart Designer
 
-For organizer-facing venue design, use `EmbeddedDesigner`. Your backend mints the
-short-lived `designerUrl`; the browser receives no SeatLayer secret key. The wrapper
-creates the iframe, recreates it for a new session URL, and validates every
-`postMessage` by iframe source and exact Designer origin.
+For organizer-facing venue design, use `EmbeddedDesigner`. Your backend
+authenticates and authorizes the organizer, then requests a short-lived session
+from SeatLayer with `sk_…`; SeatLayer mints the `dse_…` token and returns
+`designerUrl`. Never expose the secret or call SeatLayer's Designer-session
+endpoint from browser code. The wrapper creates the iframe, recreates it for a
+new session URL, and validates every `postMessage` by iframe source and exact
+Designer origin.
+
+Start that required backend request on authenticated route intent or page load,
+not on the final **Open Designer** click. Keep the response no-store and the
+session in memory, and race its promise with the SDK import and editor shell.
+An authenticated server-rendered page may instead include `designerUrl` in a
+no-store bootstrap. The iframe still waits for the session; the win comes from
+overlapping the trusted request with SDK and shell loading.
 
 ```js
-import { EmbeddedDesigner } from '@seatlayer/js';
+const sdkPromise = import('@seatlayer/js');
+const sessionPromise = requestDesignerSession(); // authenticated + no-store
+const [{ EmbeddedDesigner }, session] = await Promise.all([
+  sdkPromise,
+  sessionPromise,
+]);
 
 const designer = new EmbeddedDesigner({
   container: '#venue-designer',
@@ -239,9 +264,9 @@ const designer = new EmbeddedDesigner({
   onPublished: ({ chartId }) => refreshVenue(chartId),
   onClose: () => closeVenueEditor(),
   onError: ({ code, message }) => showError(code ?? message),
-  // Mint a fresh session when the user retries an expired/failed editor:
+  // Request a fresh session through your backend on retry/expiry:
   onRequestRelaunch: async () => {
-    const next = await mintDesignerSession(session.chartId);
+    const next = await requestDesignerSession(session.chartId);
     designer.setDesignerUrl(next.designerUrl);
   },
 });
@@ -280,7 +305,7 @@ CSS files or external assets.
 | --- | --- | --- | --- |
 | `showLoadingState` | `boolean` | `true` | Render the built-in skeleton and error card. Set `false` when you draw your own chrome. |
 | `loadingTimeoutMs` | `number` | `20000` | If `ready` never arrives within this window, show the error card with a timeout message. |
-| `onRequestRelaunch` | `() => void` | — | Called by **"Try again"** _and_ by automatic renewal (below). Mint a fresh session and call `setDesignerUrl()`; the iframe recreates and returns to loading. When omitted, "Try again" reloads the current URL in place. |
+| `onRequestRelaunch` | `() => void` | — | Called by **"Try again"** _and_ by automatic renewal (below). Request a fresh session through your backend and call `setDesignerUrl()`; the iframe recreates and returns to loading. When omitted, "Try again" reloads the current URL in place. |
 | `autoRenewSession` | `boolean` | `true`¹ | Silently renew the session before it expires and auto-recover once if an expiry error slips through. ¹Defaults `true` only when `onRequestRelaunch` is provided; a no-op without it. Set `false` for fully manual "Try again". |
 
 `setDesignerUrl()` always returns the host to the loading state, so a relaunch
@@ -288,20 +313,21 @@ flow needs no extra bookkeeping.
 
 ### Session lifecycle
 
-Designer sessions are **short-lived by design**: your backend mints a `dse_`
-token (default 1 hour, up to 4 hours via `expiresInSeconds`) and bakes it into
-`designerUrl`. Pick a TTL that fits how long organizers actually edit — longer is
-not automatically better; the renewal below keeps even a multi-hour session alive.
+Designer sessions are **short-lived by design**: your backend authorizes and
+requests one, then SeatLayer mints a `dse_` token (default 1 hour, up to 4 hours
+via `expiresInSeconds`) into `designerUrl`. Pick a TTL that fits how long
+organizers actually edit — longer is not automatically better; the renewal
+below keeps even a multi-hour session alive.
 
-Provide `onRequestRelaunch` returning (or awaiting) a freshly minted session, and
-the SDK turns expiry into a non-event:
+Provide `onRequestRelaunch` returning (or awaiting) a freshly requested session,
+and the SDK turns expiry into a non-event:
 
 - **Silent proactive renewal.** From each `ready` message's `expiresAt` the SDK
   schedules an automatic relaunch shortly before the session lapses — ~3 minutes
   ahead, or, for a TTL under 15 minutes, after 80% of the remaining life (never
-  sooner than 30s after `ready`). Your `onRequestRelaunch` mints a fresh session
-  and swaps `designerUrl`, so editing continues with no expiry card. The timer
-  re-arms from every `ready`.
+  sooner than 30s after `ready`). Your `onRequestRelaunch` requests a fresh
+  session through your backend and swaps `designerUrl`, so editing continues
+  with no expiry card. The timer re-arms from every `ready`.
 - **Automatic expiry recovery.** If an expiry error still arrives (a laptop that
   slept past the renewal window, say), the SDK makes **one** automatic relaunch
   attempt before showing the "Try again" card, and only falls back to the card if
@@ -315,9 +341,9 @@ const designer = new EmbeddedDesigner({
   container: '#venue-designer',
   designerUrl: session.designerUrl,
   expectedChartId: session.chartId,
-  // Mint a fresh session on renewal, expiry recovery, or "Try again":
+  // Request a fresh session on renewal, expiry recovery, or "Try again":
   onRequestRelaunch: async () => {
-    const next = await mintDesignerSession(session.chartId); // your backend, up to 4h TTL
+    const next = await requestDesignerSession(session.chartId); // your backend, up to 4h TTL
     designer.setDesignerUrl(next.designerUrl);               // recreates the iframe
   },
   // autoRenewSession defaults to true because onRequestRelaunch is present.
@@ -328,7 +354,8 @@ designer.mount();
 ## API
 
 `new SeatingChart(options)` — options: `container` (selector or element, required),
-`event` (key, required), `apiBase?`, `maxSelection?` (default 10),
+`event` (key, required), `apiBase?`, `publicKey?`,
+`buyerAccessTokenProvider?`, `buyerAccessToken?`, `maxSelection?` (default 10),
 `selectedObjects?`, `selectableObjects?`, `numberOfPlacesToSelect?`,
 `selectionValidators?`,
 `onSelectionChange?`, `onSelectionValidityChange?`, `onHold?`,