@fanvue/builder-sdk 0.4.0 → 0.5.0

package/README.md

@@ -348,6 +348,139 @@ const session = await verifySessionJwt("your-session-secret", jwt);
 
 </details>
 
+## Observability and Machine Auth
+
+Privacy-first logging, Sentry scrubbing, machine (cron/queue) authentication, and a
+configuration readiness probe. All exported from the root entrypoint and dependency-free.
+
+### Safe structured logging
+
+`createSafeLogFields` returns an allowlisting filter: unknown keys are dropped, only
+`string | number | boolean | null` survives (an `Error` or a response body is never
+serialised), UUID-bearing strings become `[redacted-uuid]` — **any** UUID version,
+including v7 — and email-bearing strings become `[redacted-email]`.
+
+```ts
+import { createLogEvent, createSafeLogFields, errorName } from "@fanvue/builder-sdk";
+
+const safeLogFields = createSafeLogFields(["wheelId"]); // base keys + your own
+const logEvent = createLogEvent({ prefix: "[spinwheel]", safeLogFields });
+
+logEvent("error", "exchange.failed", {
+  wheelId: "wheel_1",
+  httpStatus: 503,
+  errorName: errorName(caught), // class name only, never err.message
+  accessToken: "dropped",       // not allowlisted
+});
+// [spinwheel] { event: 'exchange.failed', wheelId: 'wheel_1', httpStatus: 503, errorName: 'TypeError' }
+```
+
+Base allowlist (`BASE_ALLOWED_LOG_KEYS`): `cause`, `code`, `creatorId`, `errorName`,
+`httpStatus`, `reason`, `retryCount`, `status`.
+
+### Sentry scrubbing
+
+```ts
+// sentry.server.config.ts
+import { createSentryScrubber } from "@fanvue/builder-sdk";
+
+Sentry.init({
+  dsn,
+  enabled: Boolean(dsn),
+  beforeSend: createSentryScrubber(/(prizedetail|fanhmac|seed)/i), // merged with the base pattern
+});
+```
+
+Recursive, and applies four rules to every node: values under a sensitive key become
+`[redacted]`, UUIDs inside strings become `[redacted-uuid]` (any version, and also when the UUID
+sits behind a `_` or another word character), a string that parses as a URL keeps its origin
+and path but loses its query string, fragment and `user:pass@` userinfo
+(`https://cdn/x?[redacted]`), and email addresses inside strings become `[redacted-email]`.
+Base sensitive keys (`BASE_SENSITIVE_KEY_PATTERN`), matched as case-insensitive substrings:
+`authorization|cookie|token|secret|password|signedurl|api[-_]?key|credential|email|phone|ip[-_]?address`.
+
+Total by construction, because a `beforeSend` that throws loses the event and raises inside the
+caller: a repeat visit yields `[circular]`, a node deeper than 32 levels yields `[max-depth]`,
+and a property whose getter throws yields `[unreadable]`. All three fail closed — an untraversed
+value cannot leak.
+
+### Machine auth (cron and queue routes)
+
+`requireMachineAuth` returns `authorized | unauthorized | not_configured`. The third arm exists
+so a deployment with no usable credential answers 503, never 401 — a broken deploy must not look
+like ordinary auth noise. Bearer secrets must be at least 32 characters (`MINIMUM_BEARER_SECRET_LENGTH`);
+a shorter one is treated as absent rather than compared. Comparison is constant-time over the
+UTF-8 bytes, with a byte-length pre-check. The `Authorization` scheme is required but matched
+case-insensitively (`bearer` and `Bearer` both work, a bare secret does not).
+
+```ts
+// app/api/cron/reconcile/route.ts
+import { boundedBatchSize, requireMachineAuth } from "@fanvue/builder-sdk";
+
+export async function POST(request: Request): Promise<Response> {
+  const auth = await requireMachineAuth(request, {
+    bearerSecret: process.env.CRON_SECRET ?? null,
+    signedRequestVerifier: null,
+    rawBody: null,
+  });
+  if (auth.status === "not_configured") return new Response(null, { status: 503 });
+  if (auth.status === "unauthorized") return new Response(null, { status: 401 });
+
+  const limit = boundedBatchSize(new URL(request.url).searchParams.get("limit"), 20, 100);
+  // ...
+}
+```
+
+A second strategy plugs in via `SignedRequestVerifier`. `@upstash/qstash` is deliberately **not**
+a dependency of this package — the app owns it:
+
+```ts
+import { Receiver } from "@upstash/qstash";
+import type { SignedRequestVerifier } from "@fanvue/builder-sdk";
+
+const qstashVerifier: SignedRequestVerifier = {
+  verify: async (request, rawBody) => {
+    const signature = request.headers.get("upstash-signature");
+    const currentSigningKey = process.env.QSTASH_CURRENT_SIGNING_KEY;
+    const nextSigningKey = process.env.QSTASH_NEXT_SIGNING_KEY;
+    if (!signature || !currentSigningKey || !nextSigningKey) return false; // deny by default
+    return new Receiver({ currentSigningKey, nextSigningKey }).verify({
+      signature,
+      body: new TextDecoder().decode(rawBody),
+      url: request.url,
+      upstashRegion: request.headers.get("upstash-region") ?? undefined,
+    });
+  },
+};
+
+// Pass the exact received bytes — a reparsed body invalidates the signature.
+const rawBody = new Uint8Array(await request.arrayBuffer());
+const auth = await requireMachineAuth(request, {
+  bearerSecret: process.env.CRON_SECRET ?? null,
+  signedRequestVerifier: qstashVerifier,
+  rawBody,
+});
+```
+
+### Configuration readiness
+
+```ts
+import { configurationReadiness } from "@fanvue/builder-sdk";
+
+export function GET(): Response {
+  const checks = configurationReadiness(); // env is a parameter; defaults to process.env
+  const ready = checks.every((check) => check.ready);
+  return Response.json({ ready, checks }, { status: ready ? 200 : 503 });
+}
+// [{ name: 'app_url', ready: false, detail: 'set FANVUE_APP_BASE_URL to an https:// origin' },
+//  { name: 'fanvue_oauth', ready: true, detail: null }]
+```
+
+`app_url` reads `FANVUE_APP_BASE_URL` (falling back to `APP_BASE_URL`) and requires an https
+origin, because Fanvue refuses to embed anything else. `fanvue_oauth` requires `FANVUE_APP_UUID`,
+`FANVUE_CLIENT_ID`, `FANVUE_CLIENT_SECRET` and `FANVUE_OAUTH_REDIRECT_URI`; details name the
+missing variables and never echo a value.
+
 ## Environment Variables
 
 Add these to your `.env.local` (Next.js) or equivalent:
