@uengage.io/platform-sdk 2.1.0 → 2.3.0

package/README.md

@@ -33,6 +33,7 @@ const { balance, balanceMinor, currency } = await wallet.getBalance();
 // wallet.debit({ referenceId, amountMinor, service: Services.FLASH_DELIVERY, description }) — idempotent on referenceId
 // wallet.credit({ ..., reversalOf }) refund capped by that debit; ({ ..., isRefund: true }) uncapped
 // wallet.listTransactions({...}); wallet.getTransaction(id)
+// wallet.getOverview() — wallet balance or credit line? See Wallet client below.
 // Legacy-ledger passthroughs, written as top-level ledger fields:
 //   taskId, rto (debit), units, serviceBaseCost, paymentId (credit), updatedBy,
 //   occurredAt — IST 'YYYY-MM-DD HH:mm:ss', dates the CHARGE not the write
@@ -229,6 +230,158 @@ const many = await client.business.bulk([123, 124], { groups: ['profile'] });
 - The `profile` group (just `name`) is public; other groups need
   matching `business.<group>:read` capability for the calling service id.
 
+## Wallet client
+
+`getWallet(...)` is a lightweight handle — no I/O. The wallet is resolved
+server-side on the first operation, so a routing miss surfaces from the
+operation, not from `getWallet()`.
+
+### Which billing model? — start here
+
+Prepaid wallets and merchant credit lines coexist, and which one a
+merchant is on decides what a dashboard renders and which calls are even
+legal. `getOverview()` settles it with a discriminated union:
+
+```ts
+const o = await wallet.getOverview();
+
+if (o.mode === 'credit') {
+  o.creditLine.limit; // { amount, amountMinor } — net of GST
+  o.creditLine.band; // 'normal' | 'warning' | 'critical' | 'blocked'
+} else {
+  o.balance.balanceMinor; // prepaid: the wallet balance
+}
+```
+
+- `balance` is on **both** arms and means the same thing either way: what
+  the merchant can still spend. Available credit on the credit arm.
+- One request for a prepaid merchant, two for a credit one, and never a
+  404 on the happy path — it reads `getBalance().source` rather than
+  calling `getCreditLine()` and catching its 404, which would make the
+  normal state of a prepaid merchant an error on every page load.
+- A wallet service older than the credit line (no `source`) reads as
+  prepaid rather than throwing.
+- **The credit arm needs `wallet.credit:read` on top of
+  `wallet.balance:read`.** A token with only the latter gets a
+  `WalletApiError` with `status === 403` from the second call — not a
+  fallback to `prepaid`, which would render the frozen `wallet_balance`
+  these merchants no longer spend from.
+- Not a guaranteed 200: `WalletNotFoundError` (no wallet document for the
+  resolved identity) and `UnresolvableWalletError` (routing cannot name
+  one) both propagate, because both mean there is nothing to render.
+
+### Credit line
+
+The ceiling is per **merchant**, not per wallet, so an outlet's id and its
+parent's id return the same line.
+
+```ts
+const line = await wallet.getCreditLine(); // 404 CreditLineNotFoundError if prepaid
+line.consumed; //  net, UNPAID — spans months, not a calendar figure
+line.available; //  limit − consumed
+line.estimatedInvoice.total; //  exact, from recorded GST — not consumed × 1.18
+
+await wallet.setCreditLimit({
+  referenceId: 'admin:limit:1200:2026-09-02', // idempotency key
+  limitMinor: 10_000_000, // ₹1,00,000, NET of GST; 0 blocks
+  onBehalfOf: 'user:4471', // required — the trail names the human
+  reason: 'Q3 volume increase',
+  // enabled: false → take them off the credit line
+});
+
+await wallet.settleInvoice({
+  invoiceRef: 'invoice:2026-04:88213', // idempotency key
+  netMinor: 500_000, // the NET figure — what frees credit
+  gstMinor: 90_000, // recorded, not released
+  onBehalfOf: 'user:9',
+});
+await wallet.reverseSettlement({ invoiceRef: '…', onBehalfOf: 'user:9' });
+// Correcting a settled amount: reverse, then settle again with the right
+// figures AND a `reason` — different figures on a reversed invoice
+// release against the merchant's whole outstanding consumption, so the
+// service requires the correction to say what it is correcting.
+
+await wallet.listCreditEvents(); // limit changes + settlements, newest first
+await wallet.listCreditEvents({ limit: 200 }); // the service defaults to 50
+await client.wallet.getCreditUtilisation({ band: 'warning' }); // cross-merchant
+```
+
+- **Charges on a credit-line merchant must carry `breakup`** — consumption
+  is tracked net of GST, so a missing split is
+  `CreditBreakupRequiredError` rather than a guessed rate. `allowNegative`
+  is refused (`CreditOverrideRefusedError`): it disables the balance guard
+  for migration paths, and on a credit line it would disable the limit.
+- **The merchant pays gross; settlement releases net.** A ₹5,900 invoice
+  on ₹5,000 of consumption frees ₹5,000. Passing gross hands back 18% too
+  much — and it looks right in a test, since both figures sit on the same
+  invoice row.
+- **Setting a limit never touches consumption**, so raising one hands back
+  exactly the difference. Lowering below what is consumed blocks charges
+  immediately.
+- **`enabled: false` is refused while the merchant owes** —
+  `CreditLineHasOutstandingError`, carrying `consumedMinor` so you can say
+  how much to settle. Disabling moves them back to a wallet balance, which
+  with a balance owed abandons it. To _stop_ a merchant trading use
+  `limitMinor: 0`; to move them _off_, settle first.
+- Reusing an idempotency key with **different** figures is
+  `CreditIdempotencyConflictError`, not a silent replay. To correct a
+  settled amount, reverse it and settle again rather than inventing a new
+  ref — a new ref leaves the original settlement standing.
+- **A plain `credit()` is refused** — `CreditTopUpRefusedError`. These
+  merchants have no balance to top up: `wallet_balance` is the fiction the
+  line replaces and is frozen, so the write would move nothing while
+  answering 201. Credit comes back through `settleInvoice`. A genuine
+  refund is accepted — send `reversalOf` or `isRefund` and it releases
+  what the original charge consumed.
+- `getCreditUtilisation` hangs off the **client**, not a wallet handle: it
+  is the one wallet call not scoped to a business.
+
+### Errors
+
+All extend `WalletApiError` (`.status`, `.body`).
+
+`CreditLimitReachedError` carries `limitMinor` / `consumedMinor` /
+`availableMinor` / `requestedMinor`, and that is the point of it — three
+situations share the code and need different merchant copy:
+
+```ts
+if (e instanceof CreditLimitReachedError) {
+  if (e.availableMinor === undefined) {
+    // No figures in the response (trimmed or proxied body) — generic
+    // copy. Not the same as 0, which is the "used up" sentinel below.
+  } else if (e.availableMinor > 0) {
+    // Limit NOT used up — this one charge is larger than what is left.
+    // A smaller order would go through; do not send them to their KAM.
+  }
+  // Otherwise the ceiling is reached — which can be unpaid invoices
+  // rather than this month's spend. getCreditLine() tells you which.
+}
+```
+
+The figures are optional for that reason: coercing an absent
+`availableMinor` to `0` would silently claim the limit is used up.
+
+Also: `CreditLineNotFoundError` (404 — a prepaid merchant, not a
+failure), `CreditBreakupRequiredError`, `CreditOverrideRefusedError`,
+`CreditTopUpRefusedError`, `CreditIdempotencyConflictError`,
+`CreditCorrectionReasonRequiredError` (400 — a reversed invoice is being
+re-settled for different figures; pass `reason`),
+`CreditCurrencyConflictError` and `CreditCurrencyMismatchError` (409 —
+neither is caller-retryable; see their docblocks),
+`SettlementNotFoundError`, plus the
+pre-existing `InsufficientBalanceError`, `OverRefundError`,
+`InvalidReversalError`, `IdempotencyConflictError`,
+`WalletIdentityMismatchError`, `UnresolvableWalletError`,
+`WalletNotFoundError`.
+
+### Money
+
+Every figure is `{ amount, amountMinor }`. **Compute in `amountMinor`**
+(integer paise); `amount` is for display. On a ledger row `amount` is
+**gross** and `breakup.subTotalMinor` is what consumed the ceiling —
+`creditMerchantId` present means the row's `balanceBefore`/`balanceAfter`
+are available credit rather than a wallet balance.
+
 ## Auth helpers
 
 ```ts

package/dist/auth/issuer.js

@@ -3,40 +3,55 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getIssuer = getIssuer;
 exports.getExpiry = getExpiry;
 /**
- * Decode (without verifying) a JWT and return its `iss` claim. Used by
- * the SDK to route subsequent auth-related calls (refresh, future
- * logout) at `${iss}/...`, so tokens from different issuers are
- * routed correctly when customer-auth ships alongside business-auth.
+ * Base64url-decode a JWT segment, in Node and in a browser.
+ *
+ * `Buffer` is a Node global. In a browser or React Native it is simply not
+ * defined, and touching it throws a ReferenceError rather than yielding
+ * undefined — which the callers below used to swallow, so every expiry read
+ * silently returned null off-Node. That mattered once a browser-reachable
+ * token source started caching against `exp`: the cache fell back to a flat
+ * five minutes and nothing said why. `atob` covers those runtimes.
  */
-function getIssuer(token) {
+function decodeSegment(segment) {
+    const base64 = segment.replace(/-/g, '+').replace(/_/g, '/');
+    const padded = base64.padEnd(base64.length + ((4 - (base64.length % 4)) % 4), '=');
+    if (typeof Buffer !== 'undefined') {
+        return Buffer.from(padded, 'base64').toString('utf8');
+    }
+    // atob yields one byte per character; re-decode as UTF-8 so a non-ASCII
+    // claim (a merchant name, say) does not come back mojibake.
+    const binary = atob(padded);
+    const bytes = Uint8Array.from(binary, (ch) => ch.charCodeAt(0));
+    return new TextDecoder().decode(bytes);
+}
+function claimsOf(token) {
     const parts = token.split('.');
     if (parts.length !== 3)
         return null;
     try {
-        const payload = parts[1].replace(/-/g, '+').replace(/_/g, '/');
-        const padded = payload.padEnd(payload.length + ((4 - (payload.length % 4)) % 4), '=');
-        const json = Buffer.from(padded, 'base64').toString('utf8');
-        const claims = JSON.parse(json);
-        return typeof claims.iss === 'string' ? claims.iss : null;
+        return JSON.parse(decodeSegment(parts[1]));
     }
     catch {
         return null;
     }
 }
+/**
+ * Decode (without verifying) a JWT and return its `iss` claim. Used by
+ * the SDK to route subsequent auth-related calls (refresh, future
+ * logout) at `${iss}/...`, so tokens from different issuers are
+ * routed correctly when customer-auth ships alongside business-auth.
+ */
+function getIssuer(token) {
+    const claims = claimsOf(token);
+    if (!claims)
+        return null;
+    return typeof claims.iss === 'string' ? claims.iss : null;
+}
 /** Decode (without verifying) a JWT and return its `exp` claim (unix seconds). */
 function getExpiry(token) {
-    const parts = token.split('.');
-    if (parts.length !== 3)
+    const claims = claimsOf(token);
+    if (!claims)
         return null;
-    try {
-        const payload = parts[1].replace(/-/g, '+').replace(/_/g, '/');
-        const padded = payload.padEnd(payload.length + ((4 - (payload.length % 4)) % 4), '=');
-        const json = Buffer.from(padded, 'base64').toString('utf8');
-        const claims = JSON.parse(json);
-        return typeof claims.exp === 'number' ? claims.exp : null;
-    }
-    catch {
-        return null;
-    }
+    return typeof claims.exp === 'number' ? claims.exp : null;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/config.d.ts

@@ -24,9 +24,14 @@ export interface PlatformConfigInput {
     logger?: Logger;
 }
 /**
- * `.auth()` shape. Pass `{token}` for a static Bearer access token.
- * OAuth2 client_credentials live at `createClient()` config-time
- * (`serviceId` + `serviceSecret` fields), not via `.auth()`.
+ * `.auth()` shape. Pass `{token}` for a static Bearer access token — used
+ * until its `exp` passes, after which requests fail, because the SDK cannot
+ * refresh a bare string.
+ *
+ * For anything that needs renewal, do not use this: pass `serviceId` +
+ * `serviceSecret` or `tokenUrl` to `upsell.createClient()` (and the
+ * equivalents on `createClient()`), which build a token source that mints,
+ * caches and renews. Those options mirror the realtime SDK's names.
  */
 export interface PlatformAuthInput {
     token?: string;

package/dist/config.js

@@ -48,7 +48,7 @@ function normalizeAuth(input) {
     if (input.token) {
         return { type: 'bearer', token: input.token };
     }
-    throw new Error('auth(): pass {token} for a static Bearer access token, or use createClient({serviceId, serviceSecret}) for OAuth2 client_credentials');
+    throw new Error('auth(): pass {token} for a static Bearer access token, or use createClient({serviceId, serviceSecret}) / upsell.createClient({tokenUrl}) for a token the SDK renews itself');
 }
 /**
  * Mutable config shared by clients. `apply()` and `setAuth()` are how the
@@ -87,4 +87,4 @@ class ConfigState {
     }
 }
 exports.ConfigState = ConfigState;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"config.js","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":";;;AAmDA,kCAMC;AAiBD,sCAQC;AA/EY,QAAA,gBAAgB,GAAG,iCAAiC,CAAC;AAgClE;;;;GAIG;AACH;;;;;GAKG;AACH,SAAS,GAAG,CAAC,IAAY;IACvB,IAAI,OAAO,OAAO,KAAK,WAAW;QAAE,OAAO,SAAS,CAAC;IACrD,OAAQ,OAAwD,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,CAAC;AAC/E,CAAC;AAED,SAAgB,WAAW;IACzB,OAAO;QACL,OAAO,EAAE,GAAG,CAAC,kBAAkB,CAAC,IAAI,wBAAgB;QACpD,IAAI,EAAE,OAAO,EAAE;QACf,OAAO,EAAE,UAAU,CAAC,KAAqB;KAC1C,CAAC;AACJ,CAAC;AAED,SAAS,OAAO;IACd,MAAM,KAAK,GAAG,GAAG,CAAC,oBAAoB,CAAC,CAAC;IACxC,IAAI,KAAK;QAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC;IAC5C,OAAO,SAAS,CAAC;AACnB,CAAC;AAED;;;;;;;;GAQG;AACH,SAAgB,aAAa,CAAC,KAAuC;IACnE,IAAI,MAAM,IAAI,KAAK;QAAE,OAAO,KAAK,CAAC;IAClC,IAAI,KAAK,CAAC,KAAK,EAAE,CAAC;QAChB,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,CAAC;IAChD,CAAC;IACD,MAAM,IAAI,KAAK,CACb,sIAAsI,CACvI,CAAC;AACJ,CAAC;AAED;;;;;GAKG;AACH,MAAa,WAAW;IACd,SAAS,GAAwB,EAAE,CAAC;IACpC,YAAY,CAA2B;IACvC,eAAe,GAAG,KAAK,CAAC;IAEhC,KAAK,CAAC,KAA0B;QAC9B,IAAI,KAAK,CAAC,OAAO,KAAK,SAAS;YAAE,IAAI,CAAC,SAAS,CAAC,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC;QACxE,IAAI,KAAK,CAAC,OAAO,KAAK,SAAS;YAAE,IAAI,CAAC,SAAS,CAAC,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC;QACxE,IAAI,KAAK,CAAC,MAAM,KAAK,SAAS;YAAE,IAAI,CAAC,SAAS,CAAC,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC;QACrE,IAAI,KAAK,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;YAC7B,IAAI,CAAC,YAAY,GAAG,aAAa,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;YAC9C,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC;QAC9B,CAAC;IACH,CAAC;IAED,OAAO,CAAC,KAAuC;QAC7C,IAAI,CAAC,YAAY,GAAG,aAAa,CAAC,KAAK,CAAC,CAAC;QACzC,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC;IAC9B,CAAC;IAED,OAAO;QACL,MAAM,GAAG,GAAG,WAAW,EAAE,CAAC;QAC1B,OAAO;YACL,OAAO,EAAE,IAAI,CAAC,SAAS,CAAC,OAAO,IAAI,GAAG,CAAC,OAAO;YAC9C,IAAI,EAAE,IAAI,CAAC,eAAe,CAAC,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI;YACzD,OAAO,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,IAAI,GAAG,CAAC,OAAO,CAAiB;YAChE,MAAM,EAAE,IAAI,CAAC,SAAS,CAAC,MAA4B;SACpD,CAAC;IACJ,CAAC;CACF;AA7BD,kCA6BC","sourcesContent":["import type { Logger } from '@uengage.io/js-logger';\nimport type { TokenSourceState } from './token-source';\n\nexport const DEFAULT_BASE_URL = 'https://api.platform.uengage.io';\n\n/**\n * Resolved auth state. Discriminated by `type` so consumers can narrow.\n */\nexport type PlatformAuth =\n  | { type: 'bearer'; token: string }\n  | { type: 'token-source'; state: TokenSourceState };\n\nexport interface PlatformConfig {\n  baseUrl: string;\n  auth?: PlatformAuth;\n  fetchFn: typeof fetch;\n  logger?: Logger;\n}\n\nexport interface PlatformConfigInput {\n  baseUrl?: string;\n  auth?: PlatformAuthInput | PlatformAuth;\n  fetchFn?: typeof fetch;\n  logger?: Logger;\n}\n\n/**\n * `.auth()` shape. Pass `{token}` for a static Bearer access token.\n * OAuth2 client_credentials live at `createClient()` config-time\n * (`serviceId` + `serviceSecret` fields), not via `.auth()`.\n */\nexport interface PlatformAuthInput {\n  token?: string;\n}\n\n/**\n * Resolve env-defaulted config. Re-read on every call so that callers can\n * set env vars after the SDK has been imported and still pick them up on\n * the next request.\n */\n/**\n * Read `process.env` defensively: in a browser bundle `process` is not\n * defined at all, and touching it throws a ReferenceError rather than\n * yielding undefined. The SDK is used from browsers (the\n * `whitelabel_web` channel), so every env read goes through here.\n */\nfunction env(name: string): string | undefined {\n  if (typeof process === 'undefined') return undefined;\n  return (process as { env?: Record<string, string | undefined> }).env?.[name];\n}\n\nexport function envDefaults(): PlatformConfig {\n  return {\n    baseUrl: env('UENGAGE_BASE_URL') ?? DEFAULT_BASE_URL,\n    auth: envAuth(),\n    fetchFn: globalThis.fetch as typeof fetch,\n  };\n}\n\nfunction envAuth(): PlatformAuth | undefined {\n  const token = env('UENGAGE_AUTH_TOKEN');\n  if (token) return { type: 'bearer', token };\n  return undefined;\n}\n\n/**\n * Coerce `.auth()` input or `config({auth})` input into a typed\n * PlatformAuth. Throws when the input has no usable credentials.\n *\n * Today this only accepts `{token}` or a pre-shaped `PlatformAuth`.\n * For OAuth2 client_credentials use `createClient({serviceId, serviceSecret})`\n * instead — that builds a TokenSource which mints + caches Bearer\n * tokens.\n */\nexport function normalizeAuth(input: PlatformAuthInput | PlatformAuth): PlatformAuth {\n  if ('type' in input) return input;\n  if (input.token) {\n    return { type: 'bearer', token: input.token };\n  }\n  throw new Error(\n    'auth(): pass {token} for a static Bearer access token, or use createClient({serviceId, serviceSecret}) for OAuth2 client_credentials',\n  );\n}\n\n/**\n * Mutable config shared by clients. `apply()` and `setAuth()` are how the\n * chainable `.config()` / `.auth()` methods write back. `resolve()` produces\n * the effective config for one request, falling back to current env state\n * for fields the caller hasn't pinned.\n */\nexport class ConfigState {\n  private overrides: PlatformConfigInput = {};\n  private explicitAuth: PlatformAuth | undefined;\n  private hasExplicitAuth = false;\n\n  apply(input: PlatformConfigInput): void {\n    if (input.baseUrl !== undefined) this.overrides.baseUrl = input.baseUrl;\n    if (input.fetchFn !== undefined) this.overrides.fetchFn = input.fetchFn;\n    if (input.logger !== undefined) this.overrides.logger = input.logger;\n    if (input.auth !== undefined) {\n      this.explicitAuth = normalizeAuth(input.auth);\n      this.hasExplicitAuth = true;\n    }\n  }\n\n  setAuth(input: PlatformAuthInput | PlatformAuth): void {\n    this.explicitAuth = normalizeAuth(input);\n    this.hasExplicitAuth = true;\n  }\n\n  resolve(): PlatformConfig {\n    const env = envDefaults();\n    return {\n      baseUrl: this.overrides.baseUrl ?? env.baseUrl,\n      auth: this.hasExplicitAuth ? this.explicitAuth : env.auth,\n      fetchFn: (this.overrides.fetchFn ?? env.fetchFn) as typeof fetch,\n      logger: this.overrides.logger as Logger | undefined,\n    };\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"config.js","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":";;;AAwDA,kCAMC;AAiBD,sCAQC;AApFY,QAAA,gBAAgB,GAAG,iCAAiC,CAAC;AAqClE;;;;GAIG;AACH;;;;;GAKG;AACH,SAAS,GAAG,CAAC,IAAY;IACvB,IAAI,OAAO,OAAO,KAAK,WAAW;QAAE,OAAO,SAAS,CAAC;IACrD,OAAQ,OAAwD,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,CAAC;AAC/E,CAAC;AAED,SAAgB,WAAW;IACzB,OAAO;QACL,OAAO,EAAE,GAAG,CAAC,kBAAkB,CAAC,IAAI,wBAAgB;QACpD,IAAI,EAAE,OAAO,EAAE;QACf,OAAO,EAAE,UAAU,CAAC,KAAqB;KAC1C,CAAC;AACJ,CAAC;AAED,SAAS,OAAO;IACd,MAAM,KAAK,GAAG,GAAG,CAAC,oBAAoB,CAAC,CAAC;IACxC,IAAI,KAAK;QAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC;IAC5C,OAAO,SAAS,CAAC;AACnB,CAAC;AAED;;;;;;;;GAQG;AACH,SAAgB,aAAa,CAAC,KAAuC;IACnE,IAAI,MAAM,IAAI,KAAK;QAAE,OAAO,KAAK,CAAC;IAClC,IAAI,KAAK,CAAC,KAAK,EAAE,CAAC;QAChB,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,CAAC;IAChD,CAAC;IACD,MAAM,IAAI,KAAK,CACb,4KAA4K,CAC7K,CAAC;AACJ,CAAC;AAED;;;;;GAKG;AACH,MAAa,WAAW;IACd,SAAS,GAAwB,EAAE,CAAC;IACpC,YAAY,CAA2B;IACvC,eAAe,GAAG,KAAK,CAAC;IAEhC,KAAK,CAAC,KAA0B;QAC9B,IAAI,KAAK,CAAC,OAAO,KAAK,SAAS;YAAE,IAAI,CAAC,SAAS,CAAC,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC;QACxE,IAAI,KAAK,CAAC,OAAO,KAAK,SAAS;YAAE,IAAI,CAAC,SAAS,CAAC,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC;QACxE,IAAI,KAAK,CAAC,MAAM,KAAK,SAAS;YAAE,IAAI,CAAC,SAAS,CAAC,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC;QACrE,IAAI,KAAK,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;YAC7B,IAAI,CAAC,YAAY,GAAG,aAAa,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;YAC9C,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC;QAC9B,CAAC;IACH,CAAC;IAED,OAAO,CAAC,KAAuC;QAC7C,IAAI,CAAC,YAAY,GAAG,aAAa,CAAC,KAAK,CAAC,CAAC;QACzC,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC;IAC9B,CAAC;IAED,OAAO;QACL,MAAM,GAAG,GAAG,WAAW,EAAE,CAAC;QAC1B,OAAO;YACL,OAAO,EAAE,IAAI,CAAC,SAAS,CAAC,OAAO,IAAI,GAAG,CAAC,OAAO;YAC9C,IAAI,EAAE,IAAI,CAAC,eAAe,CAAC,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI;YACzD,OAAO,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,IAAI,GAAG,CAAC,OAAO,CAAiB;YAChE,MAAM,EAAE,IAAI,CAAC,SAAS,CAAC,MAA4B;SACpD,CAAC;IACJ,CAAC;CACF;AA7BD,kCA6BC","sourcesContent":["import type { Logger } from '@uengage.io/js-logger';\nimport type { TokenSourceState } from './token-source';\n\nexport const DEFAULT_BASE_URL = 'https://api.platform.uengage.io';\n\n/**\n * Resolved auth state. Discriminated by `type` so consumers can narrow.\n */\nexport type PlatformAuth =\n  | { type: 'bearer'; token: string }\n  | { type: 'token-source'; state: TokenSourceState };\n\nexport interface PlatformConfig {\n  baseUrl: string;\n  auth?: PlatformAuth;\n  fetchFn: typeof fetch;\n  logger?: Logger;\n}\n\nexport interface PlatformConfigInput {\n  baseUrl?: string;\n  auth?: PlatformAuthInput | PlatformAuth;\n  fetchFn?: typeof fetch;\n  logger?: Logger;\n}\n\n/**\n * `.auth()` shape. Pass `{token}` for a static Bearer access token — used\n * until its `exp` passes, after which requests fail, because the SDK cannot\n * refresh a bare string.\n *\n * For anything that needs renewal, do not use this: pass `serviceId` +\n * `serviceSecret` or `tokenUrl` to `upsell.createClient()` (and the\n * equivalents on `createClient()`), which build a token source that mints,\n * caches and renews. Those options mirror the realtime SDK's names.\n */\nexport interface PlatformAuthInput {\n  token?: string;\n}\n\n/**\n * Resolve env-defaulted config. Re-read on every call so that callers can\n * set env vars after the SDK has been imported and still pick them up on\n * the next request.\n */\n/**\n * Read `process.env` defensively: in a browser bundle `process` is not\n * defined at all, and touching it throws a ReferenceError rather than\n * yielding undefined. The SDK is used from browsers (the\n * `whitelabel_web` channel), so every env read goes through here.\n */\nfunction env(name: string): string | undefined {\n  if (typeof process === 'undefined') return undefined;\n  return (process as { env?: Record<string, string | undefined> }).env?.[name];\n}\n\nexport function envDefaults(): PlatformConfig {\n  return {\n    baseUrl: env('UENGAGE_BASE_URL') ?? DEFAULT_BASE_URL,\n    auth: envAuth(),\n    fetchFn: globalThis.fetch as typeof fetch,\n  };\n}\n\nfunction envAuth(): PlatformAuth | undefined {\n  const token = env('UENGAGE_AUTH_TOKEN');\n  if (token) return { type: 'bearer', token };\n  return undefined;\n}\n\n/**\n * Coerce `.auth()` input or `config({auth})` input into a typed\n * PlatformAuth. Throws when the input has no usable credentials.\n *\n * Today this only accepts `{token}` or a pre-shaped `PlatformAuth`.\n * For OAuth2 client_credentials use `createClient({serviceId, serviceSecret})`\n * instead — that builds a TokenSource which mints + caches Bearer\n * tokens.\n */\nexport function normalizeAuth(input: PlatformAuthInput | PlatformAuth): PlatformAuth {\n  if ('type' in input) return input;\n  if (input.token) {\n    return { type: 'bearer', token: input.token };\n  }\n  throw new Error(\n    'auth(): pass {token} for a static Bearer access token, or use createClient({serviceId, serviceSecret}) / upsell.createClient({tokenUrl}) for a token the SDK renews itself',\n  );\n}\n\n/**\n * Mutable config shared by clients. `apply()` and `setAuth()` are how the\n * chainable `.config()` / `.auth()` methods write back. `resolve()` produces\n * the effective config for one request, falling back to current env state\n * for fields the caller hasn't pinned.\n */\nexport class ConfigState {\n  private overrides: PlatformConfigInput = {};\n  private explicitAuth: PlatformAuth | undefined;\n  private hasExplicitAuth = false;\n\n  apply(input: PlatformConfigInput): void {\n    if (input.baseUrl !== undefined) this.overrides.baseUrl = input.baseUrl;\n    if (input.fetchFn !== undefined) this.overrides.fetchFn = input.fetchFn;\n    if (input.logger !== undefined) this.overrides.logger = input.logger;\n    if (input.auth !== undefined) {\n      this.explicitAuth = normalizeAuth(input.auth);\n      this.hasExplicitAuth = true;\n    }\n  }\n\n  setAuth(input: PlatformAuthInput | PlatformAuth): void {\n    this.explicitAuth = normalizeAuth(input);\n    this.hasExplicitAuth = true;\n  }\n\n  resolve(): PlatformConfig {\n    const env = envDefaults();\n    return {\n      baseUrl: this.overrides.baseUrl ?? env.baseUrl,\n      auth: this.hasExplicitAuth ? this.explicitAuth : env.auth,\n      fetchFn: (this.overrides.fetchFn ?? env.fetchFn) as typeof fetch,\n      logger: this.overrides.logger as Logger | undefined,\n    };\n  }\n}\n"]}

package/dist/http.js

@@ -11,9 +11,20 @@ const MUTATING_METHODS = new Set(['POST', 'PUT', 'PATCH', 'DELETE']);
  * The SDK runs in browsers as well as Lambdas — `whitelabel_web` is a
  * first-class channel — and a static `node:crypto` import breaks any
  * browser bundler that does not shim it. `crypto.randomUUID` is present
- * in Node >= 19 and every current browser; the manual fallback covers
- * older runtimes and non-secure contexts, where the value is only used
- * as an idempotency key and needs uniqueness, not unguessability.
+ * in Node >= 19 and every current browser; `getRandomValues` covers older
+ * runtimes and non-secure contexts.
+ *
+ * The last fallback exists for React Native: Hermes provides NO
+ * `globalThis.crypto` at all, and `mobile_app` is a first-class channel.
+ * Throwing there made `suggest()` and `reportEvents()` — both POSTs —
+ * unusable in an app until the consumer added a polyfill, which is the
+ * wrong trade twice over: nothing on the platform reads this header, and
+ * as stated above the value needs uniqueness, not unguessability. A
+ * request that fails is strictly worse than a key that is merely unique.
+ *
+ * The fallback mixes the clock and a process counter into the first six
+ * bytes so that two calls in the same millisecond still differ even under
+ * a poor `Math.random`.
  */
 function randomUUID() {
     const c = globalThis.crypto;
@@ -26,7 +37,35 @@ function randomUUID() {
         const hex = [...b].map((x) => x.toString(16).padStart(2, '0')).join('');
         return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
     }
-    throw new Error('No crypto source available for idempotency-key generation');
+    return uniqueUUID();
+}
+/** Monotonic within the process; wraps well above any per-millisecond burst. */
+let uuidCounter = 0;
+/**
+ * A v4-SHAPED identifier built without any crypto source. Unique, not
+ * unguessable — see the note on randomUUID for why that is the right
+ * requirement for this header.
+ */
+function uniqueUUID() {
+    const b = new Uint8Array(16);
+    for (let i = 0; i < 16; i += 1)
+        b[i] = Math.floor(Math.random() * 256);
+    // Bytes 0-3: the clock, so keys are ordered and cannot repeat across
+    // milliseconds however weak Math.random is.
+    const t = Date.now();
+    b[0] = (t >>> 24) & 0xff;
+    b[1] = (t >>> 16) & 0xff;
+    b[2] = (t >>> 8) & 0xff;
+    b[3] = t & 0xff;
+    // Bytes 4-5: a per-process counter, so a burst inside one millisecond
+    // still differs.
+    uuidCounter = (uuidCounter + 1) & 0xffff;
+    b[4] = (uuidCounter >>> 8) & 0xff;
+    b[5] = uuidCounter & 0xff;
+    b[6] = (b[6] & 0x0f) | 0x40; // version 4
+    b[8] = (b[8] & 0x3f) | 0x80; // variant
+    const hex = [...b].map((x) => x.toString(16).padStart(2, '0')).join('');
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
 }
 /**
  * Build the headers for a request to the platform API.
@@ -100,4 +139,4 @@ async function sendWithAuthRetry(config, params) {
         body: params.body,
     });
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"http.js","sourceRoot":"","sources":["../src/http.ts"],"names":[],"mappings":"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","sourcesContent":["import type { PlatformConfig } from './config';\nimport { getAccessToken, invalidateToken } from './token-source';\nimport { SDK_VERSION } from './version';\n\nexport interface SignedHeaderParams {\n  method: string;\n  /** URL pathname only, without query string. Must match `c.req.path` server-side. */\n  path: string;\n  /** Raw JSON body string, or empty for none. */\n  body?: string;\n}\n\nconst MUTATING_METHODS = new Set(['POST', 'PUT', 'PATCH', 'DELETE']);\n\n/**\n * UUID v4 without a `node:crypto` import.\n *\n * The SDK runs in browsers as well as Lambdas — `whitelabel_web` is a\n * first-class channel — and a static `node:crypto` import breaks any\n * browser bundler that does not shim it. `crypto.randomUUID` is present\n * in Node >= 19 and every current browser; the manual fallback covers\n * older runtimes and non-secure contexts, where the value is only used\n * as an idempotency key and needs uniqueness, not unguessability.\n */\nfunction randomUUID(): string {\n  const c = (\n    globalThis as {\n      crypto?: { randomUUID?: () => string; getRandomValues?: (a: Uint8Array) => Uint8Array };\n    }\n  ).crypto;\n  if (c?.randomUUID) return c.randomUUID();\n  if (c?.getRandomValues) {\n    const b = c.getRandomValues(new Uint8Array(16));\n    b[6] = (b[6] & 0x0f) | 0x40;\n    b[8] = (b[8] & 0x3f) | 0x80;\n    const hex = [...b].map((x) => x.toString(16).padStart(2, '0')).join('');\n    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;\n  }\n  throw new Error('No crypto source available for idempotency-key generation');\n}\n\n/**\n * Build the headers for a request to the platform API.\n *\n * Adds three platform-wide headers automatically:\n *   - `User-Agent` so the gateway can attribute traffic to SDK version\n *   - `Idempotency-Key` (UUID v4) on mutating methods, so callers don't\n *     have to generate one per call\n *   - `content-type: application/json` when a body is supplied\n *\n * Auth comes from `config.auth`:\n *   - `bearer`: the token is sent verbatim (caller is responsible for\n *     freshness; SDK throws TokenExpiredError on local-detected expiry)\n *   - `token-source`: SDK mints + caches via OAuth2 client_credentials\n *     and refreshes on expiry / 401\n */\nexport async function buildHeaders(\n  config: PlatformConfig,\n  params: SignedHeaderParams,\n): Promise<Record<string, string>> {\n  const headers: Record<string, string> = {\n    'user-agent': `uengage-platform-sdk/${SDK_VERSION}`,\n  };\n  if (params.body !== undefined) headers['content-type'] = 'application/json';\n  if (MUTATING_METHODS.has(params.method.toUpperCase())) {\n    headers['idempotency-key'] = randomUUID();\n  }\n\n  if (!config.auth) return headers;\n\n  if (config.auth.type === 'bearer') {\n    headers['authorization'] = `Bearer ${config.auth.token}`;\n    return headers;\n  }\n\n  // token-source: mint + cache + refresh-dedup happens in getAccessToken\n  const token = await getAccessToken(config.auth.state);\n  headers['authorization'] = `Bearer ${token}`;\n  return headers;\n}\n\nexport interface SendRequestParams {\n  method: string;\n  /** URL pathname only, without query string. Must match `c.req.path` server-side. */\n  path: string;\n  /** Fully-qualified URL the fetch is sent to (base + path + querystring). */\n  url: string;\n  /** Raw JSON body string, or undefined for none. */\n  body?: string;\n}\n\n/**\n * Send a request with the SDK's standard 401-retry-once behaviour.\n *\n * Only retries when auth is `token-source`, since that's the case\n * where the cached token may have expired server-side. HMAC and\n * static bearer 401s mean the auth is misconfigured and a retry\n * would just fail again. Bubble the response so the caller surfaces it.\n *\n * Shared by every namespace client (business, audit, zones, ...) so\n * the retry semantics are uniform. Lifted out of `business/client.ts`\n * with no behaviour change.\n */\nexport async function sendWithAuthRetry(\n  config: PlatformConfig,\n  params: SendRequestParams,\n): Promise<Response> {\n  const headers = await buildHeaders(config, {\n    method: params.method,\n    path: params.path,\n    body: params.body,\n  });\n  const res = await config.fetchFn(params.url, {\n    method: params.method,\n    headers,\n    body: params.body,\n  });\n  if (res.status !== 401 || config.auth?.type !== 'token-source') return res;\n  invalidateToken(config.auth.state);\n  const retryHeaders = await buildHeaders(config, {\n    method: params.method,\n    path: params.path,\n    body: params.body,\n  });\n  return config.fetchFn(params.url, {\n    method: params.method,\n    headers: retryHeaders,\n    body: params.body,\n  });\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"http.js","sourceRoot":"","sources":["../src/http.ts"],"names":[],"mappings":"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","sourcesContent":["import type { PlatformConfig } from './config';\nimport { getAccessToken, invalidateToken } from './token-source';\nimport { SDK_VERSION } from './version';\n\nexport interface SignedHeaderParams {\n  method: string;\n  /** URL pathname only, without query string. Must match `c.req.path` server-side. */\n  path: string;\n  /** Raw JSON body string, or empty for none. */\n  body?: string;\n}\n\nconst MUTATING_METHODS = new Set(['POST', 'PUT', 'PATCH', 'DELETE']);\n\n/**\n * UUID v4 without a `node:crypto` import.\n *\n * The SDK runs in browsers as well as Lambdas — `whitelabel_web` is a\n * first-class channel — and a static `node:crypto` import breaks any\n * browser bundler that does not shim it. `crypto.randomUUID` is present\n * in Node >= 19 and every current browser; `getRandomValues` covers older\n * runtimes and non-secure contexts.\n *\n * The last fallback exists for React Native: Hermes provides NO\n * `globalThis.crypto` at all, and `mobile_app` is a first-class channel.\n * Throwing there made `suggest()` and `reportEvents()` — both POSTs —\n * unusable in an app until the consumer added a polyfill, which is the\n * wrong trade twice over: nothing on the platform reads this header, and\n * as stated above the value needs uniqueness, not unguessability. A\n * request that fails is strictly worse than a key that is merely unique.\n *\n * The fallback mixes the clock and a process counter into the first six\n * bytes so that two calls in the same millisecond still differ even under\n * a poor `Math.random`.\n */\nfunction randomUUID(): string {\n  const c = (\n    globalThis as {\n      crypto?: { randomUUID?: () => string; getRandomValues?: (a: Uint8Array) => Uint8Array };\n    }\n  ).crypto;\n  if (c?.randomUUID) return c.randomUUID();\n  if (c?.getRandomValues) {\n    const b = c.getRandomValues(new Uint8Array(16));\n    b[6] = (b[6] & 0x0f) | 0x40;\n    b[8] = (b[8] & 0x3f) | 0x80;\n    const hex = [...b].map((x) => x.toString(16).padStart(2, '0')).join('');\n    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;\n  }\n  return uniqueUUID();\n}\n\n/** Monotonic within the process; wraps well above any per-millisecond burst. */\nlet uuidCounter = 0;\n\n/**\n * A v4-SHAPED identifier built without any crypto source. Unique, not\n * unguessable — see the note on randomUUID for why that is the right\n * requirement for this header.\n */\nfunction uniqueUUID(): string {\n  const b = new Uint8Array(16);\n  for (let i = 0; i < 16; i += 1) b[i] = Math.floor(Math.random() * 256);\n\n  // Bytes 0-3: the clock, so keys are ordered and cannot repeat across\n  // milliseconds however weak Math.random is.\n  const t = Date.now();\n  b[0] = (t >>> 24) & 0xff;\n  b[1] = (t >>> 16) & 0xff;\n  b[2] = (t >>> 8) & 0xff;\n  b[3] = t & 0xff;\n\n  // Bytes 4-5: a per-process counter, so a burst inside one millisecond\n  // still differs.\n  uuidCounter = (uuidCounter + 1) & 0xffff;\n  b[4] = (uuidCounter >>> 8) & 0xff;\n  b[5] = uuidCounter & 0xff;\n\n  b[6] = (b[6] & 0x0f) | 0x40; // version 4\n  b[8] = (b[8] & 0x3f) | 0x80; // variant\n\n  const hex = [...b].map((x) => x.toString(16).padStart(2, '0')).join('');\n  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;\n}\n\n/**\n * Build the headers for a request to the platform API.\n *\n * Adds three platform-wide headers automatically:\n *   - `User-Agent` so the gateway can attribute traffic to SDK version\n *   - `Idempotency-Key` (UUID v4) on mutating methods, so callers don't\n *     have to generate one per call\n *   - `content-type: application/json` when a body is supplied\n *\n * Auth comes from `config.auth`:\n *   - `bearer`: the token is sent verbatim (caller is responsible for\n *     freshness; SDK throws TokenExpiredError on local-detected expiry)\n *   - `token-source`: SDK mints + caches via OAuth2 client_credentials\n *     and refreshes on expiry / 401\n */\nexport async function buildHeaders(\n  config: PlatformConfig,\n  params: SignedHeaderParams,\n): Promise<Record<string, string>> {\n  const headers: Record<string, string> = {\n    'user-agent': `uengage-platform-sdk/${SDK_VERSION}`,\n  };\n  if (params.body !== undefined) headers['content-type'] = 'application/json';\n  if (MUTATING_METHODS.has(params.method.toUpperCase())) {\n    headers['idempotency-key'] = randomUUID();\n  }\n\n  if (!config.auth) return headers;\n\n  if (config.auth.type === 'bearer') {\n    headers['authorization'] = `Bearer ${config.auth.token}`;\n    return headers;\n  }\n\n  // token-source: mint + cache + refresh-dedup happens in getAccessToken\n  const token = await getAccessToken(config.auth.state);\n  headers['authorization'] = `Bearer ${token}`;\n  return headers;\n}\n\nexport interface SendRequestParams {\n  method: string;\n  /** URL pathname only, without query string. Must match `c.req.path` server-side. */\n  path: string;\n  /** Fully-qualified URL the fetch is sent to (base + path + querystring). */\n  url: string;\n  /** Raw JSON body string, or undefined for none. */\n  body?: string;\n}\n\n/**\n * Send a request with the SDK's standard 401-retry-once behaviour.\n *\n * Only retries when auth is `token-source`, since that's the case\n * where the cached token may have expired server-side. HMAC and\n * static bearer 401s mean the auth is misconfigured and a retry\n * would just fail again. Bubble the response so the caller surfaces it.\n *\n * Shared by every namespace client (business, audit, zones, ...) so\n * the retry semantics are uniform. Lifted out of `business/client.ts`\n * with no behaviour change.\n */\nexport async function sendWithAuthRetry(\n  config: PlatformConfig,\n  params: SendRequestParams,\n): Promise<Response> {\n  const headers = await buildHeaders(config, {\n    method: params.method,\n    path: params.path,\n    body: params.body,\n  });\n  const res = await config.fetchFn(params.url, {\n    method: params.method,\n    headers,\n    body: params.body,\n  });\n  if (res.status !== 401 || config.auth?.type !== 'token-source') return res;\n  invalidateToken(config.auth.state);\n  const retryHeaders = await buildHeaders(config, {\n    method: params.method,\n    path: params.path,\n    body: params.body,\n  });\n  return config.fetchFn(params.url, {\n    method: params.method,\n    headers: retryHeaders,\n    body: params.body,\n  });\n}\n"]}

package/dist/realtime/endpoints.d.ts

@@ -7,9 +7,9 @@
  * AppSync assigns the Event API's DNS names at create time
  * (`<apiId>.appsync-api.<region>.amazonaws.com` and the matching
  * `appsync-realtime-api` host), so they cannot be known before the stack
- * is deployed. Until `services/realtime` has been deployed to an
- * environment its entry stays null and `connect({ env })` throws with
- * instructions; `connect({ endpoints })` always works.
+ * is deployed. An environment without a deployed stack stays null and
+ * `connect({ env })` throws with instructions; `connect({ endpoints })`
+ * always works.
  */
 export interface RealtimeEndpoints {
     /** AppSync Event API HTTP domain. Also the `host` in the auth header. */

package/dist/realtime/endpoints.js

@@ -3,15 +3,30 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.API_BASE = void 0;
 exports.endpointsFor = endpointsFor;
 /**
- * TODO(event-bus): populate `httpDomain` / `realtimeDomain` per
- * environment from the `RealtimeEventApiHttpDns-{env}` and
- * `RealtimeEventApiRealtimeDns-{env}` outputs of `UengageRealtimeService-{env}`
- * once the stack has been deployed there.
+ * AppSync assigns these at Event API create time and the prefix is NOT the
+ * API id, so they cannot be constructed — they are copied from the
+ * `RealtimeEventApiHttpDns-{env}` / `RealtimeEventApiRealtimeDns-{env}`
+ * outputs of `UengageRealtimeService-{env}`.
+ *
+ * Because a cached browser bundle carries these values, recreating an Event
+ * API is a breaking change for every pinned consumer. The `browser-sdk`
+ * release job asserts the prod pair still matches the live stack exports and
+ * fails the release on drift, so this table cannot rot silently.
+ *
+ * `dev` stays null — the realtime stack is not deployed there.
  */
 const ENDPOINTS = {
     dev: null,
-    uat: null,
-    prod: null,
+    uat: {
+        httpDomain: 'zl2kormwrjexbglkbpsy44xye4.appsync-api.ap-south-1.amazonaws.com',
+        realtimeDomain: 'zl2kormwrjexbglkbpsy44xye4.appsync-realtime-api.ap-south-1.amazonaws.com',
+        apiBase: 'https://api.uat.platform.uengage.io',
+    },
+    prod: {
+        httpDomain: '6dhfjtlvyjfalku7umbusuilha.appsync-api.ap-south-1.amazonaws.com',
+        realtimeDomain: '6dhfjtlvyjfalku7umbusuilha.appsync-realtime-api.ap-south-1.amazonaws.com',
+        apiBase: 'https://api.platform.uengage.io',
+    },
 };
 /** Platform API base per environment — known ahead of any deploy. */
 exports.API_BASE = {
@@ -28,4 +43,4 @@ function endpointsFor(env) {
     }
     return found;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/token-source.d.ts

@@ -20,6 +20,20 @@ export type TokenSource = {
 } | {
     kind: 'callback';
     getToken: () => string | Promise<string>;
+} | {
+    /**
+     * `tokenUrl` — a route on the CALLER's own server that returns
+     * `{ token, expiresIn }`. Mirrors the realtime SDK option of the
+     * same name, and exists for the same reason: it keeps the client
+     * secret on the caller's server instead of in a page or an app
+     * bundle.
+     *
+     * `expiresIn` is seconds from receipt, per the realtime contract.
+     * It is trusted over the JWT's own `exp` because the caller's
+     * server may deliberately hand out a shorter-lived slice.
+     */
+    kind: 'token-url';
+    tokenUrl: string;
 } | {
     kind: 'service-credentials';
     clientId: string;