@vuoma/sdk 0.1.0

package/README.md

@@ -0,0 +1,117 @@
+# Vuoma SDK
+
+Framework-neutral JavaScript and TypeScript client for the existing Vuoma v1
+public organization and member account APIs. Works with a host-provided Fetch
+implementation; it imports no React, Svelte, Expo or Supabase runtime. The package
+does not store credentials, read environment variables, create accounts, or
+grant access. This is a local package foundation; registry publication is a
+separate step.
+
+```js
+import { createVuomaClient } from '@vuoma/sdk'
+
+const vuoma = createVuomaClient({
+  apiOrigin: 'http://localhost:5173', // Use your verified Vuoma HTTPS origin in production.
+  organizationSlug: 'your-studio',
+  fetch: globalThis.fetch,
+})
+
+const bootstrap = await vuoma.public.getBootstrap({ includeEvents: true })
+const catalog = await vuoma.public.getCatalog()
+const schedule = await vuoma.public.getSchedule({
+  from: '2026-10-07T00:00:00Z',
+  to: '2026-10-14T00:00:00Z',
+})
+```
+
+No key is needed for these public reads. Schedule timestamps are normalized to
+UTC, and ranges must be positive and at most 63 days. The response preserves
+`schedule.has_more`; when it is true, split the requested range and fetch each
+part rather than displaying the first response as a complete schedule.
+
+## Member account setup
+
+The host owns the current session. Supply an adapter that returns that session
+or `null`, and install returned sign-in/refresh sessions in your host's existing
+secure session boundary. The following transport example is for a controlled
+server or native host; it does not establish a browser cookie session.
+
+```js
+let session = null // Example in-memory host state; no SDK persistence.
+const vuoma = createVuomaClient({
+  apiOrigin: 'http://localhost:5173',
+  organizationSlug: 'your-studio',
+  tokenAdapter: { getSession: () => session },
+})
+
+session = await vuoma.auth.signIn({ email, password })
+const account = await vuoma.member.getProfile()
+const commerce = await vuoma.member.getCommerce()
+const updated = await vuoma.member.updateProfile({ first_name: 'Sam' })
+
+session = await vuoma.auth.refresh({ refreshToken: session.refresh_token })
+const previous = session
+session = null // Immediately remove local access when signing out.
+await vuoma.auth.signOut({ refreshToken: previous.refresh_token })
+```
+
+For websites, keep access/refresh tokens in the site's server adapter and Secure
+HttpOnly cookies. Browser components call the site's same-origin backend. The
+existing Svelte account components and member-site adapter implement this
+pattern. Never serialize a member session into page loader data. For React
+Native, keep refresh tokens in Keychain/Keystore through a secure-storage adapter,
+keep access tokens in memory, and refresh through the documented member route.
+Refresh scheduling, retries and persistence remain host responsibilities.
+
+The SDK uses `credentials: 'omit'`, prevents redirects, and sends member access
+tokens only to its exact configured origin and organization. It rejects missing,
+expired, cross-organization, platform-account, organization API, identity-only
+OAuth and Supabase secret credentials in member calls. JWT decoding is a local
+credential-kind check; only the API verifies signatures and current permissions.
+Optionally configure `organizationId` for an additional JWT tenant check. Private
+responses are discarded if the adapter reports an account change during a call.
+
+Responses are checked for their v1 envelope, required display fields and relevant
+organization/customer/range binding. Additional wire fields are preserved;
+nested commerce records are typed as JSON records. These checks are not complete
+business/financial validation, and do not replace the server's authorization or
+canonical schemas. The configured response byte limit is checked after reading
+the response text and against a supplied Content-Length header.
+
+## Keys and client IDs
+
+- **Organization integration/delegated API keys** are confidential server
+  credentials. Never put them in a website bundle, native binary, URL or SDK
+  token adapter. They do not sign a customer in.
+- **Registered OAuth client IDs** are public app identifiers. Existing shared
+  sign-in grants only `openid`, `profile` and `email`; those identity tokens do
+  not authorize this SDK's member account methods.
+- **Supabase publishable keys** are public configuration for direct Supabase
+  clients. This SDK calls Vuoma's API and requires no Supabase key.
+- **Member access/refresh tokens** belong to the signed-in organization customer.
+  Platform-account sessions are a separate boundary and are intentionally not
+  accepted by this member client.
+
+This package adds no OAuth grant, CORS policy or backend permission. A third-party
+website still needs its backend adapter. Independent app authorization and
+app-scoped member grants are separate platform work; a public app ID alone must
+never authorize private account data.
+
+Supported routes are public `/api/v1/o/{slug}/member/{bootstrap,schedule,catalog}`;
+member sign-in, profile GET/PATCH and commerce GET; plus the existing global
+member refresh/sign-out routes. Signup, payments, booking mutations, uploads,
+staff administration and platform-account sessions are outside this initial SDK.
+
+## Verification and package artifact
+
+```sh
+npm test
+npm run verify
+```
+
+Verification tests the actual wire route/header/session boundaries and creates
+an installable npm archive under `artifacts/`. It checks the archive's public
+file list and loads the packed module in an isolated temporary directory.
+Nothing is published and no registry authentication is attempted. The inherited
+license remains `UNLICENSED`; `private: false` prepares packaging without granting
+open-source licensing rights.

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@vuoma/sdk",
+  "version": "0.1.0",
+  "description": "Framework-neutral client for Vuoma public organization and member account APIs",
+  "type": "module",
+  "private": false,
+  "license": "UNLICENSED",
+  "files": ["src", "README.md"],
+  "exports": {
+    ".": { "types": "./src/index.d.ts", "import": "./src/index.js" }
+  },
+  "types": "./src/index.d.ts",
+  "sideEffects": false,
+  "scripts": {
+    "test": "node --test tests/*.test.mjs",
+    "verify": "npm test && node scripts/verify-package.mjs",
+    "prepack": "npm test"
+  },
+  "publishConfig": { "access": "public" },
+  "engines": { "node": ">=20" }
+}

