@layers/amba-react-native 1.0.1 → 2.0.0

package/dist/index.cjs

@@ -53,70 +53,278 @@ var AmbaApiError = class extends Error {
 		Object.setPrototypeOf(this, new.target.prototype);
 	}
 };
-/**
-* Best-effort: pull a stable error code out of a Rust `AmbaError`
-* Display string. Used by `toAmbaApiError` when the underlying thrown
-* value is a generic `Error` produced by `wasm-bindgen`'s `JsError::new`.
-*
-* Keep in sync with `sdks/core/src/error.rs::AmbaError`'s `#[error]`
-* format strings — but the parser falls back to UNKNOWN_ERROR for any
-* pattern it doesn't recognize, so a stale match list isn't a footgun,
-* just a quality-of-life regression.
-*/
-function codeFromMessage(message) {
-	if (message.startsWith("Unauthorized")) return "UNAUTHORIZED";
-	if (message.startsWith("Forbidden")) return "FORBIDDEN";
-	if (message.startsWith("Not found")) return "NOT_FOUND";
-	if (message.startsWith("Conflict")) return "CONFLICT";
-	if (message.startsWith("Rate limited")) return "RATE_LIMITED";
-	if (message.startsWith("Validation error")) return "VALIDATION_ERROR";
-	if (message.startsWith("Network error")) return "NETWORK_ERROR";
-	if (message.startsWith("HTTP error")) return "HTTP_ERROR";
-	if (message.startsWith("Circuit breaker")) return "CIRCUIT_OPEN";
-	if (message.startsWith("Consent not granted")) return "CONSENT_NOT_GRANTED";
-	if (message.includes("not initialized")) return "NOT_INITIALIZED";
-	if (message.startsWith("Invalid configuration")) return "INVALID_CONFIG";
-	if (message.startsWith("Invalid argument")) return "INVALID_ARGUMENT";
-	return "UNKNOWN_ERROR";
+
+//#endregion
+//#region src/http-client.ts
+/** Default amba API endpoint. */
+const DEFAULT_BASE_URL = "https://api.amba.dev";
+var AmbaHttpClient = class {
+	apiKey;
+	baseUrl;
+	sdkPlatform;
+	sdkVersionHeader;
+	identity;
+	fetchImpl;
+	constructor(opts) {
+		this.apiKey = opts.apiKey;
+		this.baseUrl = opts.baseUrl.replace(/\/+$/, "");
+		this.sdkPlatform = opts.sdkPlatform;
+		this.sdkVersionHeader = opts.sdkVersionHeader;
+		this.identity = opts.identity;
+		this.fetchImpl = opts.fetchImpl ?? globalThis.fetch.bind(globalThis);
+	}
+	/** Build the absolute URL for an API path, optionally with a query string. */
+	url(path, query) {
+		const base = this.baseUrl + path;
+		if (!query) return base;
+		const parts = [];
+		for (const k of Object.keys(query)) {
+			const v = query[k];
+			if (v === void 0 || v === null) continue;
+			parts.push(`${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`);
+		}
+		if (parts.length === 0) return base;
+		return `${base}?${parts.join("&")}`;
+	}
+	/** Build the standard request headers for the current identity state. */
+	buildHeaders(extra) {
+		const h = {
+			"X-Api-Key": this.apiKey,
+			"X-SDK-Platform": this.sdkPlatform,
+			"X-SDK-Version": this.sdkVersionHeader,
+			"Content-Type": "application/json",
+			Accept: "application/json",
+			...extra
+		};
+		const tok = this.identity.getSessionToken();
+		if (tok) h.Authorization = `Bearer ${tok}`;
+		return h;
+	}
+	async get(path, query) {
+		return this.request("GET", path, void 0, query);
+	}
+	async post(path, body, query) {
+		return this.request("POST", path, body, query);
+	}
+	async patch(path, body) {
+		return this.request("PATCH", path, body);
+	}
+	async delete(path) {
+		return this.request("DELETE", path);
+	}
+	async request(method, path, body, query) {
+		const url = this.url(path, query);
+		const init = {
+			method,
+			headers: this.buildHeaders(),
+			body: body === void 0 ? void 0 : JSON.stringify(body ?? {})
+		};
+		let response;
+		try {
+			response = await this.fetchImpl(url, init);
+		} catch (err) {
+			throw new AmbaApiError("NETWORK_ERROR", `Network error: ${err instanceof Error ? err.message : typeof err === "string" ? err : "fetch failed"}`, err);
+		}
+		return parseResponse(response);
+	}
+};
+async function parseResponse(response) {
+	if (response.status === 204) return null;
+	const text = await response.text();
+	const isJson = (response.headers.get("content-type") ?? "").includes("application/json");
+	if (!response.ok) throw mapHttpError(response, text, isJson);
+	if (text === "") return null;
+	if (isJson) try {
+		return JSON.parse(text);
+	} catch (err) {
+		throw new AmbaApiError("HTTP_ERROR", `Failed to parse JSON response: ${err instanceof Error ? err.message : String(err)}`, { body: text });
+	}
+	return text;
+}
+function mapHttpError(response, rawBody, isJson) {
+	let parsed = void 0;
+	let message = rawBody || `HTTP ${response.status}`;
+	let code;
+	if (isJson && rawBody) {
+		try {
+			parsed = JSON.parse(rawBody);
+		} catch {
+			parsed = void 0;
+		}
+		const innerErr = parsed?.error;
+		if (innerErr && typeof innerErr === "object") {
+			if (typeof innerErr.code === "string") code = innerErr.code;
+			if (typeof innerErr.message === "string") message = innerErr.message;
+		}
+	}
+	switch (response.status) {
+		case 401: return new AmbaApiError(code ?? "UNAUTHORIZED", message, parsed);
+		case 403: return new AmbaApiError(code ?? "FORBIDDEN", message, parsed);
+		case 404: return new AmbaApiError(code ?? "NOT_FOUND", message, parsed);
+		case 409: return new AmbaApiError(code ?? "CONFLICT", message, parsed);
+		case 422: return new AmbaApiError(code ?? "VALIDATION_ERROR", message, parsed);
+		case 429: {
+			const retryAfter = response.headers.get("retry-after") ?? "unspecified";
+			const serverGaveMessage = message !== rawBody && message !== `HTTP ${response.status}`;
+			return new AmbaApiError(code ?? "RATE_LIMITED", serverGaveMessage ? message : `Rate limited (retry after ${retryAfter})`, parsed);
+		}
+		default: return new AmbaApiError(code ?? "HTTP_ERROR", message, parsed ?? {
+			status: response.status,
+			body: rawBody
+		});
+	}
+}
+
+//#endregion
+//#region src/uuid.ts
+function getRandomBytes(n) {
+	const bytes = new Uint8Array(n);
+	if (typeof globalThis.crypto?.getRandomValues === "function") {
+		globalThis.crypto.getRandomValues(bytes);
+		return bytes;
+	}
+	for (let i = 0; i < n; i++) bytes[i] = Math.floor(Math.random() * 256);
+	return bytes;
 }
 /**
-* Coerce any thrown value into an `AmbaApiError`. Idempotent — passing
-* an existing `AmbaApiError` returns it unchanged so wrappers can stack
-* without re-wrapping.
-*
-* Heuristics:
-* 1. Existing `AmbaApiError` → returned as-is.
-* 2. Object with `.code` → use that code + `.message` + `.details`.
-* 3. `Error` (e.g. WASM JsError) → infer code from message prefix.
-* 4. Anything else → stringify and tag UNKNOWN_ERROR.
+* Generate a UUID v4 (random) per RFC 4122. Wire shape:
+* `xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx` where `y ∈ {8,9,a,b}`.
 */
-function toAmbaApiError(err) {
-	if (err instanceof AmbaApiError) return err;
-	if (err && typeof err === "object") {
-		const obj = err;
-		if (typeof obj.code === "string") return new AmbaApiError(obj.code, typeof obj.message === "string" ? obj.message : "unknown", obj.details);
-	}
-	if (err instanceof Error) return new AmbaApiError(codeFromMessage(err.message), err.message);
-	return new AmbaApiError("UNKNOWN_ERROR", String(err));
+function uuidv4() {
+	const b = getRandomBytes(16);
+	b[6] = b[6] & 15 | 64;
+	b[8] = b[8] & 63 | 128;
+	const h = Array.from(b, (v) => v.toString(16).padStart(2, "0"));
+	return h.slice(0, 4).join("") + "-" + h.slice(4, 6).join("") + "-" + h.slice(6, 8).join("") + "-" + h.slice(8, 10).join("") + "-" + h.slice(10, 16).join("");
 }
 
 //#endregion
-//#region src/index.ts
-let coreInstance = null;
-function requireCore() {
-	if (!coreInstance) throw new AmbaApiError("NOT_INITIALIZED", "@layers/amba-react-native: SDK not configured. Call Amba.configure({ apiKey }) at app start.");
-	return coreInstance;
+//#region src/identity.ts
+/** Storage key under the configured prefix. Bumped when shape changes. */
+const IDENTITY_KEY = "identity_v1";
+function isExpired(expiresAt) {
+	if (!expiresAt) return false;
+	const t = Date.parse(expiresAt);
+	if (Number.isNaN(t)) return false;
+	return t <= Date.now();
 }
 /**
-* Run a single WASM-core call and rewrap any thrown value into a
-* stable `AmbaApiError`. Mirrors the helper in `@layers/amba-web`.
+* The SDK's identity state — held in memory after hydration, persisted
+* to AsyncStorage on every mutation. All methods are sync after
+* `hydrate()` resolves.
 */
-async function coreCall(fn) {
-	try {
-		return await fn(requireCore());
-	} catch (err) {
-		throw toAmbaApiError(err);
+var IdentityStore = class IdentityStore {
+	anonymousId;
+	appUserId = null;
+	sessionToken = null;
+	refreshToken = null;
+	expiresAt = null;
+	constructor(persistence, seed) {
+		this.persistence = persistence;
+		this.anonymousId = seed.anonymous_id;
+		this.appUserId = seed.app_user_id;
+		this.sessionToken = seed.session_token;
+		this.refreshToken = seed.refresh_token;
+		this.expiresAt = seed.expires_at;
+	}
+	/**
+	* Build a store, hydrating any prior identity from AsyncStorage.
+	* If no prior identity exists, a fresh `anonymous_id` is minted.
+	* Expired session tokens are dropped at hydration (the refresh token
+	* survives so callers can `auth.refresh()` to mint a new pair).
+	*/
+	static async create(persistence) {
+		const raw = await persistence.read(IDENTITY_KEY);
+		let seed;
+		if (raw) try {
+			const parsed = JSON.parse(raw);
+			seed = {
+				anonymous_id: parsed.anonymous_id ?? uuidv4(),
+				app_user_id: parsed.app_user_id ?? null,
+				session_token: parsed.session_token ?? null,
+				refresh_token: parsed.refresh_token ?? null,
+				expires_at: parsed.expires_at ?? null
+			};
+		} catch {
+			seed = freshSeed();
+		}
+		else seed = freshSeed();
+		if (isExpired(seed.expires_at)) {
+			seed.session_token = null;
+			seed.expires_at = null;
+		}
+		const store = new IdentityStore(persistence, seed);
+		await store.flush();
+		return store;
 	}
+	snapshot() {
+		return {
+			anonymousId: this.anonymousId,
+			appUserId: this.appUserId,
+			sessionToken: this.sessionToken,
+			refreshToken: this.refreshToken,
+			expiresAt: this.expiresAt
+		};
+	}
+	getAnonymousId() {
+		return this.anonymousId;
+	}
+	getAppUserId() {
+		return this.appUserId;
+	}
+	getSessionToken() {
+		return this.sessionToken;
+	}
+	getRefreshToken() {
+		return this.refreshToken;
+	}
+	isAuthenticated() {
+		return this.sessionToken !== null;
+	}
+	async setSession(args) {
+		this.appUserId = args.appUserId;
+		this.sessionToken = args.sessionToken;
+		this.refreshToken = args.refreshToken;
+		this.expiresAt = args.expiresAt;
+		await this.flush();
+	}
+	async clearSession(rotateAnonymousId) {
+		this.appUserId = null;
+		this.sessionToken = null;
+		this.refreshToken = null;
+		this.expiresAt = null;
+		if (rotateAnonymousId) this.anonymousId = uuidv4();
+		await this.flush();
+	}
+	async flush() {
+		const payload = {
+			anonymous_id: this.anonymousId,
+			app_user_id: this.appUserId,
+			session_token: this.sessionToken,
+			refresh_token: this.refreshToken,
+			expires_at: this.expiresAt
+		};
+		await this.persistence.write(IDENTITY_KEY, JSON.stringify(payload));
+	}
+};
+function freshSeed() {
+	return {
+		anonymous_id: uuidv4(),
+		app_user_id: null,
+		session_token: null,
+		refresh_token: null,
+		expires_at: null
+	};
+}
+
+//#endregion
+//#region src/index.ts
+/** SDK semver — burned in at build time. Bump alongside package.json. */
+const SDK_VERSION = "2.0.0";
+let state = null;
+function getState() {
+	if (!state) throw new AmbaApiError("NOT_INITIALIZED", "@layers/amba-react-native: SDK not configured. Call Amba.configure({ apiKey }) at app start.");
+	return state;
 }
 const authSubscribers = /* @__PURE__ */ new Set();
 function snapshotSession(user) {
@@ -138,82 +346,183 @@ function notifyAuthSubscribers(session) {
 async function notifyFromAuthResult(result) {
 	notifyAuthSubscribers(snapshotSession(result.user));
 }
+function expiresAtFromResult(result) {
+	if (result.expires_at && typeof result.expires_at === "string") return result.expires_at;
+	return new Date(Date.now() + 3600 * 1e3).toISOString();
+}
+async function persistAuthResult(state_, result) {
+	await state_.identity.setSession({
+		appUserId: result.user.id,
+		sessionToken: result.session_token,
+		refreshToken: result.refresh_token,
+		expiresAt: expiresAtFromResult(result)
+	});
+}
+async function postAuth(state_, path, body) {
+	const result = (await state_.http.post(path, body)).data;
+	await persistAuthResult(state_, result);
+	await notifyFromAuthResult(result);
+	return result;
+}
+function requireEmail(email) {
+	const trimmed = email.trim();
+	if (trimmed === "") throw new AmbaApiError("VALIDATION_ERROR", "email must not be empty");
+	if (!trimmed.includes("@") || !trimmed.includes(".")) throw new AmbaApiError("VALIDATION_ERROR", `email '${email}' is not a valid email address`);
+}
+function requirePassword(password) {
+	if (password.length < 8) throw new AmbaApiError("VALIDATION_ERROR", "password must be at least 8 characters");
+}
+const P = {
+	authAnonymous: "/v1/client/auth/anonymous",
+	authEmailLogin: "/v1/client/auth/email/login",
+	authEmailSignup: "/v1/client/auth/email/signup",
+	authSocial: "/v1/client/auth/social",
+	authRefresh: "/v1/client/auth/refresh",
+	authLogout: "/v1/client/auth/logout",
+	authMe: "/v1/client/auth/me",
+	events: "/v1/client/events",
+	collections: "/v1/client/collections",
+	storage: "/v1/client/media",
+	storagePresign: "/v1/client/media/presign",
+	storageCommit: "/v1/client/media/commit",
+	push: "/v1/client/push",
+	pushRegister: "/v1/client/push/register",
+	pushUnregister: "/v1/client/push/unregister",
+	pushTokens: "/v1/client/push/tokens",
+	pushSubscribe: "/v1/client/push/subscribe",
+	pushUnsubscribe: "/v1/client/push/unsubscribe",
+	entitlements: "/v1/client/entitlements",
+	aiAnthropic: "/v1/client/ai/anthropic/messages",
+	config: "/v1/client/config",
+	flags: "/v1/client/flags",
+	achievements: "/v1/client/achievements",
+	challenges: "/v1/client/challenges",
+	catalog: "/v1/client/catalog",
+	currencies: "/v1/client/currencies",
+	inventory: "/v1/client/inventory",
+	leaderboards: "/v1/client/leaderboards",
+	stores: "/v1/client/stores",
+	xp: "/v1/client/xp",
+	streaks: "/v1/client/streaks",
+	feeds: "/v1/client/feeds",
+	friends: "/v1/client/friends",
+	groups: "/v1/client/groups",
+	messaging: "/v1/client/messaging",
+	moderation: "/v1/client/moderation",
+	reviews: "/v1/client/reviews",
+	roles: "/v1/client/roles",
+	referrals: "/v1/client/referrals",
+	content: "/v1/client/content",
+	deepLinks: "/v1/client/deeplinks",
+	onboarding: "/v1/client/onboarding"
+};
+function encodePathSegment(s) {
+	return encodeURIComponent(s);
+}
 /**
 * Top-level SDK namespace for React Native.
-*
-* Differences from `@layers/amba-web`:
-* - `configure` is async (waits for WASM init AND AsyncStorage hydration).
-* - Persistence is AsyncStorage-backed — identity survives app restarts.
 */
 const Amba = {
 	configure: async (config) => {
 		if (!config.apiKey || config.apiKey.trim() === "") throw new Error("Amba.configure: apiKey is required");
-		const coreWasm = await import("@layers/amba-core");
-		const init = coreWasm.default;
-		const AmbaCoreWasm = coreWasm.AmbaCoreWasm;
-		await init();
-		await new AsyncStoragePersistence(config.storagePrefix ?? "amba").hydrate();
-		coreInstance = AmbaCoreWasm.init(JSON.stringify({
-			api_key: config.apiKey,
-			base_url: config.baseUrl,
-			sdk_platform: "react-native",
-			sdk_wrapper_version: `amba-react-native/${SDK_VERSION}`,
-			consent_required: config.consentRequired,
-			debug: config.debug
-		}), globalThis.fetch.bind(globalThis));
+		const persistence = new AsyncStoragePersistence(config.storagePrefix ?? "amba");
+		await persistence.hydrate();
+		const identity = await IdentityStore.create(persistence);
+		const baseUrl = (config.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+		const sdkVersionHeader = `amba-sdk/${SDK_VERSION} ${`amba-react-native/${SDK_VERSION}`}`;
+		state = {
+			http: new AmbaHttpClient({
+				apiKey: config.apiKey,
+				baseUrl,
+				sdkPlatform: "react-native",
+				sdkVersionHeader,
+				identity
+			}),
+			identity,
+			debug: config.debug ?? false
+		};
+	},
+	_reset: () => {
+		state = null;
+		authSubscribers.clear();
 	},
 	get anonymousId() {
-		return requireCore().anonymousId();
+		return getState().identity.getAnonymousId();
 	},
 	get appUserId() {
-		return requireCore().appUserId() ?? void 0;
+		return getState().identity.getAppUserId() ?? void 0;
 	},
 	get isAuthenticated() {
-		return requireCore().isAuthenticated();
+		return getState().identity.isAuthenticated();
 	},
 	setDebug: (enabled) => {
-		requireCore().setDebug(enabled);
+		getState().debug = enabled;
 	},
 	events: { track: async (event, properties) => {
-		await coreCall((c) => c.track(event, properties ? JSON.stringify(properties) : void 0));
+		const s = getState();
+		await s.http.post(P.events, {
+			name: event,
+			properties: properties ?? void 0,
+			anonymous_id: s.identity.getAnonymousId(),
+			timestamp: (/* @__PURE__ */ new Date()).toISOString()
+		});
 	} },
 	auth: {
 		signInAnonymously: async () => {
-			const r = await coreCall((c) => c.signInAnonymously());
-			await notifyFromAuthResult(r);
-			return r;
+			const s = getState();
+			return postAuth(s, P.authAnonymous, { anonymous_id: s.identity.getAnonymousId() });
 		},
 		signInWithEmail: async (email, password) => {
-			const r = await coreCall((c) => c.signInWithEmail(email, password));
-			await notifyFromAuthResult(r);
-			return r;
+			requireEmail(email);
+			if (password === "") throw new AmbaApiError("VALIDATION_ERROR", "password must not be empty");
+			return postAuth(getState(), P.authEmailLogin, {
+				email,
+				password
+			});
 		},
 		signUpWithEmail: async (email, password) => {
-			const r = await coreCall((c) => c.signUpWithEmail(email, password));
-			await notifyFromAuthResult(r);
-			return r;
+			requireEmail(email);
+			requirePassword(password);
+			return postAuth(getState(), P.authEmailSignup, {
+				email,
+				password
+			});
 		},
 		signInWithSocial: async (provider, idToken) => {
-			const r = await coreCall((c) => c.signInWithSocial(provider, idToken));
-			await notifyFromAuthResult(r);
-			return r;
+			if (idToken.trim() === "") throw new AmbaApiError("VALIDATION_ERROR", "id_token must not be empty");
+			return postAuth(getState(), P.authSocial, {
+				provider,
+				id_token: idToken
+			});
 		},
 		signOut: async (rotateAnonymousId = false) => {
-			await coreCall((c) => c.signOut(rotateAnonymousId));
+			const s = getState();
+			if (s.identity.getSessionToken()) try {
+				await s.http.post(P.authLogout, {});
+			} catch (err) {
+				if (typeof console !== "undefined") console.warn("[amba] signOut server call failed", err);
+			}
+			await s.identity.clearSession(rotateAnonymousId);
 			notifyAuthSubscribers(null);
 		},
 		refresh: async () => {
-			const r = await coreCall((c) => c.refreshSession());
-			await notifyFromAuthResult(r);
-			return r;
+			const s = getState();
+			const refreshToken = s.identity.getRefreshToken();
+			if (!refreshToken) throw new AmbaApiError("UNAUTHORIZED", "no refresh token available — call signIn* first");
+			return postAuth(s, P.authRefresh, { refresh_token: refreshToken });
+		},
+		me: async () => {
+			const s = getState();
+			if (!s.identity.getSessionToken()) throw new AmbaApiError("UNAUTHORIZED", "no active session — call signIn* first");
+			return (await s.http.get(P.authMe)).data;
 		},
-		me: async () => await coreCall((c) => c.me()),
 		getSession: async () => {
-			if (!requireCore().isAuthenticated()) return null;
-			return snapshotSession(await coreCall((c) => c.me()));
+			const s = getState();
+			if (!s.identity.isAuthenticated()) return null;
+			return snapshotSession((await s.http.get(P.authMe)).data);
 		},
 		getAnonymousId: async () => {
-			return requireCore().anonymousId();
+			return getState().identity.getAnonymousId();
 		},
 		onAuthStateChange: (cb) => {
 			authSubscribers.add(cb);
@@ -223,11 +532,21 @@ const Amba = {
 		}
 	},
 	collections: {
-		find: async (name, options = {}) => await coreCall((c) => c.collectionsFind(name, JSON.stringify(options))),
-		findOne: async (name, id) => await coreCall((c) => c.collectionsFindOne(name, id)),
-		insert: async (name, row) => await coreCall((c) => c.collectionsInsert(name, JSON.stringify(row))),
-		update: async (name, id, set) => await coreCall((c) => c.collectionsUpdate(name, id, JSON.stringify(set))),
-		delete: async (name, id) => await coreCall((c) => c.collectionsDelete(name, id)),
+		find: async (name, options = {}) => {
+			return getState().http.post(`${P.collections}/${encodePathSegment(name)}/find`, options);
+		},
+		findOne: async (name, id) => {
+			return (await getState().http.get(`${P.collections}/${encodePathSegment(name)}/${encodePathSegment(id)}`)).data;
+		},
+		insert: async (name, row) => {
+			return (await getState().http.post(`${P.collections}/${encodePathSegment(name)}`, row)).data;
+		},
+		update: async (name, id, set) => {
+			return (await getState().http.patch(`${P.collections}/${encodePathSegment(name)}/${encodePathSegment(id)}`, { set })).data;
+		},
+		delete: async (name, id) => {
+			return await getState().http.delete(`${P.collections}/${encodePathSegment(name)}/${encodePathSegment(id)}`) ?? { data: { deleted: true } };
+		},
 		where: {
 			eq: (column, value) => ({
 				column,
@@ -293,141 +612,335 @@ const Amba = {
 		}
 	},
 	storage: {
-		presign: async (params) => await coreCall((c) => c.storagePresign(params.bucket, params.filename, params.mimeType, params.sizeBytes, params.retentionDays)),
-		commit: async (uploadId, assetId) => await coreCall((c) => c.storageCommit(uploadId, assetId))
+		presign: async (params) => {
+			return (await getState().http.post(P.storagePresign, {
+				bucket: params.bucket,
+				filename: params.filename,
+				mime_type: params.mimeType,
+				size_bytes: params.sizeBytes,
+				retention_days: params.retentionDays
+			})).data;
+		},
+		commit: async (uploadId, assetId) => {
+			return (await getState().http.post(P.storageCommit, {
+				upload_id: uploadId,
+				asset_id: assetId
+			})).data;
+		}
 	},
 	push: {
-		register: async (token, platform, bundleId) => await coreCall((c) => c.pushRegister(token, platform, bundleId)),
+		register: async (token, platform, bundleId) => {
+			return (await getState().http.post(P.pushRegister, {
+				token,
+				platform,
+				bundle_id: bundleId
+			})).data;
+		},
 		unregister: async (token) => {
-			await coreCall((c) => c.pushUnregister(token));
+			await getState().http.post(P.pushUnregister, { token });
+		},
+		getTokens: async () => {
+			return (await getState().http.get(P.pushTokens)).data;
 		},
-		getTokens: async () => await coreCall((c) => c.pushGetTokens()),
 		subscribe: async (topic) => {
-			await coreCall((c) => c.pushSubscribe(topic));
+			await getState().http.post(P.pushSubscribe, { topic });
 		},
 		unsubscribe: async (topic) => {
-			await coreCall((c) => c.pushUnsubscribe(topic));
+			await getState().http.post(P.pushUnsubscribe, { topic });
 		}
 	},
 	entitlements: {
-		list: async () => await coreCall((c) => c.entitlementsList()),
-		has: async (name) => await coreCall((c) => c.entitlementsHas(name))
+		list: async () => {
+			return (await getState().http.get(P.entitlements)).data;
+		},
+		has: async (name) => {
+			return (await getState().http.get(P.entitlements, { active_only: "true" })).data.some((e) => e.name === name && e.is_active);
+		}
 	},
-	ai: { anthropic: { messages: { create: async (request) => await coreCall((c) => c.aiAnthropicMessages(JSON.stringify(request))) } } },
-	config: { fetch: async () => await coreCall((c) => c.configFetch()) },
-	flags: { fetch: async () => await coreCall((c) => c.flagsFetch()) },
+	ai: { anthropic: { messages: { create: async (request) => {
+		return (await getState().http.post(P.aiAnthropic, request)).data;
+	} } } },
+	config: { fetch: async () => {
+		const s = getState();
+		const url = s.http.url(P.config);
+		const headers = s.http.buildHeaders();
+		let response;
+		try {
+			response = await (globalThis.fetch ?? fetch)(url, {
+				method: "GET",
+				headers
+			});
+		} catch (err) {
+			throw new AmbaApiError("NETWORK_ERROR", `Network error: ${err instanceof Error ? err.message : String(err)}`, err);
+		}
+		const text = await response.text();
+		if (!response.ok) {
+			const ct = response.headers.get("content-type") ?? "";
+			throw mapHttpError(response, text, ct.includes("application/json"));
+		}
+		let parsed = {};
+		if (text) try {
+			parsed = JSON.parse(text);
+		} catch {
+			parsed = {};
+		}
+		const etag = response.headers.get("etag");
+		let version = null;
+		if (etag) {
+			const cleaned = etag.replace(/^"|"$/g, "");
+			const m = cleaned.match(/^(v\d+)/);
+			version = m ? m[1] ?? null : cleaned || null;
+		}
+		return {
+			version,
+			values: parsed.data ?? {}
+		};
+	} },
+	flags: { fetch: async () => {
+		return (await getState().http.get(P.flags)).data;
+	} },
 	achievements: {
-		getAll: async () => await coreCall((c) => c.achievementsGetAll()),
-		getProgress: async () => await coreCall((c) => c.achievementsGetProgress())
+		getAll: async () => {
+			return (await getState().http.get(P.achievements)).data;
+		},
+		getProgress: async () => {
+			return (await getState().http.get(`${P.achievements}/progress`)).data;
+		}
 	},
 	challenges: {
-		getActive: async () => await coreCall((c) => c.challengesGetActive()),
-		get: async (id) => await coreCall((c) => c.challengesGet(id)),
-		getProgress: async (id) => await coreCall((c) => c.challengesGetProgress(id)),
-		claim: async (id) => await coreCall((c) => c.challengesClaim(id))
+		getActive: async () => {
+			return (await getState().http.get(`${P.challenges}/active`)).data;
+		},
+		get: async (id) => {
+			return (await getState().http.get(`${P.challenges}/${encodePathSegment(id)}`)).data;
+		},
+		getProgress: async (id) => {
+			return (await getState().http.get(`${P.challenges}/${encodePathSegment(id)}/progress`)).data;
+		},
+		claim: async (id) => {
+			return (await getState().http.post(`${P.challenges}/${encodePathSegment(id)}/claim`, {})).data;
+		}
 	},
 	currencies: {
-		getBalance: async () => await coreCall((c) => c.currenciesGetBalance()),
-		getTransactions: async (currencyKey) => await coreCall((c) => c.currenciesGetTransactions(currencyKey))
+		getBalance: async () => {
+			return (await getState().http.get(P.currencies)).data;
+		},
+		getTransactions: async (currencyKey) => {
+			return (await getState().http.get(`${P.currencies}/${encodePathSegment(currencyKey)}/transactions`)).data;
+		}
 	},
 	inventory: {
-		getItems: async () => await coreCall((c) => c.inventoryGetItems()),
-		getItem: async (id) => await coreCall((c) => c.inventoryGetItem(id)),
-		purchase: async (request) => await coreCall((c) => c.inventoryPurchase(JSON.stringify(request))),
-		consume: async (request) => await coreCall((c) => c.inventoryConsume(JSON.stringify(request)))
+		getItems: async () => {
+			return (await getState().http.get(P.inventory)).data;
+		},
+		getItem: async (id) => {
+			return (await getState().http.get(`${P.inventory}/${encodePathSegment(id)}`)).data;
+		},
+		purchase: async (request) => {
+			return (await getState().http.post(`${P.inventory}/purchase`, request)).data;
+		},
+		consume: async (request) => {
+			return (await getState().http.post(`${P.inventory}/consume`, request)).data;
+		}
 	},
 	leaderboards: {
-		get: async (key) => await coreCall((c) => c.leaderboardsGet(key)),
-		getEntries: async (key, limit) => await coreCall((c) => c.leaderboardsGetEntries(key, limit ?? void 0)),
-		getMyRank: async (key) => await coreCall((c) => c.leaderboardsGetMyRank(key))
+		get: async (key) => {
+			return (await getState().http.get(`${P.leaderboards}/${encodePathSegment(key)}`)).data;
+		},
+		getEntries: async (key, limit) => {
+			return (await getState().http.get(`${P.leaderboards}/${encodePathSegment(key)}/entries`, limit !== void 0 ? { limit } : void 0)).data;
+		},
+		getMyRank: async (key) => {
+			return (await getState().http.get(`${P.leaderboards}/${encodePathSegment(key)}/me`)).data;
+		}
 	},
 	stores: {
-		list: async () => await coreCall((c) => c.storesList()),
-		getPurchaseOptions: async (storeKey) => await coreCall((c) => c.storesGetPurchaseOptions(storeKey)),
-		purchase: async (storeKey, purchaseOptionId, receipt) => await coreCall((c) => c.storesPurchase(storeKey, purchaseOptionId, JSON.stringify(receipt)))
+		list: async () => {
+			return (await getState().http.get(P.stores)).data;
+		},
+		getPurchaseOptions: async (storeKey) => {
+			return (await getState().http.get(`${P.stores}/${encodePathSegment(storeKey)}/options`)).data;
+		},
+		purchase: async (storeKey, purchaseOptionId, receipt) => {
+			return (await getState().http.post(`${P.stores}/${encodePathSegment(storeKey)}/purchase`, {
+				purchase_option_id: purchaseOptionId,
+				receipt
+			})).data;
+		}
 	},
 	xp: {
-		getBalance: async () => await coreCall((c) => c.xpGetBalance()),
-		getHistory: async (limit) => await coreCall((c) => c.xpGetHistory(limit ?? void 0)),
-		claim: async (grantKey) => await coreCall((c) => c.xpClaim(grantKey))
+		getBalance: async () => {
+			return (await getState().http.get(P.xp)).data;
+		},
+		getHistory: async (limit) => {
+			return (await getState().http.get(`${P.xp}/history`, limit !== void 0 ? { limit } : void 0)).data;
+		},
+		claim: async (grantKey) => {
+			return (await getState().http.post(`${P.xp}/claim`, { grant_key: grantKey })).data;
+		}
 	},
 	streaks: {
-		getAll: async () => await coreCall((c) => c.streaksGetAll()),
-		qualify: async (streakKey) => await coreCall((c) => c.streaksQualify(streakKey))
+		getAll: async () => {
+			return (await getState().http.get(P.streaks)).data;
+		},
+		qualify: async (streakKey) => {
+			return (await getState().http.post(`${P.streaks}/${encodePathSegment(streakKey)}/qualify`, {})).data;
+		}
 	},
-	feeds: { getActivity: async (feed, cursor) => await coreCall((c) => c.feedsGetActivity(feed ?? void 0, cursor ?? void 0)) },
+	feeds: { getActivity: async (feed, cursor) => {
+		const f = feed ?? "default";
+		return getState().http.get(`${P.feeds}/${encodePathSegment(f)}`, cursor ? { cursor } : void 0);
+	} },
 	friends: {
-		getList: async () => await coreCall((c) => c.friendsGetList()),
-		getFriends: async () => await coreCall((c) => c.friendsGetFriends()),
-		blockUser: async (userId) => await coreCall((c) => c.friendsBlockUser(userId)),
+		getList: async () => {
+			return (await getState().http.get(P.friends)).data;
+		},
+		getFriends: async () => {
+			return (await getState().http.get(P.friends, { state: "accepted" })).data;
+		},
+		blockUser: async (userId) => {
+			return (await getState().http.post(`${P.friends}/block`, { user_id: userId })).data;
+		},
 		unblockUser: async (userId) => {
-			await coreCall((c) => c.friendsUnblockUser(userId));
+			await getState().http.post(`${P.friends}/unblock`, { user_id: userId });
 		},
 		removeBlock: async (friendshipId) => {
-			await coreCall((c) => c.friendsRemoveBlock(friendshipId));
+			await getState().http.delete(`${P.friends}/${encodePathSegment(friendshipId)}`);
 		}
 	},
 	groups: {
-		create: async (params) => await coreCall((c) => c.groupsCreate(JSON.stringify(params))),
-		get: async (id) => await coreCall((c) => c.groupsGet(id)),
-		update: async (id, patch) => await coreCall((c) => c.groupsUpdate(id, JSON.stringify(patch))),
+		create: async (params) => {
+			return (await getState().http.post(P.groups, params)).data;
+		},
+		get: async (id) => {
+			return (await getState().http.get(`${P.groups}/${encodePathSegment(id)}`)).data;
+		},
+		update: async (id, patch) => {
+			return (await getState().http.patch(`${P.groups}/${encodePathSegment(id)}`, patch)).data;
+		},
 		delete: async (id) => {
-			await coreCall((c) => c.groupsDelete(id));
+			await getState().http.delete(`${P.groups}/${encodePathSegment(id)}`);
+		},
+		getMembers: async (id) => {
+			return (await getState().http.get(`${P.groups}/${encodePathSegment(id)}/members`)).data;
+		},
+		join: async (id) => {
+			return (await getState().http.post(`${P.groups}/${encodePathSegment(id)}/join`, {})).data;
 		},
-		getMembers: async (id) => await coreCall((c) => c.groupsGetMembers(id)),
-		join: async (id) => await coreCall((c) => c.groupsJoin(id)),
 		leave: async (id) => {
-			await coreCall((c) => c.groupsLeave(id));
+			await getState().http.post(`${P.groups}/${encodePathSegment(id)}/leave`, {});
 		},
-		invite: async (id, userId) => await coreCall((c) => c.groupsInvite(id, userId))
+		invite: async (id, userId) => {
+			return (await getState().http.post(`${P.groups}/${encodePathSegment(id)}/invite`, { user_id: userId })).data;
+		}
 	},
 	messaging: {
-		getConversations: async () => await coreCall((c) => c.messagingGetConversations()),
-		getMessage: async (id) => await coreCall((c) => c.messagingGetMessage(id)),
-		sendMessage: async (request) => await coreCall((c) => c.messagingSendMessage(JSON.stringify(request)))
+		getConversations: async () => {
+			return (await getState().http.get(`${P.messaging}/conversations`)).data;
+		},
+		getMessage: async (id) => {
+			return (await getState().http.get(`${P.messaging}/messages/${encodePathSegment(id)}`)).data;
+		},
+		sendMessage: async (request) => {
+			return (await getState().http.post(`${P.messaging}/messages`, request)).data;
+		}
 	},
 	moderation: {
-		reportUser: async (request) => await coreCall((c) => c.moderationReportUser(JSON.stringify(request))),
-		reportContent: async (request) => await coreCall((c) => c.moderationReportContent(JSON.stringify(request))),
-		getReportStatus: async (id) => await coreCall((c) => c.moderationGetReportStatus(id))
+		reportUser: async (request) => {
+			return (await getState().http.post(`${P.moderation}/reports/users`, request)).data;
+		},
+		reportContent: async (request) => {
+			return (await getState().http.post(`${P.moderation}/reports/content`, request)).data;
+		},
+		getReportStatus: async (id) => {
+			return (await getState().http.get(`${P.moderation}/reports/${encodePathSegment(id)}`)).data;
+		}
 	},
 	reviews: {
-		list: async (targetType, targetId) => await coreCall((c) => c.reviewsList(targetType, targetId)),
-		create: async (params) => await coreCall((c) => c.reviewsCreate(JSON.stringify(params))),
-		update: async (id, patch) => await coreCall((c) => c.reviewsUpdate(id, JSON.stringify(patch))),
+		list: async (targetType, targetId) => {
+			return (await getState().http.get(P.reviews, {
+				target_type: targetType,
+				target_id: targetId
+			})).data;
+		},
+		create: async (params) => {
+			return (await getState().http.post(P.reviews, params)).data;
+		},
+		update: async (id, patch) => {
+			return (await getState().http.patch(`${P.reviews}/${encodePathSegment(id)}`, patch)).data;
+		},
 		delete: async (id) => {
-			await coreCall((c) => c.reviewsDelete(id));
+			await getState().http.delete(`${P.reviews}/${encodePathSegment(id)}`);
 		}
 	},
 	roles: {
-		getMyRoles: async () => await coreCall((c) => c.rolesGetMyRoles()),
-		hasPermission: async (permission) => await coreCall((c) => c.rolesHasPermission(permission))
+		getMyRoles: async () => {
+			return (await getState().http.get(`${P.roles}/me`)).data;
+		},
+		hasPermission: async (permission) => {
+			return (await getState().http.get(`${P.roles}/check`, { permission })).data.allowed === true;
+		}
 	},
 	referrals: {
-		getReferralCode: async () => await coreCall((c) => c.referralsGetReferralCode()),
-		claimReferral: async (code) => await coreCall((c) => c.referralsClaimReferral(code)),
-		create: async (code, maxUses) => await coreCall((c) => c.referralsCreate(code ?? void 0, maxUses ?? void 0))
+		getReferralCode: async () => {
+			return (await getState().http.get(`${P.referrals}/me`)).data;
+		},
+		claimReferral: async (code) => {
+			return (await getState().http.post(`${P.referrals}/claim`, { code })).data;
+		},
+		create: async (code, maxUses) => {
+			const body = {};
+			if (code !== void 0) body.code = code;
+			if (maxUses !== void 0) body.max_uses = maxUses;
+			return (await getState().http.post(P.referrals, body)).data;
+		}
 	},
-	catalog: { list: async () => await coreCall((c) => c.catalogList()) },
+	catalog: { list: async () => {
+		return (await getState().http.get(P.catalog)).data;
+	} },
 	content: {
-		getToday: async (channel = "default") => await coreCall((c) => c.contentGetToday(channel)),
-		getLibrary: async (channel = "default", options) => await coreCall((c) => c.contentGetLibrary(channel, options?.limit ?? void 0, options?.cursor ?? void 0)),
-		getItem: async (id) => await coreCall((c) => c.contentGetItem(id)),
-		updateItem: async (id, state) => await coreCall((c) => c.contentUpdateItem(id, JSON.stringify(state))),
-		createItem: async (channel, item) => await coreCall((c) => c.contentCreateItem(channel, JSON.stringify(item)))
+		getToday: async (channel = "default") => {
+			return (await getState().http.get(`${P.content}/today/${encodePathSegment(channel)}`)).data ?? null;
+		},
+		getLibrary: async (channel = "default", options) => {
+			return (await getState().http.get(`${P.content}/library/${encodePathSegment(channel)}`, {
+				limit: options?.limit,
+				cursor: options?.cursor
+			})).data;
+		},
+		getItem: async (id) => {
+			return (await getState().http.get(`${P.content}/${encodePathSegment(id)}`)).data;
+		},
+		updateItem: async (id, state_) => {
+			return (await getState().http.post(`${P.content}/${encodePathSegment(id)}/state`, state_)).data;
+		},
+		createItem: async (channel, item) => {
+			return (await getState().http.post(`${P.content}/${encodePathSegment(channel)}`, item)).data;
+		}
 	},
 	deepLinks: {
-		get: async (shortCode) => await coreCall((c) => c.deepLinksGet(shortCode)),
-		create: async (params) => await coreCall((c) => c.deepLinksCreate(JSON.stringify(params)))
+		get: async (shortCode) => {
+			return (await getState().http.get(`${P.deepLinks}/${encodePathSegment(shortCode)}`)).data;
+		},
+		create: async (params) => {
+			return (await getState().http.post(P.deepLinks, params)).data;
+		}
 	},
 	onboarding: {
-		getStatus: async () => await coreCall((c) => c.onboardingGetStatus()),
-		nextStep: async (payload) => await coreCall((c) => c.onboardingNextStep(JSON.stringify(payload))),
-		skipStep: async () => await coreCall((c) => c.onboardingSkipStep()),
-		complete: async () => await coreCall((c) => c.onboardingComplete())
+		getStatus: async () => {
+			return (await getState().http.get(P.onboarding)).data;
+		},
+		nextStep: async (payload) => {
+			return (await getState().http.post(`${P.onboarding}/next`, payload)).data;
+		},
+		skipStep: async () => {
+			return (await getState().http.post(`${P.onboarding}/skip`, {})).data;
+		},
+		complete: async () => {
+			return (await getState().http.post(`${P.onboarding}/complete`, {})).data;
+		}
 	}
 };
-const SDK_VERSION = "0.1.0";
 
 //#endregion
 exports.Amba = Amba;