@@ -381,6 +514,128 @@ const config = createConfig({
 });
 ```
 
+## Platform Contracts
+
+Wire shapes, enums and environment validation shared by every Fanvue app, exported from the root entrypoint (`@fanvue/builder-sdk`). Everything here is runtime-agnostic — safe in a route handler, a worker, or the browser.
+
+### `FANVUE_*` environment
+
+```env
+FANVUE_APP_UUID=                                   # your app's UUID on Fanvue
+FANVUE_CLIENT_ID=
+FANVUE_CLIENT_SECRET=
+FANVUE_OAUTH_REDIRECT_URI=
+FANVUE_API_BASE_URL=https://api.fanvue.com         # optional, shown with defaults
+FANVUE_AUTH_BASE_URL=https://auth.fanvue.com
+FANVUE_WEB_ORIGIN=https://www.fanvue.com
+FANVUE_API_VERSION=2025-06-26
+FANVUE_EXPERIENCE_URL_TEMPLATE=                    # optional share-link override
+```
+
+```ts
+import { fanvueEnv, isFanvueConfigured, flagEnabled } from "@fanvue/builder-sdk";
+
+// Parsed on first call and cached; a build never needs the secrets present.
+const apiBaseUrl = fanvueEnv().FANVUE_API_BASE_URL;
+
+// The four credentials default to "" so builds pass — check before an OAuth call.
+if (!isFanvueConfigured()) {
+  return Response.json(
+    { error: { code: "fanvue_not_configured", message: "Fanvue is not configured." } },
+    { status: 503 },
+  );
+}
+
+// Case- and whitespace-insensitive flag reader; warns once on an unreadable value.
+const devMode = flagEnabled("MY_APP_DEV_MODE");
+```
+
+Call `resetFanvueEnvCache()` between tests that mutate `process.env`.
+
+### Experience postMessage protocol
+
+```ts
+import {
+  PUBLISH_REQUEST_MESSAGE,
+  isPublishResultMessage,
+  isFanvueOrigin,
+} from "@fanvue/builder-sdk";
+
+window.parent.postMessage({ type: PUBLISH_REQUEST_MESSAGE, token }, platformOrigin);
+
+window.addEventListener("message", (event) => {
+  // Validate the origin as well as the shape: Fanvue replies with targetOrigin "*".
+  if (!isFanvueOrigin(event.origin) || !isPublishResultMessage(event.data)) return;
+  if (event.data.status === "published") onPublished(event.data.experienceId);
+});
+```
+
+### Access modes and denial reasons
+
+```ts
+import { accessModeFromDenialReason } from "@fanvue/builder-sdk";
+
+// The exchange fails closed: a denied fan gets a reason but no access mode.
+const accessMode = accessModeFromDenialReason(reason); // 'SUBSCRIPTION' | 'PAID' | 'HIDDEN' | null
+```
+
+### Error bodies
+
+```ts
+import {
+  AppErrorEnvelopeSchema,
+  NON_SESSION_401_CODES,
+  parseFanvueErrorBody,
+} from "@fanvue/builder-sdk";
+
+// Normalises all four Fanvue API error-body shapes, preserving `reason`.
+// `reason` is what separates an entitlement refusal from an app-binding mismatch.
+const { message, reason, code } = parseFanvueErrorBody(await fanvueResponse.json());
+
+// Client side, against your own app's `{ error: { code, message } }` envelope:
+// a 401 with one of these codes means the Fanvue grant is gone, not the app
+// session, so prompt a reconnect instead of signing the creator out.
+const parsed = AppErrorEnvelopeSchema.safeParse(await appResponse.json());
+const appCode = parsed.success ? parsed.data.error.code : null;
+if (appResponse.status === 401 && (appCode === null || !NON_SESSION_401_CODES.has(appCode))) {
+  onSessionExpired();
+}
+```
+
+### Pagination
+
+```ts
+import { cursorPageSchema, offsetPageSchema, clampPageSize } from "@fanvue/builder-sdk";
+
+const SubscribersPage = offsetPageSchema(SubscriberSchema); // { data, pagination }
+const PaymentsPage = cursorPageSchema(PaymentSchema); // { data, nextCursor }
+const size = clampPageSize(requested); // the API 400s above 50
+```
+
+### Contracts API reference
+
+| Export | Description |
+|---|---|
+| `FanvueEnvSchema`, `parseFanvueEnv(source)` | Zod schema and pure parser for the `FANVUE_*` contract |
+| `fanvueEnv()`, `resetFanvueEnvCache()` | Lazily parsed, cached `process.env` view, and the test reset |
+| `isFanvueConfigured(env?)` | Whether the four Fanvue credentials are all set |
+| `flagEnabled(name, source?)` | Boolean env-flag reader; trims, lowercases, warns once per flag |
+| `PUBLISH_REQUEST_MESSAGE`, `PUBLISH_RESULT_MESSAGE`, `UNPUBLISH_REQUEST_MESSAGE`, `UNPUBLISH_RESULT_MESSAGE`, `EXPERIENCE_MESSAGE_TYPES` | `fanvue:experience:*` message types |
+| `PublishRequestMessageSchema`, `PublishResultMessageSchema`, `UnpublishRequestMessageSchema`, `UnpublishResultMessageSchema`, `ExperienceMessageSchema` | Zod schemas for the four messages and their discriminated union |
+| `isPublishResultMessage(v)`, `isUnpublishResultMessage(v)` | `safeParse`-backed type guards |
+| `isFanvueOrigin(origin)` | `https` + `fanvue.com` / `*.fanvue.com` origin check |
+| `FANVUE_ACCESS_MODES`, `FanvueAccessModeSchema` | `FREE \| SUBSCRIPTION \| PAID \| HIDDEN` |
+| `EXPERIENCE_DENIAL_REASONS`, `EXPERIENCE_ENTITLED_REASONS` | Every reason the platform reports, documented |
+| `accessModeFromDenialReason(reason)` | Recovers the access mode a denial implies, or `null` |
+| `MAX_PAGE_SIZE`, `DEFAULT_PAGE_SIZE`, `clampPageSize(n)` | Offset page-size limits (50 / 15) and client-side clamping |
+| `OffsetPaginationSchema`, `HybridPaginationSchema` | `{ page, size, hasMore }` and the `v0` subscribers variant |
+| `offsetPageSchema(item)`, `cursorPageSchema(item)` | List-response schema builders |
+| `parseFanvueErrorBody(body)` | Normalises any Fanvue error body to `{ message, reason, code }` |
+| `FanvueErrorBodySchema` (+ the four per-shape schemas) | Zod schemas for the platform's error bodies |
+| `AppErrorEnvelopeSchema` | The app's own `{ error: { code, message } }` envelope |
+| `FANVUE_APP_ERROR_CODES`, `NON_SESSION_401_CODES` | Canonical app-facing codes and the two grant-loss 401s |
+| `OAuthErrorBodySchema` | OAuth error body, normalised to `{ error, errorDescription }` |
+
 ## Error Handling
 
 All async operations return `Result<T, E>` types from [`neverthrow`](https://github.com/supermacro/neverthrow) instead of throwing exceptions. This gives you type-safe, explicit error handling:
@@ -402,6 +657,16 @@ result
 
 Error types: `OAuthError` (token exchange/refresh), `EmbeddedAuthError` (delegated authorize-on-behalf), `ApiError` (API requests), `SessionVerifyError` (JWT verification).
 
+`TOKEN_EXCHANGE_FAILED` and `TOKEN_REFRESH_FAILED` carry the authorization server's own body as `oauthError: { error, errorDescription } | null` — the only way to tell a retired refresh token from bad client credentials, since both are `400`:
+
+```ts
+if (error.code === "TOKEN_REFRESH_FAILED" && error.oauthError?.error === "invalid_grant") {
+  // The stored grant is dead: prompt the creator to reconnect.
+}
+```
+
+Treat it as a diagnostic, never as end-user copy.
+
 ## API Reference
 
 ### Core (`@fanvue/builder-sdk`)
@@ -420,6 +685,17 @@ Error types: `OAuthError` (token exchange/refresh), `EmbeddedAuthError` (delegat
 | `createFanvueClient(accessToken, apiBaseUrl?)` | Create an authenticated API client. |
 | `API_VERSION` | The API version header value (currently `2025-06-26`). |
 | `HEADER_UPDATED_SESSION` | Response header (`X-Updated-Session`) carrying a refreshed session JWT. |
+| `createSafeLogFields(extraAllowedKeys?)` | Build an allowlisting log-field filter. Drops unknown keys and non-scalars; redacts UUID-shaped values. |
+| `createLogEvent(options?)` | Build a structured `logEvent(level, event, fields)` over an allowlist. |
+| `logEvent(level, event, fields?)` | Ready-made structured logger over the base allowlist, prefixed `[fanvue]`. |
+| `errorName(error)` | The `Error` class name (or `typeof`) of a caught value — never its message. |
+| `createSentryScrubber(extraSensitiveKeyPattern?)` | Build a recursive `beforeSend` scrubber for Sentry. |
+| `requireMachineAuth(request, options)` | Authenticate a cron/queue request. Returns `authorized \| unauthorized \| not_configured`. |
+| `boundedBatchSize(requested, defaultSize, max)` | Clamp a caller-supplied batch size to a safe positive bound. |
+| `configurationReadiness(env?)` | Named `app_url` / `fanvue_oauth` configuration checks for a readiness probe. |
+| `BASE_ALLOWED_LOG_KEYS` | The generic log keys every app shares. |
+| `BASE_SENSITIVE_KEY_PATTERN` | Key-name fragments whose values never reach an error tracker. |
+| `MINIMUM_BEARER_SECRET_LENGTH` | Shortest machine-auth bearer secret the SDK will compare (32). |
 
 #### Types
 
@@ -435,6 +711,13 @@ Error types: `OAuthError` (token exchange/refresh), `EmbeddedAuthError` (delegat
 | `EmbeddedAuthError` | Error from the delegated authorize-on-behalf flow |
 | `ApiError` | Error from API requests |
 | `SessionVerifyError` | Error from session JWT verification |
+| `SafeLogFields` / `SafeLogValue` | The allowlisting filter, and the scalar types that survive it |
+| `LogEvent` / `LogEventOptions` / `LogLevel` / `LogSink` | Structured-logging shapes |
+| `SentryScrubber` | A `beforeSend`-compatible scrubber: `<T>(event: T) => T` |
+| `MachineAuthResult` | `{ status: 'authorized' \| 'unauthorized' \| 'not_configured' }` |
+| `MachineAuthOptions` | Bearer secret, signed-request verifier, and raw body |
+| `SignedRequestVerifier` | Pluggable signed-request strategy (e.g. QStash), implemented by the app |
+| `ReadinessCheck` / `ReadinessEnv` | `{ name, ready, detail }` and the environment shape checks read |
 
 ### Next.js Embedded App (`@fanvue/builder-sdk/nextjs/embedded-app`)
 
@@ -451,6 +734,7 @@ Error types: `OAuthError` (token exchange/refresh), `EmbeddedAuthError` (delegat
 | Export | Description |
 |---|---|
 | `createConfig(opts?)` | Build a `ResolvedConfig` from env vars and/or explicit options |
+| `createConfigSafe(opts?)` | Non-throwing variant: `{ ok: true, config }` or `{ ok: false, missing }` |
 | `createLoginHandler(opts)` | `{ GET }` -- redirects to the OAuth provider |
 | `createCallbackHandler(opts)` | `{ GET, POST }` -- completes the code exchange, sets the session cookie |
 | `createLogoutHandler(opts)` | `{ POST }` -- clears the session cookie |

package/dist/bridge/index.d.ts

@@ -1,2 +1,2 @@
-import { C as bridgeCapabilitySchema, D as bridgeRequestSchema, E as bridgeReadyMessageSchema, O as bridgeResponseSchema, S as analyticsTrackPayloadSchema, T as bridgeHelloMessageSchema, _ as BridgeReadyMessage, a as FanvueBridge, b as analyticsEventNameSchema, c as ANALYTICS_TRACK_METHOD, d as BRIDGE_HELLO_TYPE, f as BRIDGE_READY_TYPE, g as BridgeHelloMessage, h as BridgeErrorCode, i as BridgeRequestError, l as AnalyticsProperties, m as BridgeCapability, n as ConnectFanvueBridgeOptions, o as FanvueBridgeAnalytics, p as BRIDGE_VERSION, r as connectFanvueBridge, s as ANALYTICS_CAPABILITY, t as BridgeConnectError, u as AnalyticsTrackPayload, v as BridgeRequest, w as bridgeErrorCodeSchema, x as analyticsPropertiesSchema, y as BridgeResponse } from "../index-BRDYLBlc.js";
+import { C as bridgeCapabilitySchema, D as bridgeRequestSchema, E as bridgeReadyMessageSchema, O as bridgeResponseSchema, S as analyticsTrackPayloadSchema, T as bridgeHelloMessageSchema, _ as BridgeReadyMessage, a as FanvueBridge, b as analyticsEventNameSchema, c as ANALYTICS_TRACK_METHOD, d as BRIDGE_HELLO_TYPE, f as BRIDGE_READY_TYPE, g as BridgeHelloMessage, h as BridgeErrorCode, i as BridgeRequestError, l as AnalyticsProperties, m as BridgeCapability, n as ConnectFanvueBridgeOptions, o as FanvueBridgeAnalytics, p as BRIDGE_VERSION, r as connectFanvueBridge, s as ANALYTICS_CAPABILITY, t as BridgeConnectError, u as AnalyticsTrackPayload, v as BridgeRequest, w as bridgeErrorCodeSchema, x as analyticsPropertiesSchema, y as BridgeResponse } from "../index-CEFYZtlb.js";
 export { ANALYTICS_CAPABILITY, ANALYTICS_TRACK_METHOD, AnalyticsProperties, AnalyticsTrackPayload, BRIDGE_HELLO_TYPE, BRIDGE_READY_TYPE, BRIDGE_VERSION, BridgeCapability, BridgeConnectError, BridgeErrorCode, BridgeHelloMessage, BridgeReadyMessage, BridgeRequest, BridgeRequestError, BridgeResponse, ConnectFanvueBridgeOptions, FanvueBridge, FanvueBridgeAnalytics, analyticsEventNameSchema, analyticsPropertiesSchema, analyticsTrackPayloadSchema, bridgeCapabilitySchema, bridgeErrorCodeSchema, bridgeHelloMessageSchema, bridgeReadyMessageSchema, bridgeRequestSchema, bridgeResponseSchema, connectFanvueBridge };

package/dist/bridge/index.js

@@ -1,3 +1,3 @@
-import "../schemas-DbyHF7Xi.js";
-import { a as BRIDGE_READY_TYPE, c as analyticsPropertiesSchema, d as bridgeErrorCodeSchema, f as bridgeHelloMessageSchema, h as bridgeResponseSchema, i as BRIDGE_HELLO_TYPE, l as analyticsTrackPayloadSchema, m as bridgeRequestSchema, n as ANALYTICS_CAPABILITY, o as BRIDGE_VERSION, p as bridgeReadyMessageSchema, r as ANALYTICS_TRACK_METHOD, s as analyticsEventNameSchema, t as connectFanvueBridge, u as bridgeCapabilitySchema } from "../bridge-CGVtI3hr.js";
+import "../index.cjs-teGsk6HB.js";
+import { a as BRIDGE_READY_TYPE, c as analyticsPropertiesSchema, d as bridgeErrorCodeSchema, f as bridgeHelloMessageSchema, h as bridgeResponseSchema, i as BRIDGE_HELLO_TYPE, l as analyticsTrackPayloadSchema, m as bridgeRequestSchema, n as ANALYTICS_CAPABILITY, o as BRIDGE_VERSION, p as bridgeReadyMessageSchema, r as ANALYTICS_TRACK_METHOD, s as analyticsEventNameSchema, t as connectFanvueBridge, u as bridgeCapabilitySchema } from "../bridge-QnF7P4Co.js";
 export { ANALYTICS_CAPABILITY, ANALYTICS_TRACK_METHOD, BRIDGE_HELLO_TYPE, BRIDGE_READY_TYPE, BRIDGE_VERSION, analyticsEventNameSchema, analyticsPropertiesSchema, analyticsTrackPayloadSchema, bridgeCapabilitySchema, bridgeErrorCodeSchema, bridgeHelloMessageSchema, bridgeReadyMessageSchema, bridgeRequestSchema, bridgeResponseSchema, connectFanvueBridge };

package/dist/{bridge-CGVtI3hr.js → bridge-QnF7P4Co.js}

@@ -1,4 +1,4 @@
-import { a as number, c as string, d as prettifyError, f as require_index_cjs, i as literal, l as union, n as array, o as object, r as boolean, s as record, t as _enum, u as unknown } from "./schemas-DbyHF7Xi.js";
+import { c as number, d as record, f as string, g as prettifyError, i as boolean, l as object, m as unknown, n as _enum, o as literal, p as union, r as array, t as require_index_cjs } from "./index.cjs-teGsk6HB.js";
 //#region src/bridge/protocol.ts
 /**
 * The bridge protocol version spoken by this SDK.
@@ -333,4 +333,4 @@ function connectFanvueBridge(options) {
 //#endregion
 export { BRIDGE_READY_TYPE as a, analyticsPropertiesSchema as c, bridgeErrorCodeSchema as d, bridgeHelloMessageSchema as f, bridgeResponseSchema as h, BRIDGE_HELLO_TYPE as i, analyticsTrackPayloadSchema as l, bridgeRequestSchema as m, ANALYTICS_CAPABILITY as n, BRIDGE_VERSION as o, bridgeReadyMessageSchema as p, ANALYTICS_TRACK_METHOD as r, analyticsEventNameSchema as s, connectFanvueBridge as t, bridgeCapabilitySchema as u };
 
-//# sourceMappingURL=bridge-CGVtI3hr.js.map
+//# sourceMappingURL=bridge-QnF7P4Co.js.map

package/dist/{bridge-CGVtI3hr.js.map → bridge-QnF7P4Co.js.map}

@@ -1 +1 @@
-{"version":3,"file":"bridge-CGVtI3hr.js","names":["z.enum","z.object","z.literal","z.array","z.string","z.unknown","z.boolean","z\n  .record","z.union","z.number","z.prettifyError"],"sources":["../src/bridge/protocol.ts","../src/bridge/bridge.ts","../src/bridge/connect.ts"],"sourcesContent":["import { z } from 'zod';\n\n/**\n * The bridge protocol version spoken by this SDK.\n *\n * Both sides send it on every message. Changes within a version must be\n * additive; anything breaking increments the version, and the host answers the\n * handshake with the highest version both sides speak.\n */\nexport const BRIDGE_VERSION = 1;\n\n/**\n * Message type the embedded app posts to the host to open a handshake.\n *\n * An app may re-announce (it re-posts `ready` until a `hello` lands, in case\n * the host attached its listener late).\n */\nexport const BRIDGE_READY_TYPE = 'fanvue:bridge:ready';\n\n/**\n * Message type the host posts back, carrying the granted capabilities and the port.\n *\n * The host answers each verified `ready` with a fresh `hello` and port,\n * closing the prior port; the app adopts the newest `hello`.\n */\nexport const BRIDGE_HELLO_TYPE = 'fanvue:bridge:hello';\n\n/** Capability namespace for analytics (`analytics.track`). */\nexport const ANALYTICS_CAPABILITY = 'analytics';\n\n/** Method name for tracking an analytics event. */\nexport const ANALYTICS_TRACK_METHOD = 'track';\n\n/** The host capabilities an app can be granted. Grants are resolved server-side. */\nexport const bridgeCapabilitySchema = z.enum([ANALYTICS_CAPABILITY]);\n\n/** A host capability an app can be granted. */\nexport type BridgeCapability = z.infer<typeof bridgeCapabilitySchema>;\n\n/**\n * Error codes the host can return for a request.\n *\n * - `capability_denied` — the app was not granted the requested capability.\n * - `invalid_payload` — the payload failed the host's schema for the method.\n * - `rate_limited` — the app exceeded the host's budget for the method.\n * - `internal` — the host handler failed unexpectedly.\n */\nexport const bridgeErrorCodeSchema = z.enum([\n  'capability_denied',\n  'invalid_payload',\n  'rate_limited',\n  'internal',\n]);\n\n/** An error code the host can return for a request. */\nexport type BridgeErrorCode = z.infer<typeof bridgeErrorCodeSchema>;\n\n/** Schema for the `ready` message an app posts to `window.parent`. */\nexport const bridgeReadyMessageSchema = z.object({\n  type: z.literal(BRIDGE_READY_TYPE),\n  v: z.literal(BRIDGE_VERSION),\n});\n\n/** The `ready` message an app posts to `window.parent` to open a handshake. */\nexport type BridgeReadyMessage = z.infer<typeof bridgeReadyMessageSchema>;\n\n/** Schema for the `hello` message the host posts back with the transferred port. */\nexport const bridgeHelloMessageSchema = z.object({\n  type: z.literal(BRIDGE_HELLO_TYPE),\n  v: z.literal(BRIDGE_VERSION),\n  capabilities: z.array(bridgeCapabilitySchema),\n});\n\n/** The `hello` message the host posts back, alongside the transferred port. */\nexport type BridgeHelloMessage = z.infer<typeof bridgeHelloMessageSchema>;\n\n/**\n * Schema for a request sent app → host over the port.\n *\n * Capability and method names are bounded so a misbehaving sender cannot make\n * either side hold or log arbitrarily large strings.\n */\nexport const bridgeRequestSchema = z.object({\n  v: z.literal(BRIDGE_VERSION),\n  id: z.string().min(1).max(64),\n  kind: z.literal('request'),\n  capability: z.string().min(1).max(64),\n  method: z.string().min(1).max(64),\n  payload: z.unknown(),\n});\n\n/** A request sent app → host over the port, correlated to a response by `id`. */\nexport type BridgeRequest = z.infer<typeof bridgeRequestSchema>;\n\n/**\n * Schema for a response sent host → app over the port.\n *\n * The `id` and `error.message` are bounded like the request fields, so a\n * misbehaving host cannot push oversized strings into the app.\n */\nexport const bridgeResponseSchema = z.object({\n  v: z.literal(BRIDGE_VERSION),\n  id: z.string().max(64),\n  kind: z.literal('response'),\n  ok: z.boolean(),\n  result: z.unknown().optional(),\n  error: z.object({ code: bridgeErrorCodeSchema, message: z.string().max(1024) }).optional(),\n});\n\n/** A response sent host → app over the port, correlated to a request by `id`. */\nexport type BridgeResponse = z.infer<typeof bridgeResponseSchema>;\n\n/**\n * Event names an app may emit.\n *\n * The host prefixes every name with `embedded_app_` before it reaches\n * Amplitude, so an app can never emit a core platform event. Names are\n * snake_case to match the platform's tracking-plan convention.\n */\nexport const analyticsEventNameSchema = z.string().regex(/^[a-z0-9_]{1,64}$/);\n\n/**\n * Property keys reserved by the host.\n *\n * Identity and revenue are host-owned: the host page's Amplitude client is\n * already identified as the viewer, and an app must not be able to overwrite\n * that or fabricate revenue.\n */\nconst ANALYTICS_RESERVED_PROPERTY_KEYS: readonly string[] = ['user_id', 'device_id', 'revenue'];\n\n/** Maximum number of properties on a single event. */\nconst ANALYTICS_MAX_PROPERTY_KEYS = 20;\n\n/** Whether a property key is one an app is allowed to set. */\nfunction isAllowedAnalyticsPropertyKey(key: string): boolean {\n  return !ANALYTICS_RESERVED_PROPERTY_KEYS.includes(key) && !key.startsWith('$');\n}\n\n/**\n * Properties attached to an analytics event: a flat record of short scalars.\n *\n * Nesting is rejected so the payload stays cheap to validate and to read in\n * Amplitude, and `$`-prefixed keys are rejected because Amplitude reserves them.\n * Numbers must be finite — `Infinity` and `NaN` do not survive serialisation.\n */\nexport const analyticsPropertiesSchema = z\n  .record(\n    z.string().min(1).max(64),\n    z.union([z.string().max(256), z.number().finite(), z.boolean()]),\n  )\n  .refine((properties) => Object.keys(properties).length <= ANALYTICS_MAX_PROPERTY_KEYS, {\n    message: `An event may carry at most ${ANALYTICS_MAX_PROPERTY_KEYS} properties`,\n  })\n  .refine((properties) => Object.keys(properties).every(isAllowedAnalyticsPropertyKey), {\n    message: `Properties may not use a reserved key (${ANALYTICS_RESERVED_PROPERTY_KEYS.join(', ')}) or a key starting with \"$\"`,\n  });\n\n/** Schema for the payload of `analytics.track`. */\nexport const analyticsTrackPayloadSchema = z.object({\n  eventName: analyticsEventNameSchema,\n  properties: analyticsPropertiesSchema.optional(),\n});\n\n/** The payload of `analytics.track`. */\nexport type AnalyticsTrackPayload = z.infer<typeof analyticsTrackPayloadSchema>;\n\n/** Properties attached to an analytics event. */\nexport type AnalyticsProperties = z.infer<typeof analyticsPropertiesSchema>;\n","import { err, ok } from 'neverthrow';\nimport { z } from 'zod';\n\nimport {\n  ANALYTICS_CAPABILITY,\n  ANALYTICS_TRACK_METHOD,\n  BRIDGE_VERSION,\n  analyticsTrackPayloadSchema,\n  bridgeResponseSchema,\n  type AnalyticsProperties,\n  type BridgeCapability,\n  type BridgeErrorCode,\n  type BridgeRequest,\n  type BridgeResponse,\n} from './protocol.js';\n\nimport type { Result } from 'neverthrow';\n\n/**\n * Why a bridge request failed.\n *\n * Beyond the codes the host can return, the SDK adds `TIMEOUT` (the host never\n * answered) and `PORT_CLOSED` (the message could not be put on the port —\n * in practice the payload was not structured-cloneable). Note that\n * `postMessage` on a closed port silently drops rather than throwing, so a\n * torn-down host surfaces as `TIMEOUT`, not `PORT_CLOSED`.\n */\nexport interface BridgeRequestError {\n  code: BridgeErrorCode | 'TIMEOUT' | 'PORT_CLOSED';\n  message: string;\n}\n\n/** The analytics capability, as exposed on a connected bridge. */\nexport interface FanvueBridgeAnalytics {\n  track: (\n    eventName: string,\n    properties?: AnalyticsProperties,\n  ) => Promise<Result<void, BridgeRequestError>>;\n}\n\n/**\n * A live connection to the Fanvue host page.\n *\n * @property capabilities - The capabilities the host granted this app.\n * @property has - Whether a given capability was granted. Checking is\n *   optional: calling a capability without checking is safe and returns\n *   `capability_denied`.\n * @property analytics - Fires events through the host page's Amplitude client.\n */\nexport interface FanvueBridge {\n  capabilities: readonly BridgeCapability[];\n  has: (capability: BridgeCapability) => boolean;\n  analytics: FanvueBridgeAnalytics;\n}\n\n/**\n * A {@link FanvueBridge} plus the internals `connectFanvueBridge` drives.\n *\n * Not exported from the public entry: apps only ever see {@link FanvueBridge}.\n *\n * @property adoptPort - Swaps the underlying port for the one carried by a\n *   newer `hello`, closing the old port. Requests in flight on the old port\n *   fail by their existing timeouts.\n */\nexport interface InternalFanvueBridge extends FanvueBridge {\n  adoptPort: (port: MessagePort) => void;\n}\n\n/**\n * Everything {@link createFanvueBridge} needs to serve requests.\n *\n * @property port - The `MessagePort` transferred by the host in its `hello`.\n * @property capabilities - The capabilities named in the host's `hello`.\n * @property requestTimeoutMs - How long to wait for a response before failing.\n */\nexport interface FanvueBridgeContext {\n  port: MessagePort;\n  capabilities: readonly BridgeCapability[];\n  requestTimeoutMs: number;\n}\n\ninterface PendingRequest {\n  resolve: (response: BridgeResponse) => void;\n  timer: ReturnType<typeof setTimeout>;\n}\n\n/**\n * Builds the {@link FanvueBridge} served over an established port.\n *\n * Requests are correlated to responses by `id`; anything arriving on the port\n * that is not a well-formed response for a request still in flight is ignored,\n * so a misbehaving host cannot resolve a request twice or crash the app.\n *\n * Apps get this from {@link connectFanvueBridge} rather than calling it directly.\n *\n * @param ctx - The port, granted capabilities, and per-request timeout.\n * @returns The bridge exposed to the app.\n */\nexport function createFanvueBridge(ctx: FanvueBridgeContext): InternalFanvueBridge {\n  const { capabilities, requestTimeoutMs } = ctx;\n  const pending = new Map<string, PendingRequest>();\n  let requestSequence = 0;\n  let port = ctx.port;\n\n  function onPortMessage(event: MessageEvent): void {\n    const parsed = bridgeResponseSchema.safeParse(event.data);\n    if (!parsed.success) return;\n\n    const inFlight = pending.get(parsed.data.id);\n    if (!inFlight) return;\n\n    pending.delete(parsed.data.id);\n    clearTimeout(inFlight.timer);\n    inFlight.resolve(parsed.data);\n  }\n\n  function attach(next: MessagePort): void {\n    next.addEventListener('message', onPortMessage);\n    next.start();\n  }\n  attach(port);\n\n  function adoptPort(next: MessagePort): void {\n    // The host closes its end of the superseded port when it re-answers a\n    // ready; close this end too and route all later requests over the new\n    // port. Requests still in flight on the old port fail by their timeouts.\n    port.close();\n    port = next;\n    attach(next);\n  }\n\n  function has(capability: BridgeCapability): boolean {\n    return capabilities.includes(capability);\n  }\n\n  async function request(\n    capability: BridgeCapability,\n    method: string,\n    payload: unknown,\n  ): Promise<Result<unknown, BridgeRequestError>> {\n    if (!has(capability)) {\n      return err({\n        code: 'capability_denied',\n        message: `The host did not grant the \"${capability}\" capability to this app.`,\n      });\n    }\n\n    requestSequence += 1;\n    const id = `${capability}-${requestSequence}`;\n    const message: BridgeRequest = {\n      v: BRIDGE_VERSION,\n      id,\n      kind: 'request',\n      capability,\n      method,\n      payload,\n    };\n\n    try {\n      port.postMessage(message);\n    } catch (error) {\n      return err({\n        code: 'PORT_CLOSED',\n        message: `Could not send the request to the host: ${error instanceof Error ? error.message : String(error)}`,\n      });\n    }\n\n    // Registered after the send: port delivery is always queued as a task, so\n    // no response can arrive before this synchronous block finishes.\n    const settled = await new Promise<BridgeResponse | null>((resolve) => {\n      const timer = setTimeout(() => {\n        pending.delete(id);\n        resolve(null);\n      }, requestTimeoutMs);\n      pending.set(id, { resolve, timer });\n    });\n    if (settled === null) {\n      return err({\n        code: 'TIMEOUT',\n        message: `The host did not answer \"${capability}.${method}\" within ${requestTimeoutMs}ms.`,\n      });\n    }\n\n    if (!settled.ok) {\n      return err({\n        code: settled.error?.code ?? 'internal',\n        message: settled.error?.message ?? 'The host rejected the request without a reason.',\n      });\n    }\n\n    return ok(settled.result);\n  }\n\n  async function track(\n    eventName: string,\n    properties?: AnalyticsProperties,\n  ): Promise<Result<void, BridgeRequestError>> {\n    // Validate before sending so a malformed call fails immediately with a\n    // readable message; the host validates again as the authoritative check.\n    const payload = analyticsTrackPayloadSchema.safeParse(\n      properties === undefined ? { eventName } : { eventName, properties },\n    );\n    if (!payload.success) {\n      return err({ code: 'invalid_payload', message: z.prettifyError(payload.error) });\n    }\n\n    const result = await request(ANALYTICS_CAPABILITY, ANALYTICS_TRACK_METHOD, payload.data);\n    return result.map((): void => undefined);\n  }\n\n  return {\n    capabilities,\n    has,\n    analytics: { track },\n    adoptPort,\n  };\n}\n","import { err, ok } from 'neverthrow';\n\nimport { createFanvueBridge, type FanvueBridge, type InternalFanvueBridge } from './bridge.js';\nimport {\n  BRIDGE_READY_TYPE,\n  BRIDGE_VERSION,\n  bridgeHelloMessageSchema,\n  type BridgeReadyMessage,\n} from './protocol.js';\n\nimport type { Result } from 'neverthrow';\n\n/** How long to wait for the host's `hello` before giving up. */\nconst DEFAULT_CONNECT_TIMEOUT_MS = 3000;\n\n/** How long to wait for a response to a single request once connected. */\nconst REQUEST_TIMEOUT_MS = 3000;\n\n/**\n * How often to re-post `ready` until the handshake settles.\n *\n * The host attaches its listener asynchronously (its capability grants come\n * from a query), so a single `ready` posted right after the iframe loads can\n * arrive before anyone is listening. Re-announcing until a `hello` lands (or\n * the timeout fires) closes that race.\n */\nconst READY_REANNOUNCE_INTERVAL_MS = 500;\n\n/**\n * Why connecting to the host failed.\n *\n * - `NOT_EMBEDDED` — the app is not running in an iframe, so there is no host.\n * - `TIMEOUT` — no `hello` arrived. The page is framed by something other than\n *   Fanvue, or Fanvue refused the handshake (unregistered embed origin).\n */\nexport interface BridgeConnectError {\n  code: 'NOT_EMBEDDED' | 'TIMEOUT';\n  message: string;\n}\n\n/**\n * Options for {@link connectFanvueBridge}.\n *\n * @property timeoutMs - How long to wait for the host's `hello`. Defaults to 3000.\n */\nexport interface ConnectFanvueBridgeOptions {\n  timeoutMs?: number;\n}\n\n/**\n * Opens the capability bridge to the Fanvue page hosting this app.\n *\n * Posts `fanvue:bridge:ready` to `window.parent` and waits for the host's\n * `fanvue:bridge:hello`, which names the granted capabilities and transfers the\n * `MessagePort` all later traffic flows over. The host verifies the frame's\n * origin before replying, so a page framed by anything other than its\n * registered Fanvue surface simply times out.\n *\n * `ready` is re-posted every 500ms until a `hello` lands (or the timeout\n * fires), because the host may attach its listener after the app's first\n * announce. The host answers each verified `ready` with a fresh `hello` and\n * port, closing the prior port — so the bridge keeps listening for the\n * lifetime of the connection and adopts the newest `hello` by swapping onto\n * its port. Requests in flight on a superseded port fail by their timeouts.\n *\n * Calling this again is safe and is how an app reconnects after the iframe\n * reloads: the host closes the previous port and re-handshakes.\n *\n * Failure is not exceptional — apps are expected to keep working standalone\n * (local dev, previews) where the connection never succeeds.\n *\n * @param options - Optional overrides (e.g. a shorter `timeoutMs`).\n * @returns A `Result` with the connected {@link FanvueBridge}, or a\n *   {@link BridgeConnectError} when there is no host to talk to.\n *\n * @example\n * const result = await connectFanvueBridge();\n * if (result.isOk() && result.value.has('analytics')) {\n *   await result.value.analytics.track('course_created', { chapters: 4 });\n * }\n */\nexport function connectFanvueBridge(\n  options?: ConnectFanvueBridgeOptions,\n): Promise<Result<FanvueBridge, BridgeConnectError>> {\n  const timeoutMs = options?.timeoutMs ?? DEFAULT_CONNECT_TIMEOUT_MS;\n\n  if (typeof window === 'undefined' || window.parent === window) {\n    return Promise.resolve(\n      err({\n        code: 'NOT_EMBEDDED',\n        message:\n          'The app is not running inside a Fanvue iframe, so there is no host to connect to.',\n      }),\n    );\n  }\n  const host = window.parent;\n\n  return new Promise((resolve) => {\n    let settled = false;\n    let bridge: InternalFanvueBridge | null = null;\n\n    const timer = setTimeout(() => {\n      finish(\n        err({\n          code: 'TIMEOUT',\n          message: `The Fanvue host did not complete the handshake within ${timeoutMs}ms.`,\n        }),\n      );\n    }, timeoutMs);\n\n    // Re-announce until the handshake settles, in case the host attached its\n    // listener after the first `ready`.\n    const reannounce = setInterval(postReady, READY_REANNOUNCE_INTERVAL_MS);\n\n    function finish(result: Result<FanvueBridge, BridgeConnectError>): void {\n      if (settled) return;\n      settled = true;\n      clearTimeout(timer);\n      clearInterval(reannounce);\n      // Only a failed handshake stops listening. After a `hello` the listener\n      // lives for the lifetime of the bridge: the host may answer more than\n      // one `ready` (it closes the prior port each time), and the bridge must\n      // adopt the newest port to stay on the one the host is serving.\n      if (result.isErr()) window.removeEventListener('message', onMessage);\n      resolve(result);\n    }\n\n    function onMessage(event: MessageEvent): void {\n      // The host is the only window that can hold this frame's port; anything\n      // else on the window channel belongs to another protocol.\n      if (event.source !== host) return;\n\n      const hello = bridgeHelloMessageSchema.safeParse(event.data);\n      if (!hello.success) return;\n\n      const port = event.ports[0];\n      if (!port) return;\n\n      if (bridge) {\n        bridge.adoptPort(port);\n        return;\n      }\n\n      bridge = createFanvueBridge({\n        port,\n        capabilities: hello.data.capabilities,\n        requestTimeoutMs: REQUEST_TIMEOUT_MS,\n      });\n      finish(ok(bridge));\n    }\n\n    window.addEventListener('message', onMessage);\n\n    function postReady(): void {\n      const ready: BridgeReadyMessage = { type: BRIDGE_READY_TYPE, v: BRIDGE_VERSION };\n      // Targets \"*\" because the app cannot know the host's origin before the\n      // handshake, and `ready` carries nothing but the protocol version.\n      host.postMessage(ready, '*');\n    }\n    postReady();\n  });\n}\n"],"mappings":"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"}
+{"version":3,"file":"bridge-QnF7P4Co.js","names":["z.enum","z.object","z.literal","z.array","z.string","z.unknown","z.boolean","z\n  .record","z.union","z.number","z.prettifyError"],"sources":["../src/bridge/protocol.ts","../src/bridge/bridge.ts","../src/bridge/connect.ts"],"sourcesContent":["import { z } from 'zod';\n\n/**\n * The bridge protocol version spoken by this SDK.\n *\n * Both sides send it on every message. Changes within a version must be\n * additive; anything breaking increments the version, and the host answers the\n * handshake with the highest version both sides speak.\n */\nexport const BRIDGE_VERSION = 1;\n\n/**\n * Message type the embedded app posts to the host to open a handshake.\n *\n * An app may re-announce (it re-posts `ready` until a `hello` lands, in case\n * the host attached its listener late).\n */\nexport const BRIDGE_READY_TYPE = 'fanvue:bridge:ready';\n\n/**\n * Message type the host posts back, carrying the granted capabilities and the port.\n *\n * The host answers each verified `ready` with a fresh `hello` and port,\n * closing the prior port; the app adopts the newest `hello`.\n */\nexport const BRIDGE_HELLO_TYPE = 'fanvue:bridge:hello';\n\n/** Capability namespace for analytics (`analytics.track`). */\nexport const ANALYTICS_CAPABILITY = 'analytics';\n\n/** Method name for tracking an analytics event. */\nexport const ANALYTICS_TRACK_METHOD = 'track';\n\n/** The host capabilities an app can be granted. Grants are resolved server-side. */\nexport const bridgeCapabilitySchema = z.enum([ANALYTICS_CAPABILITY]);\n\n/** A host capability an app can be granted. */\nexport type BridgeCapability = z.infer<typeof bridgeCapabilitySchema>;\n\n/**\n * Error codes the host can return for a request.\n *\n * - `capability_denied` — the app was not granted the requested capability.\n * - `invalid_payload` — the payload failed the host's schema for the method.\n * - `rate_limited` — the app exceeded the host's budget for the method.\n * - `internal` — the host handler failed unexpectedly.\n */\nexport const bridgeErrorCodeSchema = z.enum([\n  'capability_denied',\n  'invalid_payload',\n  'rate_limited',\n  'internal',\n]);\n\n/** An error code the host can return for a request. */\nexport type BridgeErrorCode = z.infer<typeof bridgeErrorCodeSchema>;\n\n/** Schema for the `ready` message an app posts to `window.parent`. */\nexport const bridgeReadyMessageSchema = z.object({\n  type: z.literal(BRIDGE_READY_TYPE),\n  v: z.literal(BRIDGE_VERSION),\n});\n\n/** The `ready` message an app posts to `window.parent` to open a handshake. */\nexport type BridgeReadyMessage = z.infer<typeof bridgeReadyMessageSchema>;\n\n/** Schema for the `hello` message the host posts back with the transferred port. */\nexport const bridgeHelloMessageSchema = z.object({\n  type: z.literal(BRIDGE_HELLO_TYPE),\n  v: z.literal(BRIDGE_VERSION),\n  capabilities: z.array(bridgeCapabilitySchema),\n});\n\n/** The `hello` message the host posts back, alongside the transferred port. */\nexport type BridgeHelloMessage = z.infer<typeof bridgeHelloMessageSchema>;\n\n/**\n * Schema for a request sent app → host over the port.\n *\n * Capability and method names are bounded so a misbehaving sender cannot make\n * either side hold or log arbitrarily large strings.\n */\nexport const bridgeRequestSchema = z.object({\n  v: z.literal(BRIDGE_VERSION),\n  id: z.string().min(1).max(64),\n  kind: z.literal('request'),\n  capability: z.string().min(1).max(64),\n  method: z.string().min(1).max(64),\n  payload: z.unknown(),\n});\n\n/** A request sent app → host over the port, correlated to a response by `id`. */\nexport type BridgeRequest = z.infer<typeof bridgeRequestSchema>;\n\n/**\n * Schema for a response sent host → app over the port.\n *\n * The `id` and `error.message` are bounded like the request fields, so a\n * misbehaving host cannot push oversized strings into the app.\n */\nexport const bridgeResponseSchema = z.object({\n  v: z.literal(BRIDGE_VERSION),\n  id: z.string().max(64),\n  kind: z.literal('response'),\n  ok: z.boolean(),\n  result: z.unknown().optional(),\n  error: z.object({ code: bridgeErrorCodeSchema, message: z.string().max(1024) }).optional(),\n});\n\n/** A response sent host → app over the port, correlated to a request by `id`. */\nexport type BridgeResponse = z.infer<typeof bridgeResponseSchema>;\n\n/**\n * Event names an app may emit.\n *\n * The host prefixes every name with `embedded_app_` before it reaches\n * Amplitude, so an app can never emit a core platform event. Names are\n * snake_case to match the platform's tracking-plan convention.\n */\nexport const analyticsEventNameSchema = z.string().regex(/^[a-z0-9_]{1,64}$/);\n\n/**\n * Property keys reserved by the host.\n *\n * Identity and revenue are host-owned: the host page's Amplitude client is\n * already identified as the viewer, and an app must not be able to overwrite\n * that or fabricate revenue.\n */\nconst ANALYTICS_RESERVED_PROPERTY_KEYS: readonly string[] = ['user_id', 'device_id', 'revenue'];\n\n/** Maximum number of properties on a single event. */\nconst ANALYTICS_MAX_PROPERTY_KEYS = 20;\n\n/** Whether a property key is one an app is allowed to set. */\nfunction isAllowedAnalyticsPropertyKey(key: string): boolean {\n  return !ANALYTICS_RESERVED_PROPERTY_KEYS.includes(key) && !key.startsWith('$');\n}\n\n/**\n * Properties attached to an analytics event: a flat record of short scalars.\n *\n * Nesting is rejected so the payload stays cheap to validate and to read in\n * Amplitude, and `$`-prefixed keys are rejected because Amplitude reserves them.\n * Numbers must be finite — `Infinity` and `NaN` do not survive serialisation.\n */\nexport const analyticsPropertiesSchema = z\n  .record(\n    z.string().min(1).max(64),\n    z.union([z.string().max(256), z.number().finite(), z.boolean()]),\n  )\n  .refine((properties) => Object.keys(properties).length <= ANALYTICS_MAX_PROPERTY_KEYS, {\n    message: `An event may carry at most ${ANALYTICS_MAX_PROPERTY_KEYS} properties`,\n  })\n  .refine((properties) => Object.keys(properties).every(isAllowedAnalyticsPropertyKey), {\n    message: `Properties may not use a reserved key (${ANALYTICS_RESERVED_PROPERTY_KEYS.join(', ')}) or a key starting with \"$\"`,\n  });\n\n/** Schema for the payload of `analytics.track`. */\nexport const analyticsTrackPayloadSchema = z.object({\n  eventName: analyticsEventNameSchema,\n  properties: analyticsPropertiesSchema.optional(),\n});\n\n/** The payload of `analytics.track`. */\nexport type AnalyticsTrackPayload = z.infer<typeof analyticsTrackPayloadSchema>;\n\n/** Properties attached to an analytics event. */\nexport type AnalyticsProperties = z.infer<typeof analyticsPropertiesSchema>;\n","import { err, ok } from 'neverthrow';\nimport { z } from 'zod';\n\nimport {\n  ANALYTICS_CAPABILITY,\n  ANALYTICS_TRACK_METHOD,\n  BRIDGE_VERSION,\n  analyticsTrackPayloadSchema,\n  bridgeResponseSchema,\n  type AnalyticsProperties,\n  type BridgeCapability,\n  type BridgeErrorCode,\n  type BridgeRequest,\n  type BridgeResponse,\n} from './protocol.js';\n\nimport type { Result } from 'neverthrow';\n\n/**\n * Why a bridge request failed.\n *\n * Beyond the codes the host can return, the SDK adds `TIMEOUT` (the host never\n * answered) and `PORT_CLOSED` (the message could not be put on the port —\n * in practice the payload was not structured-cloneable). Note that\n * `postMessage` on a closed port silently drops rather than throwing, so a\n * torn-down host surfaces as `TIMEOUT`, not `PORT_CLOSED`.\n */\nexport interface BridgeRequestError {\n  code: BridgeErrorCode | 'TIMEOUT' | 'PORT_CLOSED';\n  message: string;\n}\n\n/** The analytics capability, as exposed on a connected bridge. */\nexport interface FanvueBridgeAnalytics {\n  track: (\n    eventName: string,\n    properties?: AnalyticsProperties,\n  ) => Promise<Result<void, BridgeRequestError>>;\n}\n\n/**\n * A live connection to the Fanvue host page.\n *\n * @property capabilities - The capabilities the host granted this app.\n * @property has - Whether a given capability was granted. Checking is\n *   optional: calling a capability without checking is safe and returns\n *   `capability_denied`.\n * @property analytics - Fires events through the host page's Amplitude client.\n */\nexport interface FanvueBridge {\n  capabilities: readonly BridgeCapability[];\n  has: (capability: BridgeCapability) => boolean;\n  analytics: FanvueBridgeAnalytics;\n}\n\n/**\n * A {@link FanvueBridge} plus the internals `connectFanvueBridge` drives.\n *\n * Not exported from the public entry: apps only ever see {@link FanvueBridge}.\n *\n * @property adoptPort - Swaps the underlying port for the one carried by a\n *   newer `hello`, closing the old port. Requests in flight on the old port\n *   fail by their existing timeouts.\n */\nexport interface InternalFanvueBridge extends FanvueBridge {\n  adoptPort: (port: MessagePort) => void;\n}\n\n/**\n * Everything {@link createFanvueBridge} needs to serve requests.\n *\n * @property port - The `MessagePort` transferred by the host in its `hello`.\n * @property capabilities - The capabilities named in the host's `hello`.\n * @property requestTimeoutMs - How long to wait for a response before failing.\n */\nexport interface FanvueBridgeContext {\n  port: MessagePort;\n  capabilities: readonly BridgeCapability[];\n  requestTimeoutMs: number;\n}\n\ninterface PendingRequest {\n  resolve: (response: BridgeResponse) => void;\n  timer: ReturnType<typeof setTimeout>;\n}\n\n/**\n * Builds the {@link FanvueBridge} served over an established port.\n *\n * Requests are correlated to responses by `id`; anything arriving on the port\n * that is not a well-formed response for a request still in flight is ignored,\n * so a misbehaving host cannot resolve a request twice or crash the app.\n *\n * Apps get this from {@link connectFanvueBridge} rather than calling it directly.\n *\n * @param ctx - The port, granted capabilities, and per-request timeout.\n * @returns The bridge exposed to the app.\n */\nexport function createFanvueBridge(ctx: FanvueBridgeContext): InternalFanvueBridge {\n  const { capabilities, requestTimeoutMs } = ctx;\n  const pending = new Map<string, PendingRequest>();\n  let requestSequence = 0;\n  let port = ctx.port;\n\n  function onPortMessage(event: MessageEvent): void {\n    const parsed = bridgeResponseSchema.safeParse(event.data);\n    if (!parsed.success) return;\n\n    const inFlight = pending.get(parsed.data.id);\n    if (!inFlight) return;\n\n    pending.delete(parsed.data.id);\n    clearTimeout(inFlight.timer);\n    inFlight.resolve(parsed.data);\n  }\n\n  function attach(next: MessagePort): void {\n    next.addEventListener('message', onPortMessage);\n    next.start();\n  }\n  attach(port);\n\n  function adoptPort(next: MessagePort): void {\n    // The host closes its end of the superseded port when it re-answers a\n    // ready; close this end too and route all later requests over the new\n    // port. Requests still in flight on the old port fail by their timeouts.\n    port.close();\n    port = next;\n    attach(next);\n  }\n\n  function has(capability: BridgeCapability): boolean {\n    return capabilities.includes(capability);\n  }\n\n  async function request(\n    capability: BridgeCapability,\n    method: string,\n    payload: unknown,\n  ): Promise<Result<unknown, BridgeRequestError>> {\n    if (!has(capability)) {\n      return err({\n        code: 'capability_denied',\n        message: `The host did not grant the \"${capability}\" capability to this app.`,\n      });\n    }\n\n    requestSequence += 1;\n    const id = `${capability}-${requestSequence}`;\n    const message: BridgeRequest = {\n      v: BRIDGE_VERSION,\n      id,\n      kind: 'request',\n      capability,\n      method,\n      payload,\n    };\n\n    try {\n      port.postMessage(message);\n    } catch (error) {\n      return err({\n        code: 'PORT_CLOSED',\n        message: `Could not send the request to the host: ${error instanceof Error ? error.message : String(error)}`,\n      });\n    }\n\n    // Registered after the send: port delivery is always queued as a task, so\n    // no response can arrive before this synchronous block finishes.\n    const settled = await new Promise<BridgeResponse | null>((resolve) => {\n      const timer = setTimeout(() => {\n        pending.delete(id);\n        resolve(null);\n      }, requestTimeoutMs);\n      pending.set(id, { resolve, timer });\n    });\n    if (settled === null) {\n      return err({\n        code: 'TIMEOUT',\n        message: `The host did not answer \"${capability}.${method}\" within ${requestTimeoutMs}ms.`,\n      });\n    }\n\n    if (!settled.ok) {\n      return err({\n        code: settled.error?.code ?? 'internal',\n        message: settled.error?.message ?? 'The host rejected the request without a reason.',\n      });\n    }\n\n    return ok(settled.result);\n  }\n\n  async function track(\n    eventName: string,\n    properties?: AnalyticsProperties,\n  ): Promise<Result<void, BridgeRequestError>> {\n    // Validate before sending so a malformed call fails immediately with a\n    // readable message; the host validates again as the authoritative check.\n    const payload = analyticsTrackPayloadSchema.safeParse(\n      properties === undefined ? { eventName } : { eventName, properties },\n    );\n    if (!payload.success) {\n      return err({ code: 'invalid_payload', message: z.prettifyError(payload.error) });\n    }\n\n    const result = await request(ANALYTICS_CAPABILITY, ANALYTICS_TRACK_METHOD, payload.data);\n    return result.map((): void => undefined);\n  }\n\n  return {\n    capabilities,\n    has,\n    analytics: { track },\n    adoptPort,\n  };\n}\n","import { err, ok } from 'neverthrow';\n\nimport { createFanvueBridge, type FanvueBridge, type InternalFanvueBridge } from './bridge.js';\nimport {\n  BRIDGE_READY_TYPE,\n  BRIDGE_VERSION,\n  bridgeHelloMessageSchema,\n  type BridgeReadyMessage,\n} from './protocol.js';\n\nimport type { Result } from 'neverthrow';\n\n/** How long to wait for the host's `hello` before giving up. */\nconst DEFAULT_CONNECT_TIMEOUT_MS = 3000;\n\n/** How long to wait for a response to a single request once connected. */\nconst REQUEST_TIMEOUT_MS = 3000;\n\n/**\n * How often to re-post `ready` until the handshake settles.\n *\n * The host attaches its listener asynchronously (its capability grants come\n * from a query), so a single `ready` posted right after the iframe loads can\n * arrive before anyone is listening. Re-announcing until a `hello` lands (or\n * the timeout fires) closes that race.\n */\nconst READY_REANNOUNCE_INTERVAL_MS = 500;\n\n/**\n * Why connecting to the host failed.\n *\n * - `NOT_EMBEDDED` — the app is not running in an iframe, so there is no host.\n * - `TIMEOUT` — no `hello` arrived. The page is framed by something other than\n *   Fanvue, or Fanvue refused the handshake (unregistered embed origin).\n */\nexport interface BridgeConnectError {\n  code: 'NOT_EMBEDDED' | 'TIMEOUT';\n  message: string;\n}\n\n/**\n * Options for {@link connectFanvueBridge}.\n *\n * @property timeoutMs - How long to wait for the host's `hello`. Defaults to 3000.\n */\nexport interface ConnectFanvueBridgeOptions {\n  timeoutMs?: number;\n}\n\n/**\n * Opens the capability bridge to the Fanvue page hosting this app.\n *\n * Posts `fanvue:bridge:ready` to `window.parent` and waits for the host's\n * `fanvue:bridge:hello`, which names the granted capabilities and transfers the\n * `MessagePort` all later traffic flows over. The host verifies the frame's\n * origin before replying, so a page framed by anything other than its\n * registered Fanvue surface simply times out.\n *\n * `ready` is re-posted every 500ms until a `hello` lands (or the timeout\n * fires), because the host may attach its listener after the app's first\n * announce. The host answers each verified `ready` with a fresh `hello` and\n * port, closing the prior port — so the bridge keeps listening for the\n * lifetime of the connection and adopts the newest `hello` by swapping onto\n * its port. Requests in flight on a superseded port fail by their timeouts.\n *\n * Calling this again is safe and is how an app reconnects after the iframe\n * reloads: the host closes the previous port and re-handshakes.\n *\n * Failure is not exceptional — apps are expected to keep working standalone\n * (local dev, previews) where the connection never succeeds.\n *\n * @param options - Optional overrides (e.g. a shorter `timeoutMs`).\n * @returns A `Result` with the connected {@link FanvueBridge}, or a\n *   {@link BridgeConnectError} when there is no host to talk to.\n *\n * @example\n * const result = await connectFanvueBridge();\n * if (result.isOk() && result.value.has('analytics')) {\n *   await result.value.analytics.track('course_created', { chapters: 4 });\n * }\n */\nexport function connectFanvueBridge(\n  options?: ConnectFanvueBridgeOptions,\n): Promise<Result<FanvueBridge, BridgeConnectError>> {\n  const timeoutMs = options?.timeoutMs ?? DEFAULT_CONNECT_TIMEOUT_MS;\n\n  if (typeof window === 'undefined' || window.parent === window) {\n    return Promise.resolve(\n      err({\n        code: 'NOT_EMBEDDED',\n        message:\n          'The app is not running inside a Fanvue iframe, so there is no host to connect to.',\n      }),\n    );\n  }\n  const host = window.parent;\n\n  return new Promise((resolve) => {\n    let settled = false;\n    let bridge: InternalFanvueBridge | null = null;\n\n    const timer = setTimeout(() => {\n      finish(\n        err({\n          code: 'TIMEOUT',\n          message: `The Fanvue host did not complete the handshake within ${timeoutMs}ms.`,\n        }),\n      );\n    }, timeoutMs);\n\n    // Re-announce until the handshake settles, in case the host attached its\n    // listener after the first `ready`.\n    const reannounce = setInterval(postReady, READY_REANNOUNCE_INTERVAL_MS);\n\n    function finish(result: Result<FanvueBridge, BridgeConnectError>): void {\n      if (settled) return;\n      settled = true;\n      clearTimeout(timer);\n      clearInterval(reannounce);\n      // Only a failed handshake stops listening. After a `hello` the listener\n      // lives for the lifetime of the bridge: the host may answer more than\n      // one `ready` (it closes the prior port each time), and the bridge must\n      // adopt the newest port to stay on the one the host is serving.\n      if (result.isErr()) window.removeEventListener('message', onMessage);\n      resolve(result);\n    }\n\n    function onMessage(event: MessageEvent): void {\n      // The host is the only window that can hold this frame's port; anything\n      // else on the window channel belongs to another protocol.\n      if (event.source !== host) return;\n\n      const hello = bridgeHelloMessageSchema.safeParse(event.data);\n      if (!hello.success) return;\n\n      const port = event.ports[0];\n      if (!port) return;\n\n      if (bridge) {\n        bridge.adoptPort(port);\n        return;\n      }\n\n      bridge = createFanvueBridge({\n        port,\n        capabilities: hello.data.capabilities,\n        requestTimeoutMs: REQUEST_TIMEOUT_MS,\n      });\n      finish(ok(bridge));\n    }\n\n    window.addEventListener('message', onMessage);\n\n    function postReady(): void {\n      const ready: BridgeReadyMessage = { type: BRIDGE_READY_TYPE, v: BRIDGE_VERSION };\n      // Targets \"*\" because the app cannot know the host's origin before the\n      // handshake, and `ready` carries nothing but the protocol version.\n      host.postMessage(ready, '*');\n    }\n    postReady();\n  });\n}\n"],"mappings":"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"}