package/src/index.d.ts

@@ -0,0 +1,134 @@
+export type JsonValue = null | boolean | number | string | JsonValue[] | { [key: string]: JsonValue }
+export interface ApiRecord { [key: string]: JsonValue }
+export interface RequestOptions { signal?: AbortSignal }
+
+/** Existing organization-member session wire shape; never an integration key. */
+export interface MemberAuthSession {
+  access_token: string
+  refresh_token: string
+  expires_at: number
+  organization_slug: string
+  customer: { id: string; display_name: string; email: string }
+}
+
+export interface MemberTokenAdapter {
+  /** Return the host's current session, or null after sign-out/account change. */
+  getSession(): MemberAuthSession | null | Promise<MemberAuthSession | null>
+}
+
+export interface VuomaClientOptions {
+  /** Origin only. HTTPS required except HTTP loopback during local development. */
+  apiOrigin: string
+  organizationSlug: string
+  /** Optional stronger client-side tenant check against the member JWT claim. */
+  organizationId?: string
+  fetch?: typeof globalThis.fetch
+  tokenAdapter?: MemberTokenAdapter
+  /** Default 2 MiB; accepted range 1 KiB–16 MiB. */
+  maximumResponseBytes?: number
+}
+
+export interface PublicOrganization extends ApiRecord {
+  slug: string
+  name: string
+}
+
+/** Selected stable display fields; additional existing API fields are preserved. */
+export interface PublicSession extends ApiRecord {
+  id: string
+  name: string
+  starts_at: string
+  ends_at: string
+  location: ApiRecord
+}
+
+export interface MemberBootstrap {
+  api_version: 1
+  generated_at: string
+  organization: PublicOrganization
+  locations: ApiRecord[]
+  schedule: { range_end: string; sessions: PublicSession[] }
+  features: ApiRecord
+}
+
+export interface MemberPublicSchedule {
+  api_version: 1
+  generated_at: string
+  schedule: { from: string; to: string; has_more: boolean; sessions: PublicSession[] }
+}
+
+export interface PublicOffer extends ApiRecord {
+  id: string
+  name: string
+  prices: ApiRecord[]
+}
+
+export interface MemberPublicCatalog {
+  api_version: 1
+  generated_at: string
+  purchases_available: boolean
+  credit_purchase?: ApiRecord | null
+  catalog: { offers: PublicOffer[] }
+}
+
+export interface MemberProfile {
+  api_version: 1
+  profile: {
+    customer_id: string
+    display_name: string
+    first_name: string | null
+    last_name: string | null
+    email: string | null
+    phone: string | null
+    birth_date: string | null
+    profile_photo: ApiRecord | null
+  }
+}
+
+export interface MemberProfileChanges {
+  first_name?: string | null
+  last_name?: string | null
+  phone?: string | null
+  birth_date?: string | null
+}
+
+/** Read-only snapshot. Nested commerce records retain the existing wire fields. */
+export interface MemberCommerceSnapshot {
+  api_version: 1
+  generated_at: string
+  cancellation_notice_minutes: number
+  cancellation_policy?: ApiRecord | null
+  catalog: { offers: ApiRecord[] }
+  entitlements: ApiRecord[]
+  bookings: ApiRecord[]
+  orders: ApiRecord[]
+}
+
+export interface VuomaClient {
+  readonly public: {
+    getBootstrap(options?: RequestOptions & { includeEvents?: boolean }): Promise<MemberBootstrap>
+    /** Returns one server range. If has_more is true, split the range and request again. */
+    getSchedule(options: RequestOptions & { from: string; to: string; includeEvents?: boolean; fresh?: boolean }): Promise<MemberPublicSchedule>
+    getCatalog(options?: RequestOptions & { includeCreditPurchases?: boolean }): Promise<MemberPublicCatalog>
+  }
+  readonly auth: {
+    /** Returns credentials to the host; the SDK neither stores nor installs them. */
+    signIn(options: RequestOptions & { email: string; password: string }): Promise<MemberAuthSession>
+    refresh(options: RequestOptions & { refreshToken: string }): Promise<MemberAuthSession>
+    /** Clear host-held credentials even if remote sign-out needs a retry. */
+    signOut(options: RequestOptions & { refreshToken: string }): Promise<void>
+  }
+  readonly member: {
+    getProfile(options?: RequestOptions): Promise<MemberProfile>
+    updateProfile(changes: MemberProfileChanges, options?: RequestOptions): Promise<MemberProfile>
+    getCommerce(options?: RequestOptions): Promise<MemberCommerceSnapshot>
+  }
+}
+
+export class VuomaApiError extends Error {
+  readonly status: number
+  readonly code: string
+  constructor(status: number, code: string, message: string)
+}
+
+export function createVuomaClient(options: VuomaClientOptions): VuomaClient

