@cross-deck/node 1.1.1 → 1.2.0

package/CHANGELOG.md

@@ -4,6 +4,44 @@ All notable changes to `@cross-deck/node` will be documented here. The
 format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/)
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.2.0] — 2026-05-18
+
+### Added
+
+- **Pluggable durable entitlement store (`entitlementStore`).** A new
+  constructor option taking an async `EntitlementStore` (a `load` /
+  `save` pair) — back it with Redis, your own database, or a KV. Every
+  successful `getEntitlements()` persists the result to it, and on a
+  network failure the SDK falls back to the stored snapshot. This is
+  what gives serverless deployments (Cloud Run / Lambda) cold-start
+  durability that an in-memory cache alone cannot. `EntitlementStore`
+  and `StoredEntitlements` are exported.
+- **Staleness fields in `diagnostics()`.** `entitlements.staleCustomers`,
+  `isStale`, `durableStore`, and `coldStartDurable` — so serving
+  last-known-good through a Crossdeck outage is observable, not silent.
+- **`sdk.no_durable_store` debug signal**, emitted once on a serverless
+  runtime with no `entitlementStore` configured, alongside a
+  `durability` fact on the boot telemetry event — so the cold-start gap
+  is measurable rather than a surprise in production.
+
+### Changed
+
+- **The entitlement cache is now durable last-known-good.**
+  `isEntitled()` and `list()` no longer expire to `false` / `[]` when
+  `entitlementCacheTtlMs` elapses — they keep serving the last
+  successfully-fetched entitlements. The TTL is now a refresh hint, not
+  an invalidation. Each entitlement is still honoured against its own
+  `validUntil`. A brief Crossdeck outage can no longer fail a paying
+  customer down to free 60 seconds after a warm.
+
+## [1.1.1] — 2026-05-14
+
+### Changed
+
+- Ported the "never silently surface an `Unknown` error" hardening to
+  `@cross-deck/node` — a captured error with no usable type or message
+  is now labelled precisely instead of collapsing to `Unknown error`.
+
 ## [1.1.0] — 2026-05-13
 
 ### Added

package/dist/auto-events/index.d.mts

@@ -1,4 +1,4 @@
-import { p as CrossdeckServer } from '../crossdeck-server-BXQaFjVx.mjs';
+import { p as CrossdeckServer } from '../crossdeck-server-BZVZEuS-.mjs';
 import 'node:events';
 
 /**

package/dist/auto-events/index.d.ts

@@ -1,4 +1,4 @@
-import { p as CrossdeckServer } from '../crossdeck-server-BXQaFjVx.js';
+import { p as CrossdeckServer } from '../crossdeck-server-BZVZEuS-.js';
 import 'node:events';
 
 /**

package/dist/{crossdeck-server-BXQaFjVx.d.mts → crossdeck-server-BZVZEuS-.d.mts}

@@ -221,6 +221,22 @@ interface RuntimeInfo {
     platformRelease: string;
     hostname: string;
     host: RuntimeHost;
+    /**
+     * Whether the host is a scale-to-zero / per-request-instance platform
+     * where a cold start begins with empty process memory.
+     *
+     * `true` for FaaS + serverless-container platforms (Lambda, Cloud
+     * Run, Firebase Functions v1/v2, Vercel, Netlify, Azure Functions,
+     * App Engine). `false` for long-lived process hosts (Heroku, Render,
+     * Railway, Fly, Kubernetes, plain Node) where the process — and thus
+     * the in-memory entitlement cache — persists across requests.
+     *
+     * The entitlement-cache durability layer reads this: a serverless
+     * host with no `entitlementStore` has no cold-start durability, and
+     * the SDK surfaces that explicitly (debug warning + a `durability`
+     * fact on the boot telemetry event).
+     */
+    isServerless: boolean;
     region: string | null;
     serviceName: string | null;
     serviceVersion: string | null;
@@ -236,7 +252,7 @@ interface RuntimeInfo {
 }
 
 declare const SDK_NAME = "@cross-deck/node";
