@uengage.io/platform-sdk 0.2.0 → 0.6.0

package/dist/audit/client.js

@@ -136,7 +136,7 @@ function createAuditClient(input = {}) {
     async function sendOnce(body) {
         const config = state.resolve();
         const logger = getLogger();
-        const headers = (0, http_1.buildHeaders)(config, { method: 'POST', path: PATH, body });
+        const headers = await (0, http_1.buildHeaders)(config, { method: 'POST', path: PATH, body });
         const res = await config.fetchFn(`${config.baseUrl}${PATH}`, {
             method: 'POST',
             headers,
@@ -166,4 +166,4 @@ function createAuditClient(input = {}) {
 function sleep(ms) {
     return new Promise((r) => setTimeout(r, ms));
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"client.js","sourceRoot":"","sources":["../../src/audit/client.ts"],"names":[],"mappings":"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","sourcesContent":["import { ulid } from 'ulid';\nimport type { Logger } from '@uengage.io/js-logger';\nimport {\n  ConfigState,\n  type PlatformAuth,\n  type PlatformAuthInput,\n  type PlatformConfigInput,\n} from '../config';\nimport { buildHeaders } from '../http';\nimport { auditEventSchema, type AuditEvent } from './schema';\n\n/**\n * Caller-facing event shape. The SDK fills:\n *   - `event_id`   (ULID, generated per call)\n *   - `occurred_at` (UTC ISO 8601 at the time of `record()`)\n *   - `actor.via`  (always set to the configured serviceId, so callers\n *                   can't drift from the service identity used for auth)\n */\nexport type AuditEventInput = Omit<AuditEvent, 'event_id' | 'occurred_at' | 'actor'> & {\n  actor: Omit<AuditEvent['actor'], 'via'>;\n};\n\nexport interface AuditClientInput extends PlatformConfigInput {\n  /** Default 5000. */\n  flushIntervalMs?: number;\n  /** Default 50. */\n  maxBatchSize?: number;\n  /** Default 1000. New events past this are dropped with a warning. */\n  maxQueueSize?: number;\n  /** Default true. Set false to disable the auto-flush timer (test only). */\n  enableTimer?: boolean;\n}\n\nexport interface AuditClient {\n  config(input: PlatformConfigInput): AuditClient;\n  auth(input: PlatformAuthInput | PlatformAuth): AuditClient;\n  record(event: AuditEventInput): void;\n  flush(): Promise<void>;\n}\n\nconst PATH = '/v1/audit/events';\nconst RETRY_DELAYS_MS = [500, 2000, 8000];\n\nconst NOOP_LOGGER = {\n  error: () => {},\n  warn: () => {},\n  info: () => {},\n  debug: () => {},\n  child() {\n    return this;\n  },\n} as unknown as Logger;\n\nexport function createAuditClient(input: AuditClientInput = {}): AuditClient {\n  const state = new ConfigState();\n  const flushIntervalMs = input.flushIntervalMs ?? 5000;\n  const maxBatchSize = input.maxBatchSize ?? 50;\n  const maxQueueSize = input.maxQueueSize ?? 1000;\n  const enableTimer = input.enableTimer ?? true;\n\n  const {\n    flushIntervalMs: _f,\n    maxBatchSize: _b,\n    maxQueueSize: _q,\n    enableTimer: _t,\n    ...rest\n  } = input;\n  void _f;\n  void _b;\n  void _q;\n  void _t;\n  state.apply(rest);\n\n  const queue: AuditEvent[] = [];\n  const inflight: Promise<void>[] = [];\n\n  function getLogger(): Logger {\n    return state.resolve().logger ?? NOOP_LOGGER;\n  }\n\n  function getServiceId(): string {\n    const config = state.resolve();\n    if (!config.auth || config.auth.type !== 'hmac') {\n      throw new Error(\n        'audit client requires HMAC auth (set PLATFORM_SIGNING_SECRET + PLATFORM_SERVICE_ID, or call .auth({secret, serviceId}))',\n      );\n    }\n    return config.auth.serviceId;\n  }\n\n  const client: AuditClient = {\n    config(opts) {\n      state.apply(opts);\n      return client;\n    },\n    auth(opts) {\n      state.setAuth(opts);\n      return client;\n    },\n    record(input) {\n      const logger = getLogger();\n      let serviceId: string;\n      try {\n        serviceId = getServiceId();\n      } catch (err) {\n        logger.error('audit_sdk.no_auth', {\n          error: { code: 'AUDIT_NO_AUTH', category: 'engineering' },\n          context: { message: (err as Error).message },\n        });\n        return;\n      }\n\n      const candidate: AuditEvent = {\n        ...input,\n        event_id: ulid(),\n        occurred_at: new Date().toISOString().replace(/\\.\\d{3}Z$/, 'Z'),\n        actor: { ...input.actor, via: serviceId },\n      };\n      const result = auditEventSchema.safeParse(candidate);\n      if (!result.success) {\n        logger.error('audit_sdk.invalid_event', {\n          error: { code: 'AUDIT_INVALID_EVENT', category: 'engineering' },\n          context: { issues: result.error.issues, event: candidate },\n        });\n        return;\n      }\n      if (queue.length >= maxQueueSize) {\n        logger.warn('audit_sdk.queue_full', {\n          context: { dropped_event_id: candidate.event_id, max_queue_size: maxQueueSize },\n        });\n        return;\n      }\n      queue.push(result.data);\n      if (queue.length >= maxBatchSize) {\n        void scheduleSend();\n      }\n    },\n    async flush() {\n      await scheduleSend();\n      while (inflight.length > 0) {\n        await Promise.allSettled([...inflight]);\n      }\n    },\n  };\n\n  async function scheduleSend(): Promise<void> {\n    while (queue.length > 0) {\n      const batch = queue.splice(0, maxBatchSize);\n      const send = sendWithRetries(batch);\n      inflight.push(send);\n      try {\n        await send;\n      } finally {\n        const idx = inflight.indexOf(send);\n        if (idx !== -1) inflight.splice(idx, 1);\n      }\n    }\n  }\n\n  async function sendWithRetries(events: AuditEvent[]): Promise<void> {\n    const logger = getLogger();\n    const body = JSON.stringify({ events });\n    for (let attempt = 0; attempt <= RETRY_DELAYS_MS.length; attempt++) {\n      try {\n        const ok = await sendOnce(body);\n        if (ok) return;\n      } catch (err) {\n        const e = err as Error;\n        logger.warn('audit_sdk.send_error', {\n          context: { attempt, message: e.message, batch_size: events.length },\n        });\n      }\n      if (attempt < RETRY_DELAYS_MS.length) {\n        await sleep(RETRY_DELAYS_MS[attempt]);\n      }\n    }\n    logger.error('audit_sdk.send_failed', {\n      error: { code: 'AUDIT_SEND_FAILED', category: 'engineering' },\n      context: { batch_size: events.length, events },\n    });\n  }\n\n  async function sendOnce(body: string): Promise<boolean> {\n    const config = state.resolve();\n    const logger = getLogger();\n    const headers = buildHeaders(config, { method: 'POST', path: PATH, body });\n    const res = await config.fetchFn(`${config.baseUrl}${PATH}`, {\n      method: 'POST',\n      headers,\n      body,\n    });\n    if (res.status >= 500) return false;\n    if (!res.ok && res.status !== 202) {\n      logger.error('audit_sdk.rejected', {\n        error: { code: 'AUDIT_REJECTED', category: 'engineering' },\n        context: { status: res.status },\n      });\n      return true;\n    }\n    return true;\n  }\n\n  let timer: ReturnType<typeof setInterval> | undefined;\n  if (enableTimer) {\n    timer = setInterval(() => {\n      void scheduleSend();\n    }, flushIntervalMs);\n    if (typeof timer.unref === 'function') timer.unref();\n  }\n\n  return client;\n}\n\nfunction sleep(ms: number): Promise<void> {\n  return new Promise((r) => setTimeout(r, ms));\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"client.js","sourceRoot":"","sources":["../../src/audit/client.ts"],"names":[],"mappings":"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","sourcesContent":["import { ulid } from 'ulid';\nimport type { Logger } from '@uengage.io/js-logger';\nimport {\n  ConfigState,\n  type PlatformAuth,\n  type PlatformAuthInput,\n  type PlatformConfigInput,\n} from '../config';\nimport { buildHeaders } from '../http';\nimport { auditEventSchema, type AuditEvent } from './schema';\n\n/**\n * Caller-facing event shape. The SDK fills:\n *   - `event_id`   (ULID, generated per call)\n *   - `occurred_at` (UTC ISO 8601 at the time of `record()`)\n *   - `actor.via`  (always set to the configured serviceId, so callers\n *                   can't drift from the service identity used for auth)\n */\nexport type AuditEventInput = Omit<AuditEvent, 'event_id' | 'occurred_at' | 'actor'> & {\n  actor: Omit<AuditEvent['actor'], 'via'>;\n};\n\nexport interface AuditClientInput extends PlatformConfigInput {\n  /** Default 5000. */\n  flushIntervalMs?: number;\n  /** Default 50. */\n  maxBatchSize?: number;\n  /** Default 1000. New events past this are dropped with a warning. */\n  maxQueueSize?: number;\n  /** Default true. Set false to disable the auto-flush timer (test only). */\n  enableTimer?: boolean;\n}\n\nexport interface AuditClient {\n  config(input: PlatformConfigInput): AuditClient;\n  auth(input: PlatformAuthInput | PlatformAuth): AuditClient;\n  record(event: AuditEventInput): void;\n  flush(): Promise<void>;\n}\n\nconst PATH = '/v1/audit/events';\nconst RETRY_DELAYS_MS = [500, 2000, 8000];\n\nconst NOOP_LOGGER = {\n  error: () => {},\n  warn: () => {},\n  info: () => {},\n  debug: () => {},\n  child() {\n    return this;\n  },\n} as unknown as Logger;\n\nexport function createAuditClient(input: AuditClientInput = {}): AuditClient {\n  const state = new ConfigState();\n  const flushIntervalMs = input.flushIntervalMs ?? 5000;\n  const maxBatchSize = input.maxBatchSize ?? 50;\n  const maxQueueSize = input.maxQueueSize ?? 1000;\n  const enableTimer = input.enableTimer ?? true;\n\n  const {\n    flushIntervalMs: _f,\n    maxBatchSize: _b,\n    maxQueueSize: _q,\n    enableTimer: _t,\n    ...rest\n  } = input;\n  void _f;\n  void _b;\n  void _q;\n  void _t;\n  state.apply(rest);\n\n  const queue: AuditEvent[] = [];\n  const inflight: Promise<void>[] = [];\n\n  function getLogger(): Logger {\n    return state.resolve().logger ?? NOOP_LOGGER;\n  }\n\n  function getServiceId(): string {\n    const config = state.resolve();\n    if (!config.auth || config.auth.type !== 'hmac') {\n      throw new Error(\n        'audit client requires HMAC auth (set PLATFORM_SIGNING_SECRET + PLATFORM_SERVICE_ID, or call .auth({secret, serviceId}))',\n      );\n    }\n    return config.auth.serviceId;\n  }\n\n  const client: AuditClient = {\n    config(opts) {\n      state.apply(opts);\n      return client;\n    },\n    auth(opts) {\n      state.setAuth(opts);\n      return client;\n    },\n    record(input) {\n      const logger = getLogger();\n      let serviceId: string;\n      try {\n        serviceId = getServiceId();\n      } catch (err) {\n        logger.error('audit_sdk.no_auth', {\n          error: { code: 'AUDIT_NO_AUTH', category: 'engineering' },\n          context: { message: (err as Error).message },\n        });\n        return;\n      }\n\n      const candidate: AuditEvent = {\n        ...input,\n        event_id: ulid(),\n        occurred_at: new Date().toISOString().replace(/\\.\\d{3}Z$/, 'Z'),\n        actor: { ...input.actor, via: serviceId },\n      };\n      const result = auditEventSchema.safeParse(candidate);\n      if (!result.success) {\n        logger.error('audit_sdk.invalid_event', {\n          error: { code: 'AUDIT_INVALID_EVENT', category: 'engineering' },\n          context: { issues: result.error.issues, event: candidate },\n        });\n        return;\n      }\n      if (queue.length >= maxQueueSize) {\n        logger.warn('audit_sdk.queue_full', {\n          context: { dropped_event_id: candidate.event_id, max_queue_size: maxQueueSize },\n        });\n        return;\n      }\n      queue.push(result.data);\n      if (queue.length >= maxBatchSize) {\n        void scheduleSend();\n      }\n    },\n    async flush() {\n      await scheduleSend();\n      while (inflight.length > 0) {\n        await Promise.allSettled([...inflight]);\n      }\n    },\n  };\n\n  async function scheduleSend(): Promise<void> {\n    while (queue.length > 0) {\n      const batch = queue.splice(0, maxBatchSize);\n      const send = sendWithRetries(batch);\n      inflight.push(send);\n      try {\n        await send;\n      } finally {\n        const idx = inflight.indexOf(send);\n        if (idx !== -1) inflight.splice(idx, 1);\n      }\n    }\n  }\n\n  async function sendWithRetries(events: AuditEvent[]): Promise<void> {\n    const logger = getLogger();\n    const body = JSON.stringify({ events });\n    for (let attempt = 0; attempt <= RETRY_DELAYS_MS.length; attempt++) {\n      try {\n        const ok = await sendOnce(body);\n        if (ok) return;\n      } catch (err) {\n        const e = err as Error;\n        logger.warn('audit_sdk.send_error', {\n          context: { attempt, message: e.message, batch_size: events.length },\n        });\n      }\n      if (attempt < RETRY_DELAYS_MS.length) {\n        await sleep(RETRY_DELAYS_MS[attempt]);\n      }\n    }\n    logger.error('audit_sdk.send_failed', {\n      error: { code: 'AUDIT_SEND_FAILED', category: 'engineering' },\n      context: { batch_size: events.length, events },\n    });\n  }\n\n  async function sendOnce(body: string): Promise<boolean> {\n    const config = state.resolve();\n    const logger = getLogger();\n    const headers = await buildHeaders(config, { method: 'POST', path: PATH, body });\n    const res = await config.fetchFn(`${config.baseUrl}${PATH}`, {\n      method: 'POST',\n      headers,\n      body,\n    });\n    if (res.status >= 500) return false;\n    if (!res.ok && res.status !== 202) {\n      logger.error('audit_sdk.rejected', {\n        error: { code: 'AUDIT_REJECTED', category: 'engineering' },\n        context: { status: res.status },\n      });\n      return true;\n    }\n    return true;\n  }\n\n  let timer: ReturnType<typeof setInterval> | undefined;\n  if (enableTimer) {\n    timer = setInterval(() => {\n      void scheduleSend();\n    }, flushIntervalMs);\n    if (typeof timer.unref === 'function') timer.unref();\n  }\n\n  return client;\n}\n\nfunction sleep(ms: number): Promise<void> {\n  return new Promise((r) => setTimeout(r, ms));\n}\n"]}

package/dist/auth/authorize-url.d.ts

@@ -0,0 +1,18 @@
+export interface AuthorizeUrlInput {
+    authBaseUrl?: string;
+    clientId: string;
+    redirectUri: string;
+    scope?: string;
+    tenant: string;
+    state?: string;
+    codeChallenge: string;
+    codeChallengeMethod?: 'S256';
+    nonce?: string;
+}
+/**
+ * Build the `/authorize` URL the browser should be redirected to. The
+ * caller is responsible for storing `codeVerifier` (from `generatePKCE`)
+ * to round-trip into `exchangeCode` after the redirect comes back with
+ * `?code=...`.
+ */
+export declare function createAuthorizeUrl(input: AuthorizeUrlInput): string;

package/dist/auth/authorize-url.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAuthorizeUrl = createAuthorizeUrl;
+const errors_1 = require("../errors");
+const DEFAULT_AUTH_BASE_URL = 'https://api.platform.uengage.io/auth/business';
+/**
+ * Build the `/authorize` URL the browser should be redirected to. The
+ * caller is responsible for storing `codeVerifier` (from `generatePKCE`)
+ * to round-trip into `exchangeCode` after the redirect comes back with
+ * `?code=...`.
+ */
+function createAuthorizeUrl(input) {
+    if (!input.clientId || !input.redirectUri || !input.tenant || !input.codeChallenge) {
+        throw new errors_1.ConfigError('createAuthorizeUrl requires clientId, redirectUri, tenant and codeChallenge');
+    }
+    const url = new URL(`${input.authBaseUrl ?? DEFAULT_AUTH_BASE_URL}/authorize`);
+    url.searchParams.set('response_type', 'code');
+    url.searchParams.set('client_id', input.clientId);
+    url.searchParams.set('redirect_uri', input.redirectUri);
+    if (input.scope)
+        url.searchParams.set('scope', input.scope);
+    url.searchParams.set('tenant', input.tenant);
+    if (input.state)
+        url.searchParams.set('state', input.state);
+    url.searchParams.set('code_challenge', input.codeChallenge);
+    url.searchParams.set('code_challenge_method', input.codeChallengeMethod ?? 'S256');
+    if (input.nonce)
+        url.searchParams.set('nonce', input.nonce);
+    return url.toString();
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/auth/exchange-code.d.ts

@@ -0,0 +1,22 @@
+export interface ExchangeCodeInput {
+    authBaseUrl?: string;
+    code: string;
+    codeVerifier: string;
+    clientId: string;
+    redirectUri: string;
+}
+export interface TokenPair {
+    accessToken: string;
+    refreshToken?: string;
+    idToken?: string;
+    expiresIn: number;
+    scope?: string;
+}
+/**
+ * Exchange an authorization code for an access + refresh + id token
+ * triple. PKCE verifier is included as `code_verifier` so the auth
+ * server can confirm the holder of the code is the same caller that
+ * initiated the flow.
+ */
+export declare function exchangeCode(input: ExchangeCodeInput): Promise<TokenPair>;
+export declare function parseTokenResponse(res: Response): Promise<TokenPair>;

package/dist/auth/exchange-code.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exchangeCode = exchangeCode;
+exports.parseTokenResponse = parseTokenResponse;
+const errors_1 = require("../errors");
+const DEFAULT_AUTH_BASE_URL = 'https://api.platform.uengage.io/auth/business';
+/**
+ * Exchange an authorization code for an access + refresh + id token
+ * triple. PKCE verifier is included as `code_verifier` so the auth
+ * server can confirm the holder of the code is the same caller that
+ * initiated the flow.
+ */
+async function exchangeCode(input) {
+    const body = new URLSearchParams({
+        grant_type: 'authorization_code',
+        code: input.code,
+        code_verifier: input.codeVerifier,
+        client_id: input.clientId,
+        redirect_uri: input.redirectUri,
+    });
+    const res = await fetch(`${input.authBaseUrl ?? DEFAULT_AUTH_BASE_URL}/oauth/token`, {
+        method: 'POST',
+        headers: { 'content-type': 'application/x-www-form-urlencoded' },
+        body: body.toString(),
+    });
+    return parseTokenResponse(res);
+}
+async function parseTokenResponse(res) {
+    let body;
+    try {
+        body = (await res.json());
+    }
+    catch (err) {
+        throw new errors_1.PlatformError(`auth server returned non-JSON: HTTP ${res.status}`, {
+            status: res.status,
+            cause: err,
+        });
+    }
+    if (!res.ok) {
+        const error = typeof body.error === 'string' ? body.error : 'auth_request_failed';
+        const description = typeof body.error_description === 'string' ? body.error_description : undefined;
+        if (res.status === 401) {
+            throw new errors_1.AuthenticationError(description ?? error, { cause: body });
+        }
+        throw new errors_1.PlatformError(description ?? error, { status: res.status, cause: body });
+    }
+    return {
+        accessToken: String(body.access_token ?? ''),
+        refreshToken: typeof body.refresh_token === 'string' ? body.refresh_token : undefined,
+        idToken: typeof body.id_token === 'string' ? body.id_token : undefined,
+        expiresIn: Number(body.expires_in ?? 0),
+        scope: typeof body.scope === 'string' ? body.scope : undefined,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/auth/index.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Auth namespace: helpers for OAuth2 flows against the platform's
+ * `/auth/business/*` surface. Consumers don't bake a `client_id` into
+ * the SDK itself — every helper takes parameters explicitly so multiple
+ * OAuth clients (dashboard, mobile, BFFs) can share one SDK install.
+ */
+export { generatePKCE, type PkcePair } from './pkce';
+export { createAuthorizeUrl, type AuthorizeUrlInput } from './authorize-url';
+export { exchangeCode, parseTokenResponse, type ExchangeCodeInput, type TokenPair, } from './exchange-code';
+export { refresh, type RefreshInput } from './refresh';
+export { verifyAccessToken } from './verify';
+export { getIssuer, getExpiry } from './issuer';
+import { generatePKCE } from './pkce';
+import { createAuthorizeUrl } from './authorize-url';
+import { exchangeCode } from './exchange-code';
+import { refresh } from './refresh';
+import { verifyAccessToken } from './verify';
+import { getIssuer, getExpiry } from './issuer';
+/**
+ * Default singleton namespace for callers using the package singleton.
+ *   import { auth } from '@uengage.io/platform-sdk';
+ *   const pkce = auth.generatePKCE();
+ */
+export declare const auth: {
+    generatePKCE: typeof generatePKCE;
+    createAuthorizeUrl: typeof createAuthorizeUrl;
+    exchangeCode: typeof exchangeCode;
+    refresh: typeof refresh;
+    verifyAccessToken: typeof verifyAccessToken;
+    getIssuer: typeof getIssuer;
+    getExpiry: typeof getExpiry;
+};

package/dist/auth/index.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.auth = exports.getExpiry = exports.getIssuer = exports.verifyAccessToken = exports.refresh = exports.parseTokenResponse = exports.exchangeCode = exports.createAuthorizeUrl = exports.generatePKCE = void 0;
+/**
+ * Auth namespace: helpers for OAuth2 flows against the platform's
+ * `/auth/business/*` surface. Consumers don't bake a `client_id` into
+ * the SDK itself — every helper takes parameters explicitly so multiple
+ * OAuth clients (dashboard, mobile, BFFs) can share one SDK install.
+ */
+var pkce_1 = require("./pkce");
+Object.defineProperty(exports, "generatePKCE", { enumerable: true, get: function () { return pkce_1.generatePKCE; } });
+var authorize_url_1 = require("./authorize-url");
+Object.defineProperty(exports, "createAuthorizeUrl", { enumerable: true, get: function () { return authorize_url_1.createAuthorizeUrl; } });
+var exchange_code_1 = require("./exchange-code");
+Object.defineProperty(exports, "exchangeCode", { enumerable: true, get: function () { return exchange_code_1.exchangeCode; } });
+Object.defineProperty(exports, "parseTokenResponse", { enumerable: true, get: function () { return exchange_code_1.parseTokenResponse; } });
+var refresh_1 = require("./refresh");
+Object.defineProperty(exports, "refresh", { enumerable: true, get: function () { return refresh_1.refresh; } });
+var verify_1 = require("./verify");
+Object.defineProperty(exports, "verifyAccessToken", { enumerable: true, get: function () { return verify_1.verifyAccessToken; } });
+var issuer_1 = require("./issuer");
+Object.defineProperty(exports, "getIssuer", { enumerable: true, get: function () { return issuer_1.getIssuer; } });
+Object.defineProperty(exports, "getExpiry", { enumerable: true, get: function () { return issuer_1.getExpiry; } });
+const pkce_2 = require("./pkce");
+const authorize_url_2 = require("./authorize-url");
+const exchange_code_2 = require("./exchange-code");
+const refresh_2 = require("./refresh");
+const verify_2 = require("./verify");
+const issuer_2 = require("./issuer");
+/**
+ * Default singleton namespace for callers using the package singleton.
+ *   import { auth } from '@uengage.io/platform-sdk';
+ *   const pkce = auth.generatePKCE();
+ */
+exports.auth = {
+    generatePKCE: pkce_2.generatePKCE,
+    createAuthorizeUrl: authorize_url_2.createAuthorizeUrl,
+    exchangeCode: exchange_code_2.exchangeCode,
+    refresh: refresh_2.refresh,
+    verifyAccessToken: verify_2.verifyAccessToken,
+    getIssuer: issuer_2.getIssuer,
+    getExpiry: issuer_2.getExpiry,
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/auth/issuer.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 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.
+ */
+export declare function getIssuer(token: string): string | null;
+/** Decode (without verifying) a JWT and return its `exp` claim (unix seconds). */
+export declare function getExpiry(token: string): number | null;

package/dist/auth/issuer.js

@@ -0,0 +1,42 @@
+"use strict";
+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.
+ */
+function getIssuer(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;
+    }
+    catch {
+        return null;
+    }
+}
+/** Decode (without verifying) a JWT and return its `exp` claim (unix seconds). */
+function getExpiry(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.exp === 'number' ? claims.exp : null;
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/auth/pkce.d.ts

@@ -0,0 +1,13 @@
+/**
+ * PKCE (RFC 7636) S256 helper. Browser callers should pull `randomBytes`
+ * via the WebCrypto path instead — this package targets Node + bundlers
+ * that polyfill `node:crypto`. When the SDK ships a browser-only build
+ * we'll add a parallel implementation using `crypto.getRandomValues`.
+ */
+export interface PkcePair {
+    codeVerifier: string;
+    codeChallenge: string;
+    codeChallengeMethod: 'S256';
+}
+export declare function generatePKCE(): PkcePair;
+export declare function base64url(buf: Buffer): string;

package/dist/auth/pkce.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generatePKCE = generatePKCE;
+exports.base64url = base64url;
+const node_crypto_1 = require("node:crypto");
+function generatePKCE() {
+    const verifier = base64url((0, node_crypto_1.randomBytes)(32));
+    const challenge = base64url((0, node_crypto_1.createHash)('sha256').update(verifier).digest());
+    return { codeVerifier: verifier, codeChallenge: challenge, codeChallengeMethod: 'S256' };
+}
+function base64url(buf) {
+    return buf.toString('base64').replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/g, '');
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/auth/refresh.d.ts

@@ -0,0 +1,16 @@
+import { type TokenPair } from './exchange-code';
+export interface RefreshInput {
+    refreshToken: string;
+    /** Current access token; used to read `iss` for routing. */
+    accessToken: string;
+    clientId: string;
+    /** Override issuer-based routing for tests / non-standard flows. */
+    authBaseUrl?: string;
+}
+/**
+ * Trade an old refresh token for a fresh pair. Reads `iss` from the
+ * supplied access token so calls are routed back to the issuing auth
+ * service even when the SDK consumer has multiple issuers configured
+ * (business auth + future customer auth).
+ */
+export declare function refresh(input: RefreshInput): Promise<TokenPair>;

package/dist/auth/refresh.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.refresh = refresh;
+const errors_1 = require("../errors");
+const exchange_code_1 = require("./exchange-code");
+const issuer_1 = require("./issuer");
+/**
+ * Trade an old refresh token for a fresh pair. Reads `iss` from the
+ * supplied access token so calls are routed back to the issuing auth
+ * service even when the SDK consumer has multiple issuers configured
+ * (business auth + future customer auth).
+ */
+async function refresh(input) {
+    const issuer = input.authBaseUrl ?? (0, issuer_1.getIssuer)(input.accessToken);
+    if (!issuer) {
+        throw new errors_1.ConfigError('cannot refresh: access token has no `iss` claim and no authBaseUrl was provided');
+    }
+    const body = new URLSearchParams({
+        grant_type: 'refresh_token',
+        refresh_token: input.refreshToken,
+        client_id: input.clientId,
+    });
+    const res = await fetch(`${issuer}/oauth/token`, {
+        method: 'POST',
+        headers: { 'content-type': 'application/x-www-form-urlencoded' },
+        body: body.toString(),
+    });
+    return (0, exchange_code_1.parseTokenResponse)(res);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVmcmVzaC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9hdXRoL3JlZnJlc2gudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFtQkEsMEJBa0JDO0FBckNELHNDQUF3QztBQUN4QyxtREFBcUU7QUFDckUscUNBQXFDO0FBV3JDOzs7OztHQUtHO0FBQ0ksS0FBSyxVQUFVLE9BQU8sQ0FBQyxLQUFtQjtJQUMvQyxNQUFNLE1BQU0sR0FBRyxLQUFLLENBQUMsV0FBVyxJQUFJLElBQUEsa0JBQVMsRUFBQyxLQUFLLENBQUMsV0FBVyxDQUFDLENBQUM7SUFDakUsSUFBSSxDQUFDLE1BQU0sRUFBRSxDQUFDO1FBQ1osTUFBTSxJQUFJLG9CQUFXLENBQ25CLGlGQUFpRixDQUNsRixDQUFDO0lBQ0osQ0FBQztJQUNELE1BQU0sSUFBSSxHQUFHLElBQUksZUFBZSxDQUFDO1FBQy9CLFVBQVUsRUFBRSxlQUFlO1FBQzNCLGFBQWEsRUFBRSxLQUFLLENBQUMsWUFBWTtRQUNqQyxTQUFTLEVBQUUsS0FBSyxDQUFDLFFBQVE7S0FDMUIsQ0FBQyxDQUFDO0lBQ0gsTUFBTSxHQUFHLEdBQUcsTUFBTSxLQUFLLENBQUMsR0FBRyxNQUFNLGNBQWMsRUFBRTtRQUMvQyxNQUFNLEVBQUUsTUFBTTtRQUNkLE9BQU8sRUFBRSxFQUFFLGNBQWMsRUFBRSxtQ0FBbUMsRUFBRTtRQUNoRSxJQUFJLEVBQUUsSUFBSSxDQUFDLFFBQVEsRUFBRTtLQUN0QixDQUFDLENBQUM7SUFDSCxPQUFPLElBQUEsa0NBQWtCLEVBQUMsR0FBRyxDQUFDLENBQUM7QUFDakMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbmZpZ0Vycm9yIH0gZnJvbSAnLi4vZXJyb3JzJztcbmltcG9ydCB7IHBhcnNlVG9rZW5SZXNwb25zZSwgdHlwZSBUb2tlblBhaXIgfSBmcm9tICcuL2V4Y2hhbmdlLWNvZGUnO1xuaW1wb3J0IHsgZ2V0SXNzdWVyIH0gZnJvbSAnLi9pc3N1ZXInO1xuXG5leHBvcnQgaW50ZXJmYWNlIFJlZnJlc2hJbnB1dCB7XG4gIHJlZnJlc2hUb2tlbjogc3RyaW5nO1xuICAvKiogQ3VycmVudCBhY2Nlc3MgdG9rZW47IHVzZWQgdG8gcmVhZCBgaXNzYCBmb3Igcm91dGluZy4gKi9cbiAgYWNjZXNzVG9rZW46IHN0cmluZztcbiAgY2xpZW50SWQ6IHN0cmluZztcbiAgLyoqIE92ZXJyaWRlIGlzc3Vlci1iYXNlZCByb3V0aW5nIGZvciB0ZXN0cyAvIG5vbi1zdGFuZGFyZCBmbG93cy4gKi9cbiAgYXV0aEJhc2VVcmw/OiBzdHJpbmc7XG59XG5cbi8qKlxuICogVHJhZGUgYW4gb2xkIHJlZnJlc2ggdG9rZW4gZm9yIGEgZnJlc2ggcGFpci4gUmVhZHMgYGlzc2AgZnJvbSB0aGVcbiAqIHN1cHBsaWVkIGFjY2VzcyB0b2tlbiBzbyBjYWxscyBhcmUgcm91dGVkIGJhY2sgdG8gdGhlIGlzc3VpbmcgYXV0aFxuICogc2VydmljZSBldmVuIHdoZW4gdGhlIFNESyBjb25zdW1lciBoYXMgbXVsdGlwbGUgaXNzdWVycyBjb25maWd1cmVkXG4gKiAoYnVzaW5lc3MgYXV0aCArIGZ1dHVyZSBjdXN0b21lciBhdXRoKS5cbiAqL1xuZXhwb3J0IGFzeW5jIGZ1bmN0aW9uIHJlZnJlc2goaW5wdXQ6IFJlZnJlc2hJbnB1dCk6IFByb21pc2U8VG9rZW5QYWlyPiB7XG4gIGNvbnN0IGlzc3VlciA9IGlucHV0LmF1dGhCYXNlVXJsID8/IGdldElzc3VlcihpbnB1dC5hY2Nlc3NUb2tlbik7XG4gIGlmICghaXNzdWVyKSB7XG4gICAgdGhyb3cgbmV3IENvbmZpZ0Vycm9yKFxuICAgICAgJ2Nhbm5vdCByZWZyZXNoOiBhY2Nlc3MgdG9rZW4gaGFzIG5vIGBpc3NgIGNsYWltIGFuZCBubyBhdXRoQmFzZVVybCB3YXMgcHJvdmlkZWQnLFxuICAgICk7XG4gIH1cbiAgY29uc3QgYm9keSA9IG5ldyBVUkxTZWFyY2hQYXJhbXMoe1xuICAgIGdyYW50X3R5cGU6ICdyZWZyZXNoX3Rva2VuJyxcbiAgICByZWZyZXNoX3Rva2VuOiBpbnB1dC5yZWZyZXNoVG9rZW4sXG4gICAgY2xpZW50X2lkOiBpbnB1dC5jbGllbnRJZCxcbiAgfSk7XG4gIGNvbnN0IHJlcyA9IGF3YWl0IGZldGNoKGAke2lzc3Vlcn0vb2F1dGgvdG9rZW5gLCB7XG4gICAgbWV0aG9kOiAnUE9TVCcsXG4gICAgaGVhZGVyczogeyAnY29udGVudC10eXBlJzogJ2FwcGxpY2F0aW9uL3gtd3d3LWZvcm0tdXJsZW5jb2RlZCcgfSxcbiAgICBib2R5OiBib2R5LnRvU3RyaW5nKCksXG4gIH0pO1xuICByZXR1cm4gcGFyc2VUb2tlblJlc3BvbnNlKHJlcyk7XG59XG4iXX0=

package/dist/auth/verify.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Verify an access token: fetches JWKS based on the token's `iss`,
+ * verifies the RSA signature, and returns the claims. Throws on any
+ * failure so callers can `try/catch` once instead of branching on a
+ * boolean.
+ *
+ * The verification itself happens via `jose`'s `jwtVerify`, but to
+ * keep this module lightweight (and to avoid pulling jose into the
+ * Browser bundle when consumers only want the URL helpers) we
+ * dynamic-import it. Tree-shakers will drop the import for code paths
+ * that never call `verifyAccessToken`.
+ */
+export declare function verifyAccessToken(token: string, options?: {
+    audience?: string;
+}): Promise<Record<string, unknown>>;
+/** Test-only: clear the JWKS cache. */
+export declare function _resetJwksCache(): void;

package/dist/auth/verify.js

@@ -0,0 +1,93 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyAccessToken = verifyAccessToken;
+exports._resetJwksCache = _resetJwksCache;
+const errors_1 = require("../errors");
+const issuer_1 = require("./issuer");
+/**
+ * Cache of JWKS documents keyed by issuer URL. Lambda-style: cleared
+ * on cold start, reused for the lifetime of the process. 5-minute
+ * staleness is plenty: when a key is rotated the auth server keeps
+ * publishing both old + new for the access-token TTL window, so the
+ * SDK's slightly stale view never causes a verification miss.
+ */
+const jwksCache = new Map();
+const JWKS_TTL_MS = 5 * 60 * 1000;
+async function getJwks(issuer) {
+    const cached = jwksCache.get(issuer);
+    if (cached && Date.now() - cached.cachedAt < JWKS_TTL_MS)
+        return cached.doc;
+    const res = await fetch(`${issuer}/jwks.json`);
+    if (!res.ok)
+        throw new errors_1.PlatformError(`JWKS fetch failed: HTTP ${res.status}`, { status: res.status });
+    const doc = (await res.json());
+    jwksCache.set(issuer, { doc, cachedAt: Date.now() });
+    return doc;
+}
+/**
+ * Verify an access token: fetches JWKS based on the token's `iss`,
+ * verifies the RSA signature, and returns the claims. Throws on any
+ * failure so callers can `try/catch` once instead of branching on a
+ * boolean.
+ *
+ * The verification itself happens via `jose`'s `jwtVerify`, but to
+ * keep this module lightweight (and to avoid pulling jose into the
+ * Browser bundle when consumers only want the URL helpers) we
+ * dynamic-import it. Tree-shakers will drop the import for code paths
+ * that never call `verifyAccessToken`.
+ */
+async function verifyAccessToken(token, options) {
+    const issuer = (0, issuer_1.getIssuer)(token);
+    if (!issuer)
+        throw new errors_1.ConfigError('access token has no `iss` claim');
+    const { jwtVerify, createLocalJWKSet } = await Promise.resolve().then(() => __importStar(require('jose')));
+    const jwks = createLocalJWKSet({ keys: (await getJwks(issuer)).keys });
+    try {
+        const { payload } = await jwtVerify(token, jwks, {
+            issuer,
+            audience: options?.audience,
+        });
+        return payload;
+    }
+    catch (err) {
+        throw new errors_1.AuthenticationError('access token verification failed', { cause: err });
+    }
+}
+/** Test-only: clear the JWKS cache. */
+function _resetJwksCache() {
+    jwksCache.clear();
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/business/client.d.ts

@@ -6,9 +6,9 @@ export interface BusinessGetOptions {
 export interface BusinessClient {
     config(input: PlatformConfigInput): BusinessClient;
     auth(input: PlatformAuthInput | PlatformAuth): BusinessClient;
-    /** GET /v1/business/:id - returns the record or throws BusinessApiError. */
+    /** GET /v1/businesses/:id - returns the record or throws BusinessApiError. */
     get(id: number, opts?: BusinessGetOptions): Promise<BusinessRecord>;
-    /** GET /v1/business/bulk - returns matched records (missing ids dropped). */
+    /** GET /v1/businesses?ids= - returns matched records (missing ids dropped). */
     bulk(ids: readonly number[], opts?: BusinessGetOptions): Promise<BusinessRecord[]>;
 }
 export declare class BusinessApiError extends Error {