package/dist/core/index.d.ts

@@ -1,2 +1,2 @@
-import { A as DEFAULT_ISSUER_URL, C as OAuthConfig, D as TokenResponse, E as SessionVerifyError, F as HEADER_UPDATED_SESSION, M as DEFAULT_SCOPES, N as assertFanvueDomain, O as API_VERSION, P as BEARER_PREFIX, S as JsonParseError, T as SessionPayload, _ as refreshAccessToken, a as SessionPayloadSchema, b as EmbeddedAuthError, c as FanvueTheme, d as getThemeFromUrl, f as requestAuthorizationCodeOnBehalf, g as exchangeCodeForToken, h as createAuthorizationUrl, i as FanvueUserSchema, j as DEFAULT_PLATFORM_URL, k as DEFAULT_API_BASE_URL, l as exchangeSessionToken, m as verifySessionJwt, n as createFanvueClient, o as TokenResponseSchema, p as createSessionJwt, r as AuthorizeOnBehalfResponseSchema, s as safeJsonParse, t as FanvueClient, u as getSessionTokenFromUrl, v as ApiError, w as OAuthError, x as FanvueUser, y as EmbeddedAuthConfig } from "../index-ClbZoV_Z.js";
-export { API_VERSION, ApiError, AuthorizeOnBehalfResponseSchema, BEARER_PREFIX, DEFAULT_API_BASE_URL, DEFAULT_ISSUER_URL, DEFAULT_PLATFORM_URL, DEFAULT_SCOPES, EmbeddedAuthConfig, EmbeddedAuthError, FanvueClient, FanvueTheme, FanvueUser, FanvueUserSchema, HEADER_UPDATED_SESSION, JsonParseError, OAuthConfig, OAuthError, SessionPayload, SessionPayloadSchema, SessionVerifyError, TokenResponse, TokenResponseSchema, assertFanvueDomain, createAuthorizationUrl, createFanvueClient, createSessionJwt, exchangeCodeForToken, exchangeSessionToken, getSessionTokenFromUrl, getThemeFromUrl, refreshAccessToken, requestAuthorizationCodeOnBehalf, safeJsonParse, verifySessionJwt };
+import { $ as DEFAULT_ISSUER_URL, $t as resetFanvueEnvCache, A as safeJsonParse, At as isUnpublishResultMessage, B as refreshAccessToken, Bt as FanvueStringListErrorBodySchema, C as requireMachineAuth, Ct as UNPUBLISH_RESULT_MESSAGE, D as FanvueUserSchema, Dt as UnpublishResultMessageSchema, E as AuthorizeOnBehalfResponseSchema, Et as UnpublishResultMessage, F as requestAuthorizationCodeOnBehalf, Ft as FanvueErrorBody, G as JsonParseError, Gt as parseFanvueErrorBody, H as EmbeddedAuthConfig, Ht as NormalisedFanvueError, I as createSessionJwt, It as FanvueErrorBodySchema, J as SessionPayload, Jt as FanvueEnvSchema, K as OAuthConfig, Kt as EnvSource, L as verifySessionJwt, Lt as FanvueErrorFieldBodySchema, M as exchangeSessionToken, Mt as AppErrorEnvelopeSchema, N as getSessionTokenFromUrl, Nt as FANVUE_APP_ERROR_CODES, O as SessionPayloadSchema, Ot as isFanvueOrigin, P as getThemeFromUrl, Pt as FanvueAppErrorCode, Q as DEFAULT_API_BASE_URL, Qt as parseFanvueEnv, R as createAuthorizationUrl, Rt as FanvueIssueListErrorBodySchema, S as boundedBatchSize, St as UNPUBLISH_REQUEST_MESSAGE, T as createFanvueClient, Tt as UnpublishRequestMessageSchema, U as EmbeddedAuthError, Ut as OAuthErrorBody, V as ApiError, Vt as NON_SESSION_401_CODES, W as FanvueUser, Wt as OAuthErrorBodySchema, X as TokenResponse, Xt as flagEnabled, Y as SessionVerifyError, Yt as fanvueEnv, Z as API_VERSION, Zt as isFanvueConfigured, _ as logEvent, _t as PUBLISH_RESULT_MESSAGE, a as ReadinessEnv, an as FanvueAccessMode, at as HybridPaginationSchema, b as MachineAuthResult, bt as PublishResultMessage, c as LogEvent, cn as BEARER_PREFIX, ct as OffsetPaginationSchema, d as LogSink, dt as offsetPageSchema, en as EXPERIENCE_DENIAL_REASONS, et as DEFAULT_PLATFORM_URL, f as SafeLogFields, ft as EXPERIENCE_MESSAGE_TYPES, g as errorName, gt as PUBLISH_REQUEST_MESSAGE, h as createSafeLogFields, ht as ExperienceMessageType, i as ReadinessCheck, in as FANVUE_ACCESS_MODES, it as HybridPagination, j as FanvueTheme, jt as AppErrorEnvelope, k as TokenResponseSchema, kt as isPublishResultMessage, l as LogEventOptions, ln as HEADER_UPDATED_SESSION, lt as clampPageSize, m as createLogEvent, mt as ExperienceMessageSchema, n as SentryScrubber, nn as ExperienceDenialReason, nt as assertFanvueDomain, o as configurationReadiness, on as FanvueAccessModeSchema, ot as MAX_PAGE_SIZE, p as SafeLogValue, pt as ExperienceMessage, q as OAuthError, qt as FanvueEnv, r as createSentryScrubber, rn as ExperienceEntitledReason, rt as DEFAULT_PAGE_SIZE, s as BASE_ALLOWED_LOG_KEYS, sn as accessModeFromDenialReason, st as OffsetPagination, t as BASE_SENSITIVE_KEY_PATTERN, tn as EXPERIENCE_ENTITLED_REASONS, tt as DEFAULT_SCOPES, u as LogLevel, ut as cursorPageSchema, v as MINIMUM_BEARER_SECRET_LENGTH, vt as PublishRequestMessage, w as FanvueClient, wt as UnpublishRequestMessage, x as SignedRequestVerifier, xt as PublishResultMessageSchema, y as MachineAuthOptions, yt as PublishRequestMessageSchema, z as exchangeCodeForToken, zt as FanvueMessageErrorBodySchema } from "../index-C3CXrRiw.js";
+export { API_VERSION, ApiError, AppErrorEnvelope, AppErrorEnvelopeSchema, AuthorizeOnBehalfResponseSchema, BASE_ALLOWED_LOG_KEYS, BASE_SENSITIVE_KEY_PATTERN, BEARER_PREFIX, DEFAULT_API_BASE_URL, DEFAULT_ISSUER_URL, DEFAULT_PAGE_SIZE, DEFAULT_PLATFORM_URL, DEFAULT_SCOPES, EXPERIENCE_DENIAL_REASONS, EXPERIENCE_ENTITLED_REASONS, EXPERIENCE_MESSAGE_TYPES, EmbeddedAuthConfig, EmbeddedAuthError, EnvSource, ExperienceDenialReason, ExperienceEntitledReason, ExperienceMessage, ExperienceMessageSchema, ExperienceMessageType, FANVUE_ACCESS_MODES, FANVUE_APP_ERROR_CODES, FanvueAccessMode, FanvueAccessModeSchema, FanvueAppErrorCode, FanvueClient, FanvueEnv, FanvueEnvSchema, FanvueErrorBody, FanvueErrorBodySchema, FanvueErrorFieldBodySchema, FanvueIssueListErrorBodySchema, FanvueMessageErrorBodySchema, FanvueStringListErrorBodySchema, FanvueTheme, FanvueUser, FanvueUserSchema, HEADER_UPDATED_SESSION, HybridPagination, HybridPaginationSchema, JsonParseError, LogEvent, LogEventOptions, LogLevel, LogSink, MAX_PAGE_SIZE, MINIMUM_BEARER_SECRET_LENGTH, MachineAuthOptions, MachineAuthResult, NON_SESSION_401_CODES, NormalisedFanvueError, OAuthConfig, OAuthError, OAuthErrorBody, OAuthErrorBodySchema, OffsetPagination, OffsetPaginationSchema, PUBLISH_REQUEST_MESSAGE, PUBLISH_RESULT_MESSAGE, PublishRequestMessage, PublishRequestMessageSchema, PublishResultMessage, PublishResultMessageSchema, ReadinessCheck, ReadinessEnv, SafeLogFields, SafeLogValue, SentryScrubber, SessionPayload, SessionPayloadSchema, SessionVerifyError, SignedRequestVerifier, TokenResponse, TokenResponseSchema, UNPUBLISH_REQUEST_MESSAGE, UNPUBLISH_RESULT_MESSAGE, UnpublishRequestMessage, UnpublishRequestMessageSchema, UnpublishResultMessage, UnpublishResultMessageSchema, accessModeFromDenialReason, assertFanvueDomain, boundedBatchSize, clampPageSize, configurationReadiness, createAuthorizationUrl, createFanvueClient, createLogEvent, createSafeLogFields, createSentryScrubber, createSessionJwt, cursorPageSchema, errorName, exchangeCodeForToken, exchangeSessionToken, fanvueEnv, flagEnabled, getSessionTokenFromUrl, getThemeFromUrl, isFanvueConfigured, isFanvueOrigin, isPublishResultMessage, isUnpublishResultMessage, logEvent, offsetPageSchema, parseFanvueEnv, parseFanvueErrorBody, refreshAccessToken, requestAuthorizationCodeOnBehalf, requireMachineAuth, resetFanvueEnvCache, safeJsonParse, verifySessionJwt };