-declare const SDK_VERSION = "1.1.0";
+declare const SDK_VERSION = "1.2.0";
 declare const DEFAULT_BASE_URL = "https://api.cross-deck.com/v1";
 declare const DEFAULT_TIMEOUT_MS = 15000;
 /**
@@ -310,6 +326,63 @@ interface EntitlementsListResponse {
     crossdeckCustomerId: string;
     env: Environment;
 }
+/**
+ * Snapshot of one customer's last-known-good entitlements, as written
+ * to / read from a durable `EntitlementStore`. Versioned for forward-
+ * compat — a future SDK can refuse a blob whose `v` it doesn't know.
+ *
+ * Carries enough to fully reconstruct an `EntitlementsListResponse` on
+ * a cold start (the durable read path in `getEntitlements()` rebuilds
+ * the response from this), plus `savedAt` so staleness is measurable
+ * after a process restart.
+ */
+interface StoredEntitlements {
+    v: 1;
+    /** Canonical Crossdeck customer ID this snapshot belongs to. */
+    crossdeckCustomerId: string;
+    /** The entitlement set exactly as the server last returned it. */
+    entitlements: PublicEntitlement[];
+    env: Environment;
+    /** Epoch ms of the successful server fetch that produced this snapshot. */
+    savedAt: number;
+}
+/**
+ * Pluggable async durable store for last-known-good entitlements.
+ *
+ * The Node SDK's entitlement cache is an in-memory per-customer `Map`.
+ * On serverless (Cloud Run / AWS Lambda) a cold start is an empty Map,
+ * and a brief Crossdeck outage during that window would otherwise read
+ * a paying customer as un-entitled. An `EntitlementStore` is the
+ * developer-supplied durability layer — Redis, their primary DB, a KV —
+ * that survives both a cold start and an outage.
+ *
+ * Contract:
+ *   - `load` returns the most recent snapshot for a customer, or `null`
+ *     if none exists. It MUST NOT throw for a missing key — return
+ *     `null`. (The SDK additionally guards every call in a try/catch,
+ *     but a well-behaved store returns `null`.)
+ *   - `save` persists a snapshot. Called only after a SUCCESSFUL server
+ *     fetch, so the store never holds anything but server-confirmed
+ *     truth.
+ *   - Both are awaited inside `getEntitlements()` (already async). They
+ *     are NEVER called from the synchronous `isEntitled()` — that stays
+ *     a pure in-memory `Map` read with zero I/O.
+ *   - The SDK swallows store errors: a failed `save` never fails a
+ *     successful fetch, a failed `load` degrades to "no durable copy".
+ *     A broken store weakens durability; it never breaks the SDK.
+ *
+ * The `key` passed to `load` / `save` is whatever identity string the
+ * caller used — a canonical `crossdeckCustomerId`, or a developer
+ * `userId` / `anonymousId` hint. The SDK saves a snapshot under every
+ * identity it knows for a customer so a cold-start `load` succeeds even
+ * before the in-memory alias map is populated.
+ */
+interface EntitlementStore {
+    /** Resolve a customer's last-known-good snapshot, or `null` if none. */
+    load(key: string): Promise<StoredEntitlements | null>;
+    /** Persist a customer's last-known-good snapshot. */
+    save(key: string, value: StoredEntitlements): Promise<void>;
+}
 interface AliasResult {
     object: "alias_result";
     crossdeckCustomerId: string;
@@ -462,8 +535,46 @@ interface CrossdeckServerOptions {
      *
      * Pass `0` to disable caching (every `isEntitled` requires a fresh
      * `getEntitlements()` call to populate the cache — useful for tests).
+     *
+     * NOTE: the TTL is a REFRESH HINT, not an invalidation. Once a
+     * customer is warm, `isEntitled()` keeps serving last-known-good past
+     * the TTL — a brief Crossdeck outage can never flip a paying customer
+     * to `false`. The TTL only tells `needsRefresh()` when a re-fetch is
+     * due, and (with no failed refresh) when the cache is flagged stale.
+     * Each entitlement's own `validUntil` is still honoured at read time.
      */
     entitlementCacheTtlMs?: number;
+    /**
+     * Age (ms) past which last-known-good entitlement data is flagged
+     * STALE in `diagnostics()` even with no failed refresh. Default 24h.
+     *
+     * Staleness never changes what `isEntitled()` returns — the cache
+     * keeps serving last-known-good. This window only makes "we have been
+     * serving an un-refreshed answer for a long time" observable, so an
+     * event-based revoke (chargeback / refund — which has no `validUntil`)
+     * riding out a long outage is visible instead of silent.
+     */
+    entitlementStaleAfterMs?: number;
+    /**
+     * Durable last-known-good store for entitlements. Optional.
+     *
+     * The entitlement cache is in-memory. On serverless (Cloud Run /
+     * Lambda) every cold start begins with an empty cache — and if
+     * Crossdeck is briefly unreachable during that window, a paying
+     * customer would read as un-entitled. Wiring an `EntitlementStore`
+     * (Redis / your DB / a KV) closes that gap: every successful
+     * `getEntitlements()` persists the result, and a network failure
+     * falls back to the stored snapshot instead of throwing.
+     *
+     * Without a store on a serverless host the SDK has NO cold-start
+     * durability — that is unavoidable and the SDK says so explicitly
+     * (a `debug.emit` warning plus a `durability` fact on the boot
+     * telemetry event). It is not hidden.
+     *
+     * `isEntitled()` stays synchronous regardless — the store is only
+     * ever touched from the already-async `getEntitlements()`.
+     */
+    entitlementStore?: EntitlementStore;
     /**
      * Service name for runtime enrichment. Attached to every event + error
      * as `properties.serviceName`. Default: env-detected via
@@ -674,6 +785,32 @@ interface Diagnostics {
         ttlMs: number;
         /** Cumulative count of listener invocations that threw. Swallowed inside the cache; surfaced here. */
         listenerErrors: number;
+        /**
+         * Number of cached customers currently flagged STALE — their most
+         * recent refresh attempt failed, or their data has aged past
+         * `entitlementStaleAfterMs`. The cache keeps serving last-known-good
+         * for them; this count makes "serving through an outage" observable.
+         */
+        staleCustomers: number;
+        /**
+         * Whether ANY cached customer is stale. Quick boolean for health
+         * checks / alerting without inspecting `staleCustomers`.
+         */
+        isStale: boolean;
+        /**
+         * Most recent failed-refresh timestamp across all customers (epoch
+         * ms), or 0 if every customer's last refresh succeeded.
+         */
+        lastRefreshFailedAt: number;
+        /**
+         * Durable-store posture. `durableStore` is true iff an
+         * `EntitlementStore` is configured. `coldStartDurable` is true iff
+         * the SDK has cold-start durability — which on a serverless host
+         * requires a store, and on a long-lived host is inherently true
+         * (the process, hence the in-memory cache, survives).
+         */
+        durableStore: boolean;
+        coldStartDurable: boolean;
     };
     events: {
         buffered: number;
@@ -844,8 +981,8 @@ interface GroupMembership {
 }
 
 /**
- * Per-customer entitlement cache with TTL — the third Crossdeck USP
- * on the server.
+ * Per-customer durable last-known-good entitlement cache — the third
+ * Crossdeck USP on the server.
  *
  * Why this exists: server-side gating code looks like
  *
@@ -856,29 +993,68 @@ interface GroupMembership {
  * per request, every request, for every customer. The cache makes
  * `isEntitled()` a `Map.get()` after the first warm.
  *
- * Differences from `@cross-deck/web/src/entitlement-cache.ts`:
+ * Durability contract (mirrors `@cross-deck/web/src/entitlement-cache.ts`,
+ * adapted for a multi-tenant server):
+ *   - This cache is NOT a second source of truth. Crossdeck remains the
+ *     only source; this is the SDK's local copy of what the server last
+ *     told us — a cache that does not forget during a network partition.
+ *   - Only a SUCCESSFUL fetch replaces a customer's entry (via
+ *     `setForCustomer`). A failed refresh never reaches it, so an outage
+ *     can never fail a paying customer down to free.
+ *   - **The TTL is a REFRESH HINT, not an invalidation.** `isEntitled()`
+ *     and `list()` keep serving last-known-good after `ttlMs` elapses —
+ *     they do NOT return `false` / `[]` because the entry aged. The TTL
+ *     only drives `needsRefresh()` ("a re-fetch is due") and, with no
+ *     failed refresh, the stale flag. This is the central fix: on
+ *     serverless a paying customer must not be locked out 60s after a
+ *     warm just because Crossdeck was briefly unreachable.
+ *   - Staleness alone never returns false. Each entitlement is honoured
+ *     against its OWN `validUntil` instead — a time-based trial expiry
+ *     still applies even mid-partition; a still-valid Pro entitlement
+ *     rides the outage out.
+ *   - Staleness is VISIBLE, not silent. `validUntil` covers time-based
+ *     expiry; it does NOT cover an event-based revoke (chargeback,
+ *     refund, fraud) — that has no `validUntil`, so the cache would keep
+ *     serving a revoked customer through an outage. Serving them is the
+ *     right trade (don't lock real payers out), but unbounded-and-
+ *     invisible is the bug. So once a refresh ATTEMPT fails
+ *     (`markRefreshFailed`) or the data ages past `staleAfterMs`, the
+ *     customer is flagged stale — `isStale()` / `staleCustomerCount` are
+ *     surfaced in `diagnostics()`. It keeps serving last-known-good; the
+ *     staleness is just no longer hidden.
+ *
+ * Cold-start durability lives one layer up: `getEntitlements()` in
+ * `crossdeck-server.ts` persists every successful fetch to an optional
+ * `EntitlementStore` and, on a network failure, loads last-known-good
+ * back from it and into this cache. This cache stays a pure in-memory
+ * structure with NO I/O — `isEntitled()` is and remains synchronous.
+ *
+ * Differences from the web SDK's cache:
  *   - **Per-customer**, not singleton. Web SDK has one user per browser
  *     tab; Node SDK has many users hitting one server. The cache is
- *     keyed by `crossdeckCustomerId`.
- *   - **TTL-bounded**. Each customer's entry expires after `ttlMs`
- *     (default 60_000) and the next read returns `false` until
- *     `getEntitlements()` refreshes. Stripe + Mixpanel ship the same
- *     pattern server-side.
+ *     keyed by `crossdeckCustomerId`. Staleness, freshness and the
+ *     failed-refresh marker are therefore all per-customer too.
+ *   - **No synchronous storage hydration** in the constructor. The web
+ *     SDK hydrates from `localStorage` on boot; the Node durable store
+ *     is async, so hydration happens lazily inside `getEntitlements()`.
+ *   - **LRU-bounded** by `maxCustomers` — a long-running multi-tenant
+ *     server would otherwise leak Map entries forever.
  *   - **Subscriber API unchanged** — `subscribe(listener)` fires after
- *     any mutation (set / clear / per-customer expiry-driven eviction
- *     is NOT considered a mutation, by design — listeners shouldn't
- *     re-render just because a TTL elapsed).
- *
- * The cache holds only ACTIVE entitlements — `setForCustomer` filters.
- * `isEntitled()` returns `false` when:
- *   - the customer has no cached entry
- *   - the entry has expired
- *   - the requested key isn't in the active set
+ *     any mutation (set / clear). Passive LRU eviction and a TTL
+ *     elapsing are NOT mutations, by design.
  */
 
 type EntitlementsListener = (customerId: string, entitlements: PublicEntitlement[]) => void;
 interface EntitlementCacheOptions {
-    /** TTL in ms. Default 60_000 (60s). 0 disables caching (every read is cold). */
+    /**
+     * Refresh-hint TTL in ms. Default 60_000 (60s).
+     *
+     * After `ttlMs` a customer's entry is "refresh due" — `needsRefresh()`
+     * returns true and the caller should re-fetch. It is NOT an expiry:
+     * `isEntitled()` keeps serving last-known-good past it. `0` makes
+     * every entry immediately refresh-due (useful for tests) but STILL
+     * does not invalidate — last-known-good is served regardless.
+     */
     ttlMs?: number;
     /**
      * Maximum number of customers cached at once. Long-running multi-tenant
@@ -889,6 +1065,16 @@ interface EntitlementCacheOptions {
      * (passive eviction is not a mutation by design).
      */
     maxCustomers?: number;
+    /**
+     * Age (ms) past which a customer's last-known-good data is flagged
+     * STALE even with no failed refresh. Default 24h.
+     *
+     * Staleness never changes what `isEntitled()` returns; it only makes a
+     * long un-refreshed window observable via `isStale()` / diagnostics —
+     * so an event-based revoke (no `validUntil`) riding out an outage is
+     * visible instead of silent.
+     */
+    staleAfterMs?: number;
 }
 
 /**
@@ -995,6 +1181,16 @@ declare class CrossdeckServer extends EventEmitter {
     private readonly flushOnExit;
     private readonly superProps;
     private readonly entitlementCache;
+    /**
+     * Optional developer-supplied durable store for last-known-good
+     * entitlements (Redis / their DB / a KV). `undefined` when not
+     * configured — the SDK then has no cold-start durability on
+     * serverless, which it states explicitly at boot.
+     *
+     * Touched ONLY from the async `getEntitlements()` — never from the
+     * synchronous `isEntitled()`.
+     */
+    private readonly entitlementStore;
     private readonly debug;
     /**
      * Alias map — `developerUserId` / `anonymousId` → canonical
@@ -1014,9 +1210,58 @@ declare class CrossdeckServer extends EventEmitter {
     private errorTags;
     private errorBeforeSend;
     constructor(options: CrossdeckServerOptions);
+    /**
+     * Emit the one-time `sdk.boot` telemetry event and, when the runtime
+     * is serverless with no `entitlementStore`, the honest "no cold-start
+     * durability" warning.
+     *
+     * Why a `track()` event and not the heartbeat: `GET /v1/sdk/heartbeat`
+     * carries no request body, so it cannot transport a structured
+     * `durability` fact. The event pipeline can — every `track()` event
+     * lands as an aggregatable document the backend can query, so
+     * Crossdeck can compute fleet-wide "% serverless-with-no-durable-
+     * store" from `sdk.boot` events (denominator = all `sdk.boot`,
+     * numerator = those with `durability.coldStartDurable === false`).
+     * The event rides the existing batched + retried + idempotent queue
+     * and is drained by flush-on-exit, so it survives a serverless
+     * teardown — it is NOT a local-only debug log.
+     *
+     * `isServerless` AND no store is the gap: a cold start begins with an
+     * empty in-memory cache and a brief Crossdeck outage in that window
+     * would read a paying customer as un-entitled. That gap is
+     * unavoidable without a store — so the SDK STATES it (a
+     * `sdk.no_durable_store` debug warning) rather than hiding it.
+     *
+     * Called once, from the deferred boot block — so it inherits the
+     * `testMode` / `bootHeartbeat:false` opt-outs and never fires before
+     * the constructor returns.
+     */
+    private emitBootTelemetry;
     identify(userId: string, anonymousId: string, options?: IdentifyOptions & RequestOptions): Promise<AliasResult>;
     aliasIdentity(input: AliasIdentityInput, options?: RequestOptions): Promise<AliasResult>;
     forget(hints: IdentityHints, options?: RequestOptions): Promise<ForgetResult>;
+    /**
+     * Fetch a customer's entitlements from Crossdeck and warm the cache.
+     *
+     * Durability — this is where last-known-good lives, NOT in the
+     * synchronous `isEntitled()`:
+     *   - On a SUCCESSFUL fetch: the entitlement cache is populated and,
+     *     if an `entitlementStore` is configured, the result is persisted
+     *     to it (`await store.save(...)`). The cache + store now hold
+     *     server-confirmed truth.
+     *   - On a network FAILURE: the cache is marked refresh-failed for the
+     *     customer (so `diagnostics()` shows the staleness), then — if a
+     *     store is configured — last-known-good is loaded back from it
+     *     (`await store.load(...)`). If the store yields a snapshot, the
+     *     cache is populated from it and that snapshot is RETURNED as a
+     *     normal `EntitlementsListResponse` — a cold-start / outage no
+     *     longer fails a paying customer. If there is no store, or the
+     *     store is empty, the network error is rethrown unchanged so the
+     *     caller still sees the failure.
+     *
+     * The store is touched only here, inside the `await` that already
+     * existed. `isEntitled()` remains a pure synchronous `Map` read.
+     */
     getEntitlements(hints: IdentityHints, options?: RequestOptions): Promise<EntitlementsListResponse>;
     getCustomerEntitlements(customerId: string, options?: RequestOptions): Promise<EntitlementsListResponse>;
     /**
@@ -1389,6 +1634,44 @@ declare class CrossdeckServer extends EventEmitter {
      * with the entitlement cache's max-customers cap.
      */
     private populateEntitlementCache;
+    /**
+     * Persist a successful entitlements fetch to the durable store, if
+     * one is configured. No-op when there is no store.
+     *
+     * Saved under EVERY identity the caller might later look up by — the
+     * canonical `crossdeckCustomerId` plus any `userId` / `anonymousId`
+     * hint. The Node cache resolves a hint to a canonical ID via an
+     * in-memory alias map; on a cold start that map is empty, so a
+     * failure-path `load()` must be able to hit the store with the raw
+     * hint the caller passed. Saving under all keys makes that work.
+     *
+     * Best-effort: a store `save()` that throws is swallowed (logged in
+     * debug) — it weakens durability for that customer but must never
+     * fail an otherwise-successful `getEntitlements()`.
+     */
+    private saveEntitlementsToStore;
+    /**
+     * Load last-known-good entitlements from the durable store on a
+     * network-failure path. Returns the first snapshot found across the
+     * caller's identity keys, or `null` if there is no store / no stored
+     * snapshot / every read failed.
+     *
+     * Tries the canonical `customerId` hint first, then `userId`, then
+     * `anonymousId` — the order callers most commonly key by. A corrupt
+     * or wrong-shaped blob is treated as a miss (the store is developer-
+     * supplied; the SDK validates rather than trusts).
+     */
+    private loadEntitlementsFromStore;
+    /**
+     * Resolve the customer ID to stamp a failed-refresh marker against.
+     *
+     * Prefers a canonical ID the cache already knows (so the marker lands
+     * on the existing warm entry), then falls back to whatever raw hint
+     * the caller supplied — on a true cold-start failure there is no
+     * cache entry yet, and marking under the hint still makes "we tried
+     * for this customer and Crossdeck was down" observable.
+     */
+    private resolveFailedRefreshCustomerId;
     private touchAlias;
     /**
      * Resolve any hint shape (canonical customerId / userId hint /
@@ -1411,4 +1694,4 @@ declare class CrossdeckServer extends EventEmitter {
     private normalizeIngestEvent;
 }
 
-export { type StackFrame as $, type AliasIdentityInput as A, type Breadcrumb as B, CROSSDECK_API_VERSION as C, DEFAULT_BASE_URL as D, type EntitlementCacheOptions as E, type EventProperties as F, type ForgetResult as G, type GrantDuration as H, type GrantEntitlementInput as I, type GroupMembership as J, type HeartbeatResponse as K, type HttpRequestInfo as L, type HttpResponseInfo as M, type HttpRetriesConfig as N, type IdentifyOptions as O, type IdentityHints as P, type IngestOptions as Q, type IngestResponse as R, type PublicEntitlement as S, type PurchaseResult as T, type RequestOptions as U, type RevokeEntitlementInput as V, type RuntimeHost as W, type RuntimeInfo as X, SDK_NAME as Y, SDK_VERSION as Z, type ServerEvent as _, type AliasResult as a, type SyncPurchaseInput as a0, makeCrossdeckError as a1, type AuditDecision as b, type AuditEntry as c, type BreadcrumbCategory as d, type BreadcrumbLevel as e, type CapturedError as f, CrossdeckAuthenticationError as g, CrossdeckConfigurationError as h, CrossdeckError as i, type CrossdeckErrorPayload as j, type CrossdeckErrorType as k, CrossdeckInternalError as l, CrossdeckNetworkError as m, CrossdeckPermissionError as n, CrossdeckRateLimitError as o, CrossdeckServer as p, type CrossdeckServerOptions as q, CrossdeckValidationError as r, DEFAULT_TIMEOUT_MS as s, type Diagnostics as t, type EntitlementMutationResult as u, type EntitlementsListResponse as v, type EntitlementsListener as w, type Environment as x, type ErrorCaptureConfig as y, type ErrorLevel as z };
+export { type ServerEvent as $, type AliasIdentityInput as A, type Breadcrumb as B, CROSSDECK_API_VERSION as C, DEFAULT_BASE_URL as D, type EntitlementCacheOptions as E, type ErrorLevel as F, type EventProperties as G, type ForgetResult as H, type GrantDuration as I, type GrantEntitlementInput as J, type GroupMembership as K, type HeartbeatResponse as L, type HttpRequestInfo as M, type HttpResponseInfo as N, type HttpRetriesConfig as O, type IdentifyOptions as P, type IdentityHints as Q, type IngestOptions as R, type IngestResponse as S, type PublicEntitlement as T, type PurchaseResult as U, type RequestOptions as V, type RevokeEntitlementInput as W, type RuntimeHost as X, type RuntimeInfo as Y, SDK_NAME as Z, SDK_VERSION as _, type AliasResult as a, type StackFrame as a0, type StoredEntitlements as a1, type SyncPurchaseInput as a2, makeCrossdeckError as a3, type AuditDecision as b, type AuditEntry as c, type BreadcrumbCategory as d, type BreadcrumbLevel as e, type CapturedError as f, CrossdeckAuthenticationError as g, CrossdeckConfigurationError as h, CrossdeckError as i, type CrossdeckErrorPayload as j, type CrossdeckErrorType as k, CrossdeckInternalError as l, CrossdeckNetworkError as m, CrossdeckPermissionError as n, CrossdeckRateLimitError as o, CrossdeckServer as p, type CrossdeckServerOptions as q, CrossdeckValidationError as r, DEFAULT_TIMEOUT_MS as s, type Diagnostics as t, type EntitlementMutationResult as u, type EntitlementStore as v, type EntitlementsListResponse as w, type EntitlementsListener as x, type Environment as y, type ErrorCaptureConfig as z };