@fanvue/builder-sdk 0.3.0 → 0.5.0

package/README.md

@@ -6,7 +6,7 @@ this SDK covers both:
 
 | Building an... | Import | What you get | Docs |
 |---|---|---|---|
-| **Embedded App** (runs inside Fanvue, in an iframe) | `@fanvue/builder-sdk/nextjs/embedded-app` + `@fanvue/builder-sdk/react` | Session-token exchange handler, `useEmbeddedAuth` hook, Bearer sessions with auto refresh | [Overview](https://api.fanvue.com/docs/app-store/embedded-apps/overview) · [Integration guide](https://api.fanvue.com/docs/app-store/embedded-apps/integration-guide) |
+| **Embedded App** (runs inside Fanvue, in an iframe) | `@fanvue/builder-sdk/nextjs/embedded-app` + `@fanvue/builder-sdk/react` | Session-token exchange handler, `useEmbeddedAuth` hook, Bearer sessions with auto refresh, analytics through the host page | [Overview](https://api.fanvue.com/docs/app-store/embedded-apps/overview) · [Integration guide](https://api.fanvue.com/docs/app-store/embedded-apps/integration-guide) |
 | **Off-Platform App** ("Login with Fanvue" on your own domain) | `@fanvue/builder-sdk/nextjs/off-platform` | Full-page redirect flow, httpOnly cookie sessions, auto token refresh | [Auth overview](https://api.fanvue.com/docs/authentication/overview) · [Implementation guide](https://api.fanvue.com/docs/authentication/implementation-guide) |
 
 Building something else (Node, Deno, a custom server)? The core `@fanvue/builder-sdk`
@@ -138,6 +138,70 @@ export const { POST } = createSessionExchangeHandler(createConfig(), {
 See the [embedded apps integration guide](https://api.fanvue.com/docs/app-store/embedded-apps/integration-guide)
 for the full walkthrough, including app registration in the Builder.
 
+### Analytics (embedded apps)
+
+Embedded apps can fire product analytics through the Fanvue page hosting them,
+so events land in Fanvue's analytics stitched into the viewer's session --
+without your app ever handling identity data.
+
+```tsx
+"use client";
+import { useFanvueAnalytics } from "@fanvue/builder-sdk/react";
+
+export function CreateCourseButton() {
+  const { track } = useFanvueAnalytics();
+  return <button onClick={() => track("course_created", { chapters: 4 })}>Create course</button>;
+}
+```
+
+That is the whole integration -- no provider, no configuration. `track` is
+fire-and-forget: it never throws, and outside Fanvue (local dev, previews, a
+standalone deployment) it silently does nothing, so you can call it
+unconditionally.
+
+**Rules your events must follow:**
+
+- Event names match `/^[a-z0-9_]{1,64}$/`. Fanvue emits them prefixed with
+  `embedded_app_`, so `course_created` arrives as `embedded_app_course_created`,
+  attributed to your app automatically.
+- Properties are a flat record of at most 20 keys (max 64 characters each) with
+  `string` (max 256 characters), `number` or `boolean` values. No nesting.
+- Identity is Fanvue's to set: `user_id`, `device_id`, `revenue` and any
+  `$`-prefixed key are rejected.
+
+Analytics is granted per app by Fanvue, so `track` may legitimately be a no-op
+for your app. `isEnabled` tells you which:
+
+```tsx
+const { track, isEnabled } = useFanvueAnalytics();
+```
+
+**Outside React**, connect to the bridge directly:
+
+```ts
+import { connectFanvueBridge } from "@fanvue/builder-sdk/bridge";
+
+const result = await connectFanvueBridge();
+if (result.isOk() && result.value.has("analytics")) {
+  await result.value.analytics.track("course_created", { chapters: 4 });
+}
+```
+
+`connectFanvueBridge` handshakes with the host page: your app announces itself,
+Fanvue verifies your registered embed origin and replies with the capabilities
+it granted plus a private `MessagePort` carrying all further traffic. It fails
+with `NOT_EMBEDDED` when the app is not in an iframe and `TIMEOUT` when no
+`hello` arrives within the timeout (default 3s) -- neither is exceptional, and
+apps are expected to keep working standalone.
+
+> [!NOTE]
+> Host support for the bridge is being rolled out per environment. Until it is
+> enabled for the environment your app is running in, the handshake times out
+> and every `track` call no-ops -- exactly as it does outside Fanvue. So a
+> timeout does not necessarily mean your app is misconfigured. If events are not
+> arriving from a live embedded surface, confirm the bridge is enabled there
+> before you go looking for a bug in your integration.
+
 ### Off-Platform App ("Login with Fanvue")
 
 The fastest path: create a config file and three route handlers.
@@ -284,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:
@@ -317,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:
@@ -338,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`)
@@ -356,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
 
@@ -371,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`)
 
@@ -387,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 |
@@ -400,6 +748,18 @@ Error types: `OAuthError` (token exchange/refresh), `EmbeddedAuthError` (delegat
 | `AuthProvider` | Context provider. Manages JWT storage in `sessionStorage`. |
 | `useAuth()` | Returns `{ jwt, isAuthenticated, setJwt, clearJwt, authFetch }` |
 | `useEmbeddedAuth(opts?)` | Returns `{ status, error, theme }`. Exchanges the embedded session token on mount; `theme` is the creator's colour scheme (`'light' \| 'dark' \| null`). |
+| `useFanvueAnalytics()` | Returns `{ track, isEnabled }`. Fires events through the host page; no-ops outside Fanvue. |
+
+### Bridge (`@fanvue/builder-sdk/bridge`)
+
+The host-to-app capability protocol. Most apps only need `useFanvueAnalytics`.
+
+| Export | Description |
+|---|---|
+| `connectFanvueBridge(opts?)` | Handshakes with the host page. Returns `Result<FanvueBridge, BridgeConnectError>` (`NOT_EMBEDDED` or `TIMEOUT`) |
+| `FanvueBridge` | `{ capabilities, has(capability), analytics.track(eventName, properties?) }` |
+| `analyticsTrackPayloadSchema` | Zod schema for the `analytics.track` payload -- the same schema the host validates against |
+| Protocol constants and schemas | `BRIDGE_VERSION`, `BRIDGE_READY_TYPE`, `BRIDGE_HELLO_TYPE`, `bridgeRequestSchema`, `bridgeResponseSchema` |
 
 ## Examples
 

package/dist/bridge/index.d.ts

@@ -0,0 +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-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

@@ -0,0 +1,3 @@
+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 };