package/dist/core/index.js

@@ -1,3 +1,3 @@
-import "../schemas-DbyHF7Xi.js";
-import { C as HEADER_UPDATED_SESSION, S as BEARER_PREFIX, _ as DEFAULT_API_BASE_URL, a as requestAuthorizationCodeOnBehalf, b as DEFAULT_SCOPES, c as createAuthorizationUrl, d as AuthorizeOnBehalfResponseSchema, f as FanvueUserSchema, g as API_VERSION, h as safeJsonParse, i as getThemeFromUrl, l as exchangeCodeForToken, m as TokenResponseSchema, n as exchangeSessionToken, o as createSessionJwt, p as SessionPayloadSchema, r as getSessionTokenFromUrl, s as verifySessionJwt, t as createFanvueClient, u as refreshAccessToken, v as DEFAULT_ISSUER_URL, x as assertFanvueDomain, y as DEFAULT_PLATFORM_URL } from "../core-BqdYUMrJ.js";
-export { API_VERSION, AuthorizeOnBehalfResponseSchema, BEARER_PREFIX, DEFAULT_API_BASE_URL, DEFAULT_ISSUER_URL, DEFAULT_PLATFORM_URL, DEFAULT_SCOPES, FanvueUserSchema, HEADER_UPDATED_SESSION, SessionPayloadSchema, TokenResponseSchema, assertFanvueDomain, createAuthorizationUrl, createFanvueClient, createSessionJwt, exchangeCodeForToken, exchangeSessionToken, getSessionTokenFromUrl, getThemeFromUrl, refreshAccessToken, requestAuthorizationCodeOnBehalf, safeJsonParse, verifySessionJwt };
+import "../index.cjs-teGsk6HB.js";
+import { $ as FanvueStringListErrorBodySchema, A as OffsetPaginationSchema, B as UNPUBLISH_REQUEST_MESSAGE, C as FanvueUserSchema, D as DEFAULT_PAGE_SIZE, E as safeJsonParse, F as ExperienceMessageSchema, G as isPublishResultMessage, H as UnpublishRequestMessageSchema, I as PUBLISH_REQUEST_MESSAGE, J as FANVUE_APP_ERROR_CODES, K as isUnpublishResultMessage, L as PUBLISH_RESULT_MESSAGE, M as cursorPageSchema, N as offsetPageSchema, O as HybridPaginationSchema, P as EXPERIENCE_MESSAGE_TYPES, Q as FanvueMessageErrorBodySchema, R as PublishRequestMessageSchema, S as AuthorizeOnBehalfResponseSchema, T as TokenResponseSchema, U as UnpublishResultMessageSchema, V as UNPUBLISH_RESULT_MESSAGE, W as isFanvueOrigin, X as FanvueErrorFieldBodySchema, Y as FanvueErrorBodySchema, Z as FanvueIssueListErrorBodySchema, _ as createSessionJwt, _t as FANVUE_ACCESS_MODES, a as createLogEvent, at as flagEnabled, b as exchangeCodeForToken, bt as BEARER_PREFIX, c as logEvent, ct as resetFanvueEnvCache, d as requireMachineAuth, dt as DEFAULT_ISSUER_URL, et as NON_SESSION_401_CODES, f as createFanvueClient, ft as DEFAULT_PLATFORM_URL, g as requestAuthorizationCodeOnBehalf, gt as EXPERIENCE_ENTITLED_REASONS, h as getThemeFromUrl, ht as EXPERIENCE_DENIAL_REASONS, i as BASE_ALLOWED_LOG_KEYS, it as fanvueEnv, j as clampPageSize, k as MAX_PAGE_SIZE, l as MINIMUM_BEARER_SECRET_LENGTH, lt as API_VERSION, m as getSessionTokenFromUrl, mt as assertFanvueDomain, n as createSentryScrubber, nt as parseFanvueErrorBody, o as createSafeLogFields, ot as isFanvueConfigured, p as exchangeSessionToken, pt as DEFAULT_SCOPES, q as AppErrorEnvelopeSchema, r as configurationReadiness, rt as FanvueEnvSchema, s as errorName, st as parseFanvueEnv, t as BASE_SENSITIVE_KEY_PATTERN, tt as OAuthErrorBodySchema, u as boundedBatchSize, ut as DEFAULT_API_BASE_URL, v as verifySessionJwt, vt as FanvueAccessModeSchema, w as SessionPayloadSchema, x as refreshAccessToken, xt as HEADER_UPDATED_SESSION, y as createAuthorizationUrl, yt as accessModeFromDenialReason, z as PublishResultMessageSchema } from "../core-BhKiA55a.js";
+export { API_VERSION, AppErrorEnvelopeSchema, AuthorizeOnBehalfResponseSchema, BASE_ALLOWED_LOG_KEYS, BASE_SENSITIVE_KEY_PATTERN, BEARER_PREFIX, DEFAULT_API_BASE_URL, DEFAULT_ISSUER_URL, DEFAULT_PAGE_SIZE, DEFAULT_PLATFORM_URL, DEFAULT_SCOPES, EXPERIENCE_DENIAL_REASONS, EXPERIENCE_ENTITLED_REASONS, EXPERIENCE_MESSAGE_TYPES, ExperienceMessageSchema, FANVUE_ACCESS_MODES, FANVUE_APP_ERROR_CODES, FanvueAccessModeSchema, FanvueEnvSchema, FanvueErrorBodySchema, FanvueErrorFieldBodySchema, FanvueIssueListErrorBodySchema, FanvueMessageErrorBodySchema, FanvueStringListErrorBodySchema, FanvueUserSchema, HEADER_UPDATED_SESSION, HybridPaginationSchema, MAX_PAGE_SIZE, MINIMUM_BEARER_SECRET_LENGTH, NON_SESSION_401_CODES, OAuthErrorBodySchema, OffsetPaginationSchema, PUBLISH_REQUEST_MESSAGE, PUBLISH_RESULT_MESSAGE, PublishRequestMessageSchema, PublishResultMessageSchema, SessionPayloadSchema, TokenResponseSchema, UNPUBLISH_REQUEST_MESSAGE, UNPUBLISH_RESULT_MESSAGE, UnpublishRequestMessageSchema, UnpublishResultMessageSchema, accessModeFromDenialReason, assertFanvueDomain, boundedBatchSize, clampPageSize, configurationReadiness, createAuthorizationUrl, createFanvueClient, createLogEvent, createSafeLogFields, createSentryScrubber, createSessionJwt, cursorPageSchema, errorName, exchangeCodeForToken, exchangeSessionToken, fanvueEnv, flagEnabled, getSessionTokenFromUrl, getThemeFromUrl, isFanvueConfigured, isFanvueOrigin, isPublishResultMessage, isUnpublishResultMessage, logEvent, offsetPageSchema, parseFanvueEnv, parseFanvueErrorBody, refreshAccessToken, requestAuthorizationCodeOnBehalf, requireMachineAuth, resetFanvueEnvCache, safeJsonParse, verifySessionJwt };