package/src/index.js

@@ -0,0 +1,259 @@
+// Public package: no environment reads, provider clients, persistence or secrets.
+const slugPattern = /^[a-z0-9]+(?:-[a-z0-9]+)*$/u
+const uuidPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu
+const timestampPattern = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/u
+const maximumRange = 63 * 24 * 60 * 60 * 1000
+const object = value => value !== null && typeof value === "object" && !Array.isArray(value)
+const uuid = value => typeof value === "string" && uuidPattern.test(value)
+const timestamp = value => typeof value === "string" && timestampPattern.test(value) && Number.isFinite(Date.parse(value)) &&
+  new Date(`${value.slice(0, 10)}T00:00:00Z`).toISOString().slice(0, 10) === value.slice(0, 10)
+
+export class VuomaApiError extends Error {
+  /** @param {number} status @param {string} code @param {string} message */
+  constructor(status, code, message) {
+    super(message)
+    this.name = "VuomaApiError"
+    this.status = status
+    this.code = code
+  }
+}
+
+function invalidResponse() {
+  return new VuomaApiError(502, "invalid_response", "Vuoma returned an invalid response.")
+}
+function invalidSession() {
+  return new VuomaApiError(401, "member_session_required", "Sign in to this organization to continue.")
+}
+
+/** Decode only to reject incorrect credential kinds. The API verifies authenticity. */
+function memberClaims(token) {
+  if (typeof token !== "string" || token.length < 20 || token.length > 4096) throw invalidSession()
+  const segments = token.split(".")
+  if (segments.length !== 3 || segments.some(part => !/^[A-Za-z0-9_-]+$/u.test(part))) throw invalidSession()
+  try {
+    const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
+    const encoded = segments[1].replace(/-/gu, "+").replace(/_/gu, "/")
+    if (encoded.length % 4 === 1) throw invalidSession()
+    let bits = 0, buffer = 0, escaped = ""
+    for (const character of encoded) {
+      buffer = (buffer << 6) | alphabet.indexOf(character)
+      bits += 6
+      if (bits >= 8) {
+        bits -= 8
+        escaped += `%${((buffer >> bits) & 255).toString(16).padStart(2, "0")}`
+      }
+    }
+    const claims = JSON.parse(decodeURIComponent(escaped))
+    if (!object(claims) || !uuid(claims.sub) || !uuid(claims.session_id) ||
+      claims.role !== "authenticated" || !object(claims.app_metadata) ||
+      claims.app_metadata.account_kind !== "organization_member" ||
+      !uuid(claims.app_metadata.organization_id) || !Number.isSafeInteger(claims.exp) ||
+      claims.exp <= Math.floor(Date.now() / 1000)) throw invalidSession()
+    return claims
+  } catch {
+    throw invalidSession()
+  }
+}
+
+function verifySession(value, organizationSlug, organizationId) {
+  if (!object(value) || value.organization_slug !== organizationSlug ||
+    !object(value.customer) || !uuid(value.customer.id) ||
+    typeof value.customer.display_name !== "string" || !value.customer.display_name ||
+    typeof value.customer.email !== "string" || !value.customer.email.includes("@") ||
+    !Number.isSafeInteger(value.expires_at) || value.expires_at <= Math.floor(Date.now() / 1000)) throw invalidSession()
+  const claims = memberClaims(value.access_token)
+  if (claims.exp !== value.expires_at || (organizationId && claims.app_metadata.organization_id !== organizationId)) throw invalidSession()
+  return { session: value, identity: `${organizationSlug}:${value.customer.id}:${claims.sub}:${claims.session_id}:${claims.app_metadata.organization_id}` }
+}
+
+function refreshToken(value) {
+  if (typeof value !== "string" || !value.length || value.length > 1024 || /[\s\u0000-\u001f\u007f]/u.test(value) ||
+    /^(?:chapi_|chsignin_|sb_secret_|sb_publishable_)/u.test(value)) throw invalidSession()
+  return value
+}
+
+function envelope(value) {
+  if (!object(value) || value.api_version !== 1) throw invalidResponse()
+  return value
+}
+
+function sessionResponse(value, organizationSlug, organizationId) {
+  try {
+    const { session } = verifySession(value, organizationSlug, organizationId)
+    refreshToken(session.refresh_token)
+    // Project the established wire session; never retain it inside the client.
+    return { access_token: session.access_token, refresh_token: session.refresh_token,
+      expires_at: session.expires_at, organization_slug: session.organization_slug,
+      customer: { id: session.customer.id, display_name: session.customer.display_name, email: session.customer.email } }
+  } catch {
+    throw invalidResponse()
+  }
+}
+
+function publicSessions(value) {
+  if (!Array.isArray(value) || value.some(item => !object(item) || !uuid(item.id) ||
+    typeof item.name !== "string" || !timestamp(item.starts_at) || !timestamp(item.ends_at) ||
+    Date.parse(item.ends_at) <= Date.parse(item.starts_at) || !object(item.location))) throw invalidResponse()
+  return value
+}
+
+function catalog(value) {
+  envelope(value)
+  if (!timestamp(value.generated_at) || typeof value.purchases_available !== "boolean" ||
+    !object(value.catalog) || !Array.isArray(value.catalog.offers) || value.catalog.offers.length > 100 ||
+    value.catalog.offers.some(offer => !object(offer) || !uuid(offer.id) || typeof offer.name !== "string" || !Array.isArray(offer.prices) || offer.prices.some(price => !object(price))) ||
+    (!value.purchases_available && value.catalog.offers.length)) throw invalidResponse()
+  return value
+}
+
+function utf8Length(text) {
+  let length = 0
+  for (const character of text) {
+    const code = character.codePointAt(0)
+    length += code <= 0x7f ? 1 : code <= 0x7ff ? 2 : code <= 0xffff ? 3 : 4
+  }
+  return length
+}
+
+/**
+ * Create an isolated client. No implicit API host, cookies, environment or storage.
+ * @param {import('./index.js').VuomaClientOptions} options
+ * @returns {import('./index.js').VuomaClient}
+ */
+export function createVuomaClient(options) {
+  if (!object(options) || typeof options.apiOrigin !== "string" || /[\s\\]/u.test(options.apiOrigin)) throw new TypeError("An explicit API origin is required.")
+  let origin
+  try {
+    const url = new URL(options.apiOrigin)
+    const loopback = ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname)
+    if ((url.protocol !== "https:" && !(url.protocol === "http:" && loopback)) ||
+      url.username || url.password || url.pathname !== "/" || url.search || url.hash) throw new Error()
+    origin = url.origin
+  } catch { throw new TypeError("Use an HTTPS API origin, or HTTP on loopback for local development.") }
+  const organizationSlug = options.organizationSlug
+  if (typeof organizationSlug !== "string" || organizationSlug.length < 2 || organizationSlug.length > 80 || !slugPattern.test(organizationSlug)) throw new TypeError("Use an exact organization slug.")
+  const organizationId = options.organizationId
+  if (organizationId !== undefined && !uuid(organizationId)) throw new TypeError("Use a valid organization ID.")
+  const requestFetch = options.fetch ?? globalThis.fetch
+  if (typeof requestFetch !== "function") throw new TypeError("A fetch implementation is required.")
+  const tokenAdapter = options.tokenAdapter
+  if (tokenAdapter !== undefined && (!object(tokenAdapter) || typeof tokenAdapter.getSession !== "function")) throw new TypeError("Provide a member session adapter.")
+  const maximumBytes = options.maximumResponseBytes ?? 2 * 1024 * 1024
+  if (!Number.isSafeInteger(maximumBytes) || maximumBytes < 1024 || maximumBytes > 16 * 1024 * 1024) throw new TypeError("Use a response limit between 1 KiB and 16 MiB.")
+  const memberRoot = `/api/v1/o/${organizationSlug}/member`
+
+  async function readSession() {
+    if (!tokenAdapter) throw invalidSession()
+    return verifySession(await tokenAdapter.getSession(), organizationSlug, organizationId)
+  }
+
+  async function request(path, { method = "GET", body, accessToken, signal, query, privateResponse = false, empty = false } = {}) {
+    const url = new URL(path, origin)
+    if (query) for (const [key, value] of Object.entries(query)) url.searchParams.set(key, value)
+    const headers = { accept: "application/json" }
+    if (body !== undefined) headers["content-type"] = "application/json"
+    if (accessToken) headers.authorization = `Bearer ${accessToken}`
+    const response = await requestFetch(url.href, {
+      method, headers, signal, credentials: "omit", redirect: "error", referrerPolicy: "no-referrer",
+      cache: privateResponse ? "no-store" : "default",
+      ...(body === undefined ? {} : { body: JSON.stringify(body) }),
+    })
+    // Custom fetch adapters must also honor the no-redirect destination boundary.
+    if (response.redirected || (response.url && response.url !== url.href)) throw invalidResponse()
+    const declared = Number(response.headers.get("content-length"))
+    if (Number.isFinite(declared) && declared > maximumBytes) throw invalidResponse()
+    const text = await response.text()
+    if (utf8Length(text) > maximumBytes) throw invalidResponse()
+    let value
+    try { value = text ? JSON.parse(text) : null } catch { if (response.ok) throw invalidResponse() }
+    if (!response.ok) {
+      const code = object(value) && typeof value.code === "string" && /^[a-z][a-z0-9_]{0,80}$/u.test(value.code) &&
+        !/^(?:chapi_|chsignin_|sb_secret_|sb_publishable_)/u.test(value.code) ? value.code : "api_request_failed"
+      const message = response.status === 401 ? "Sign in again to continue." : response.status === 403 ? "Your account cannot perform this operation." :
+        response.status === 429 ? "Too many requests. Try again shortly." : "The Vuoma request could not be completed."
+      throw new VuomaApiError(response.status, code, message)
+    }
+    if (empty) {
+      if (response.status !== 204 || text) throw invalidResponse()
+      return
+    }
+    if (!object(value)) throw invalidResponse()
+    return value
+  }
+
+  async function accountRequest(path, requestOptions = {}, parse = value => value) {
+    const initial = await readSession()
+    const value = await request(`${memberRoot}${path}`, { ...requestOptions, accessToken: initial.session.access_token, privateResponse: true })
+    const current = await readSession()
+    if (current.identity !== initial.identity) throw new VuomaApiError(401, "member_session_changed", "Your signed-in account changed. Try again.")
+    return parse(value, initial.session.customer.id)
+  }
+
+  function profile(value, customerId) {
+    envelope(value)
+    if (!object(value.profile) || value.profile.customer_id !== customerId || typeof value.profile.display_name !== "string") throw invalidResponse()
+    for (const field of ["first_name", "last_name", "email", "phone", "birth_date"]) {
+      if (value.profile[field] !== null && typeof value.profile[field] !== "string") throw invalidResponse()
+    }
+    if (value.profile.profile_photo !== null && !object(value.profile.profile_photo)) throw invalidResponse()
+    return value
+  }
+
+  return Object.freeze({
+    public: Object.freeze({
+      async getBootstrap({ includeEvents = false, signal } = {}) {
+        const value = envelope(await request(`${memberRoot}/bootstrap`, { signal, query: includeEvents ? { include_events: "true" } : undefined }))
+        if (!timestamp(value.generated_at) || !object(value.organization) || value.organization.slug !== organizationSlug ||
+          typeof value.organization.name !== "string" || !Array.isArray(value.locations) || value.locations.some(location => !object(location)) || !object(value.features) || !object(value.schedule) ||
+          !timestamp(value.schedule.range_end)) throw invalidResponse()
+        publicSessions(value.schedule.sessions)
+        return value
+      },
+      async getSchedule({ from, to, includeEvents = false, fresh = false, signal }) {
+        if (!timestamp(from) || !timestamp(to) || Date.parse(to) <= Date.parse(from) || Date.parse(to) - Date.parse(from) > maximumRange) throw new TypeError("Choose RFC 3339 timestamps spanning at most 63 days.")
+        from = new Date(from).toISOString()
+        to = new Date(to).toISOString()
+        const query = { from, to, ...(includeEvents ? { include_events: "true" } : {}), ...(fresh ? { refresh: "1" } : {}) }
+        const value = envelope(await request(`${memberRoot}/schedule`, { query, signal, privateResponse: fresh }))
+        if (!timestamp(value.generated_at) || !object(value.schedule) || value.schedule.from !== from || value.schedule.to !== to ||
+          typeof value.schedule.has_more !== "boolean") throw invalidResponse()
+        publicSessions(value.schedule.sessions)
+        if (value.schedule.sessions.length > 250) throw invalidResponse()
+        return value
+      },
+      async getCatalog({ includeCreditPurchases = false, signal } = {}) {
+        return catalog(await request(`${memberRoot}/catalog`, { signal, query: includeCreditPurchases ? { include_credit_purchases: "true" } : undefined }))
+      },
+    }),
+    auth: Object.freeze({
+      async signIn({ email, password, signal }) {
+        if (typeof email !== "string" || !email.trim() || email.length > 320 || typeof password !== "string" || !password || password.length > 1024) throw new TypeError("Provide an email address and password.")
+        return sessionResponse(await request(`${memberRoot}/auth/sign-in`, { method: "POST", body: { email, password }, signal, privateResponse: true }), organizationSlug, organizationId)
+      },
+      async refresh({ refreshToken: token, signal }) {
+        return sessionResponse(await request("/api/v1/member/auth/refresh", { method: "POST", body: { refresh_token: refreshToken(token) }, signal, privateResponse: true }), organizationSlug, organizationId)
+      },
+      async signOut({ refreshToken: token, signal }) {
+        await request("/api/v1/member/auth/sign-out", { method: "POST", body: { refresh_token: refreshToken(token) }, signal, privateResponse: true, empty: true })
+      },
+    }),
+    member: Object.freeze({
+      getProfile({ signal } = {}) { return accountRequest("/profile", { signal }, profile) },
+      updateProfile(changes, { signal } = {}) {
+        const allowed = new Set(["first_name", "last_name", "phone", "birth_date"])
+        if (!object(changes) || !Object.keys(changes).length || Object.entries(changes).some(([key, value]) =>
+          !allowed.has(key) || (value !== null && typeof value !== "string") || (typeof value === "string" && value.length > 320))) throw new TypeError("Provide supported member profile fields.")
+        return accountRequest("/profile", { method: "PATCH", body: changes, signal }, profile)
+      },
+      getCommerce({ signal } = {}) {
+        return accountRequest("/commerce", { signal }, value => {
+          envelope(value)
+          if (!timestamp(value.generated_at) || !object(value.catalog) || !Array.isArray(value.catalog.offers) || value.catalog.offers.some(offer => !object(offer)) ||
+            [value.entitlements, value.bookings, value.orders].some(records => !Array.isArray(records) || records.some(record => !object(record))) ||
+            !Number.isSafeInteger(value.cancellation_notice_minutes) || value.cancellation_notice_minutes < 0) throw invalidResponse()
+          return value
+        })
+      },
+    }),
+  })
+}