@ait-kit/sdk 0.2.0

package/dist/iap/grant-coordinator.js

@@ -0,0 +1,69 @@
+/**
+ * Client-side dedupe for server grant callbacks, scoped to one adapter
+ * instance (one "processing scope"):
+ *
+ * - Concurrent grants for the same order share the in-flight Promise, so a
+ *   duplicate callback never re-runs the server request.
+ * - A successfully granted order is reused within the same scope: later
+ *   flows (pending-order recovery, duplicate success events) resolve
+ *   immediately instead of re-granting.
+ * - Failed grants are never cached: the entry is removed when the attempt
+ *   rejects, so the next call retries for real.
+ *
+ * This only reduces duplicate client-side work. Server-side grant
+ * idempotency (verify the order, persist exactly once) is a separate,
+ * mandatory server responsibility.
+ */
+export class IapGrantCoordinator {
+    grant;
+    inFlight = new Map();
+    granted = new Map();
+    constructor(grant) {
+        this.grant = grant;
+    }
+    /**
+     * Runs (or joins) the grant for the target order. Resolves when the
+     * consumer's callback resolves; rejects with the callback's error when it
+     * fails, leaving the order retryable. A duplicate joins only when it
+     * describes the same target: orderId and sku must match, and a caller
+     * that does not know the subscriptionId (pending-order recovery) may join
+     * a cached subscription grant. Explicitly conflicting duplicates reject
+     * instead of silently inheriting another flow's grant.
+     */
+    run(target) {
+        const conflict = (existing) => new Error(`conflicting grant target for order ${target.orderId}: already ${existing.sku !== target.sku ? `sku ${existing.sku}` : `subscriptionId ${existing.subscriptionId}`}, requested ${target.sku}`);
+        // Join rules: sku must match. A caller without a subscriptionId
+        // (pending-order recovery) may join any cached grant for the order; a
+        // caller WITH one must match the cached subscriptionId exactly — a
+        // cached grant without a subscriptionId never satisfies an explicit one.
+        const sameTarget = (existing) => existing.sku === target.sku &&
+            (target.subscriptionId === undefined || existing.subscriptionId === target.subscriptionId);
+        const inFlight = this.inFlight.get(target.orderId);
+        if (inFlight) {
+            return sameTarget(inFlight.target) ? inFlight.promise : Promise.reject(conflict(inFlight.target));
+        }
+        const granted = this.granted.get(target.orderId);
+        if (granted) {
+            return sameTarget(granted) ? Promise.resolve() : Promise.reject(conflict(granted));
+        }
+        const attempt = (async () => {
+            await this.grant(target);
+            // Only successful grants persist: the consumer's contract is to
+            // resolve after the server verified the order and persisted the grant.
+            this.granted.set(target.orderId, target);
+        })();
+        this.inFlight.set(target.orderId, { target, promise: attempt });
+        attempt
+            .catch(() => {
+            // Failures are not cached; a later call retries the callback.
+        })
+            .finally(() => {
+            this.inFlight.delete(target.orderId);
+        });
+        return attempt;
+    }
+    /** True when this scope already granted the order successfully. */
+    isGranted(orderId) {
+        return this.granted.has(orderId);
+    }
+}

package/dist/iap/platform-contract.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Internal platform contract shared by the /rn and /web IAP adapters.
+ * Each entry point declares its own structural copy of the official SDK
+ * surface (they are different npm packages with identical Domains API
+ * shapes); this module is the common, platform-neutral engine boundary and
+ * is never exported from a public subpath.
+ */
+import type { IapOneTimePurchaseParams, IapPendingOrder, IapProduct, IapSubscriptionPurchaseParams } from "../index.js";
+export interface IapSdkError {
+    code?: string;
+    message?: string;
+}
+export type IapGrantTarget = {
+    orderId: string;
+    sku: string;
+    subscriptionId?: string;
+};
+/** Official SDK functions optionally expose an isSupported() pre-check. */
+type WithSupport<F> = F & {
+    isSupported?: () => boolean;
+};
+export interface IapPlatformSdk {
+    getProductItemList: WithSupport<() => Promise<{
+        products: IapProduct[];
+    }>>;
+    createOneTimePurchaseOrder: WithSupport<(params: IapOneTimePurchaseParams) => () => void>;
+    createSubscriptionPurchaseOrder: WithSupport<(params: IapSubscriptionPurchaseParams) => () => void>;
+    getPendingOrders: WithSupport<() => Promise<{
+        orders: IapPendingOrder[];
+    }>>;
+    completeProductGrant: WithSupport<(args: {
+        params: {
+            orderId: string;
+        };
+    }) => Promise<boolean>>;
+}
+/**
+ * Injection surface: installed framework versions may expose only some IAP
+ * functions. The loaders accept any partial surface; the adapter gates each
+ * operation individually at call time.
+ */
+export type PartialIapPlatformSdk = {
+    [K in keyof IapPlatformSdk]?: IapPlatformSdk[K];
+};
+export type IapPlatformLoader = () => Promise<{
+    available: true;
+    module: PartialIapPlatformSdk;
+} | {
+    available: false;
+    reason: string;
+}>;
+export declare function toIapErrorMessage(error: unknown): string;
+export declare function toIapErrorCode(error: unknown): string | undefined;
+export {};
+//# sourceMappingURL=platform-contract.d.ts.map

package/dist/iap/platform-contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"platform-contract.d.ts","sourceRoot":"","sources":["../../src/iap/platform-contract.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EACV,wBAAwB,EACxB,eAAe,EACf,UAAU,EACV,6BAA6B,EAC9B,MAAM,aAAa,CAAC;AAErB,MAAM,WAAW,WAAW;IAC1B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,MAAM,cAAc,GAAG;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,GAAG,EAAE,MAAM,CAAC;IACZ,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB,CAAC;AAEF,2EAA2E;AAC3E,KAAK,WAAW,CAAC,CAAC,IAAI,CAAC,GAAG;IAAE,WAAW,CAAC,EAAE,MAAM,OAAO,CAAA;CAAE,CAAC;AAE1D,MAAM,WAAW,cAAc;IAC7B,kBAAkB,EAAE,WAAW,CAAC,MAAM,OAAO,CAAC;QAAE,QAAQ,EAAE,UAAU,EAAE,CAAA;KAAE,CAAC,CAAC,CAAC;IAC3E,0BAA0B,EAAE,WAAW,CAAC,CAAC,MAAM,EAAE,wBAAwB,KAAK,MAAM,IAAI,CAAC,CAAC;IAC1F,+BAA+B,EAAE,WAAW,CAC1C,CAAC,MAAM,EAAE,6BAA6B,KAAK,MAAM,IAAI,CACtD,CAAC;IACF,gBAAgB,EAAE,WAAW,CAAC,MAAM,OAAO,CAAC;QAAE,MAAM,EAAE,eAAe,EAAE,CAAA;KAAE,CAAC,CAAC,CAAC;IAC5E,oBAAoB,EAAE,WAAW,CAC/B,CAAC,IAAI,EAAE;QAAE,MAAM,EAAE;YAAE,OAAO,EAAE,MAAM,CAAA;SAAE,CAAA;KAAE,KAAK,OAAO,CAAC,OAAO,CAAC,CAC5D,CAAC;CACH;AAED;;;;GAIG;AACH,MAAM,MAAM,qBAAqB,GAAG;KACjC,CAAC,IAAI,MAAM,cAAc,CAAC,CAAC,EAAE,cAAc,CAAC,CAAC,CAAC;CAChD,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG,MAAM,OAAO,CAC3C;IAAE,SAAS,EAAE,IAAI,CAAC;IAAC,MAAM,EAAE,qBAAqB,CAAA;CAAE,GAAG;IAAE,SAAS,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAC1F,CAAC;AAEF,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CASxD;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAMjE"}

package/dist/iap/platform-contract.js

@@ -0,0 +1,26 @@
+/**
+ * Internal platform contract shared by the /rn and /web IAP adapters.
+ * Each entry point declares its own structural copy of the official SDK
+ * surface (they are different npm packages with identical Domains API
+ * shapes); this module is the common, platform-neutral engine boundary and
+ * is never exported from a public subpath.
+ */
+export function toIapErrorMessage(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    if (typeof error === "object" && error !== null) {
+        const coded = error;
+        if (typeof coded.message === "string" && coded.message)
+            return coded.message;
+    }
+    return String(error);
+}
+export function toIapErrorCode(error) {
+    if (typeof error === "object" && error !== null) {
+        const code = error.code;
+        if (typeof code === "string" && code)
+            return code;
+    }
+    return undefined;
+}

package/dist/iap/purchase-flow.d.ts

@@ -0,0 +1,34 @@
+import type { IapPurchaseResult } from "../index.js";
+import { type IapGrantCoordinator } from "./grant-coordinator.js";
+export interface PurchaseFlowOptions {
+    /** The platform's order-creation function (already capability-checked). */
+    startOrder: ((params: import("../index.js").IapOneTimePurchaseParams) => () => void) | ((params: import("../index.js").IapSubscriptionPurchaseParams) => () => void);
+    coordinator: IapGrantCoordinator;
+    sku: string;
+    offerId?: string;
+    subscription: boolean;
+    /** Overall deadline for the purchase flow; 0 disables. */
+    timeoutMs: number;
+}
+/**
+ * Shared purchase flow for the /rn and /web IAP adapters, built on the
+ * common event-flow base:
+ *
+ * - The platform's `processProductGrant` slot wraps the consumer-injected
+ *   server grant callback (through the coordinator's dedupe). The platform
+ *   receives `true` only after the callback resolves.
+ * - Completion requires the success event's orderId to match the order the
+ *   grant confirmed for THIS flow. A grant for a different order ends the
+ *   flow as `failed` with `ORDER_MISMATCH`, and a success event arriving
+ *   before the grant settles is parked until the grant for the same order
+ *   confirms — a success event alone never completes a purchase.
+ * - A failed or throwing grant ends the flow as `grant_failed`; a purchase
+ *   is never reported successful over a failed server grant.
+ * - `USER_CANCELED` maps to `canceled`; other SDK errors to `failed`.
+ * - Timeout yields `unknown` (with the known orderId when available): the
+ *   server grant may already be in progress — resolve it through server
+ *   verification and the pending-order recovery flow. Late events after
+ *   any terminal state are ignored.
+ */
+export declare function runPurchaseFlow(options: PurchaseFlowOptions): Promise<IapPurchaseResult>;
+//# sourceMappingURL=purchase-flow.d.ts.map

package/dist/iap/purchase-flow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"purchase-flow.d.ts","sourceRoot":"","sources":["../../src/iap/purchase-flow.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAEV,iBAAiB,EAGlB,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,KAAK,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAQlE,MAAM,WAAW,mBAAmB;IAClC,2EAA2E;IAC3E,UAAU,EACN,CAAC,CAAC,MAAM,EAAE,OAAO,aAAa,EAAE,wBAAwB,KAAK,MAAM,IAAI,CAAC,GACxE,CAAC,CAAC,MAAM,EAAE,OAAO,aAAa,EAAE,6BAA6B,KAAK,MAAM,IAAI,CAAC,CAAC;IAClF,WAAW,EAAE,mBAAmB,CAAC;IACjC,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,OAAO,CAAC;IACtB,0DAA0D;IAC1D,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAsJxF"}

package/dist/iap/purchase-flow.js

@@ -0,0 +1,167 @@
+import { runEventFlow } from "../event-flow.js";
+import {} from "./grant-coordinator.js";
+import { toIapErrorCode, toIapErrorMessage } from "./platform-contract.js";
+/**
+ * Shared purchase flow for the /rn and /web IAP adapters, built on the
+ * common event-flow base:
+ *
+ * - The platform's `processProductGrant` slot wraps the consumer-injected
+ *   server grant callback (through the coordinator's dedupe). The platform
+ *   receives `true` only after the callback resolves.
+ * - Completion requires the success event's orderId to match the order the
+ *   grant confirmed for THIS flow. A grant for a different order ends the
+ *   flow as `failed` with `ORDER_MISMATCH`, and a success event arriving
+ *   before the grant settles is parked until the grant for the same order
+ *   confirms — a success event alone never completes a purchase.
+ * - A failed or throwing grant ends the flow as `grant_failed`; a purchase
+ *   is never reported successful over a failed server grant.
+ * - `USER_CANCELED` maps to `canceled`; other SDK errors to `failed`.
+ * - Timeout yields `unknown` (with the known orderId when available): the
+ *   server grant may already be in progress — resolve it through server
+ *   verification and the pending-order recovery flow. Late events after
+ *   any terminal state are ignored.
+ */
+export function runPurchaseFlow(options) {
+    const { startOrder, coordinator, sku, offerId, subscription, timeoutMs } = options;
+    // Per-flow state, shared by the register callbacks and the reducer.
+    let observedOrderId;
+    let observedSubscriptionId;
+    let confirmedOrderId;
+    let confirmedSubscriptionId;
+    let stashedSuccess;
+    let grantFailure;
+    const evaluate = () => {
+        if (grantFailure) {
+            return { done: true, result: { status: "grant_failed", ...grantFailure } };
+        }
+        if (stashedSuccess && confirmedOrderId !== undefined) {
+            if (confirmedOrderId !== stashedSuccess.orderId) {
+                return {
+                    done: true,
+                    result: {
+                        status: "failed",
+                        code: "ORDER_MISMATCH",
+                        reason: `grant confirmed order ${confirmedOrderId} but the success event reported ${stashedSuccess.orderId}`
+                    }
+                };
+            }
+            return {
+                done: true,
+                result: {
+                    status: "completed",
+                    orderId: confirmedOrderId,
+                    ...(confirmedSubscriptionId !== undefined
+                        ? { subscriptionId: confirmedSubscriptionId }
+                        : {}),
+                    success: stashedSuccess
+                }
+            };
+        }
+        return { done: false };
+    };
+    return runEventFlow({
+        timeoutMs,
+        onTimeout: () => ({
+            status: "unknown",
+            // Include the order the platform already handed to the grant slot,
+            // even when the grant itself has not settled — consumers need it to
+            // verify and recover the uncertain purchase.
+            orderId: confirmedOrderId ?? observedOrderId ?? stashedSuccess?.orderId,
+            ...(observedSubscriptionId !== undefined || confirmedSubscriptionId !== undefined
+                ? { subscriptionId: confirmedSubscriptionId ?? observedSubscriptionId }
+                : {}),
+            reason: "purchase flow timed out; the server grant may still be in progress — verify the order server-side and recover it via pending orders"
+        }),
+        register: (emit) => {
+            const processProductGrant = async (params) => {
+                observedOrderId = params.orderId;
+                observedSubscriptionId = params.subscriptionId;
+                try {
+                    await coordinator.run({
+                        orderId: params.orderId,
+                        sku,
+                        ...(params.subscriptionId !== undefined
+                            ? { subscriptionId: params.subscriptionId }
+                            : {})
+                    });
+                    confirmedOrderId = params.orderId;
+                    confirmedSubscriptionId = params.subscriptionId;
+                    emit({ kind: "grantSettled", orderId: params.orderId, ok: true });
+                    return true;
+                }
+                catch (error) {
+                    grantFailure = {
+                        orderId: params.orderId,
+                        reason: `server grant callback failed: ${toIapErrorMessage(error)}`
+                    };
+                    emit({ kind: "grantSettled", orderId: params.orderId, ok: false });
+                    return false;
+                }
+            };
+            const params = {
+                options: {
+                    sku,
+                    ...(offerId !== undefined && offerId !== null ? { offerId } : {}),
+                    processProductGrant
+                },
+                onEvent: (event) => {
+                    if (event.type === "success") {
+                        emit({ kind: "sdkSuccess", data: event.data });
+                    }
+                },
+                onError: (error) => {
+                    emit({ kind: "sdkError", error });
+                }
+            };
+            return startOrder(params);
+        },
+        reduce: (event) => {
+            switch (event.kind) {
+                case "sdkSuccess":
+                    stashedSuccess = event.data;
+                    return evaluate();
+                case "grantSettled":
+                    return evaluate();
+                case "sdkError": {
+                    if (grantFailure) {
+                        // The server grant failed first; that outcome wins over the
+                        // platform's error report.
+                        return evaluate();
+                    }
+                    const code = toIapErrorCode(event.error);
+                    if (confirmedOrderId !== undefined ||
+                        observedOrderId !== undefined ||
+                        stashedSuccess !== undefined) {
+                        // The order is already identified (grant ran, is running, or the
+                        // success event named it) — an SDK error here is not a
+                        // definitive failure. Report unknown so the caller verifies
+                        // server-side instead of retrying into a second paid order.
+                        return {
+                            done: true,
+                            result: {
+                                status: "unknown",
+                                orderId: confirmedOrderId ?? observedOrderId ?? stashedSuccess?.orderId,
+                                ...(confirmedSubscriptionId !== undefined ||
+                                    observedSubscriptionId !== undefined
+                                    ? { subscriptionId: confirmedSubscriptionId ?? observedSubscriptionId }
+                                    : {}),
+                                reason: `SDK error after the order was identified (${code ?? toIapErrorMessage(event.error)}); the order may already be granted — verify server-side and recover it via pending orders`
+                            }
+                        };
+                    }
+                    if (code === "USER_CANCELED") {
+                        return { done: true, result: { status: "canceled" } };
+                    }
+                    return {
+                        done: true,
+                        result: {
+                            status: "failed",
+                            ...(code !== undefined ? { code } : {}),
+                            reason: toIapErrorMessage(event.error)
+                        }
+                    };
+                }
+            }
+        }
+    });
+}

package/dist/identity/platform-contract.d.ts

@@ -0,0 +1,44 @@
+import { type SdkAnonymousKey, type SdkLoginResult } from "../index.js";
+/**
+ * Internal platform contract for the login/anonymous-identity adapters,
+ * shared by /rn and /web. Each entry declares its own structural copy of
+ * the official SDK surface; this module is the common engine boundary and
+ * is never exported from a public subpath.
+ */
+export interface TossAuthLike {
+    login: FunctionWithSupport<() => Promise<unknown>> | undefined;
+}
+export interface UserLike {
+    getAnonymousKey: FunctionWithSupport<() => Promise<unknown>> | undefined;
+}
+type FunctionWithSupport<F> = F & {
+    isSupported?: () => boolean;
+};
+export interface IdentityPlatformSdk {
+    TossAuth?: TossAuthLike;
+    User?: UserLike;
+}
+export type IdentityPlatformLoader = () => Promise<{
+    available: true;
+    module: IdentityPlatformSdk;
+} | {
+    available: false;
+    reason: string;
+}>;
+/**
+ * Runs the platform login call and validates the result: the
+ * authorizationCode must be a non-empty string and the referrer one of the
+ * documented values, both preserved verbatim. SDK rejections propagate to
+ * the caller unchanged; unsupported environments reject with
+ * SdkError("UNSUPPORTED") when the platform exposes isSupported.
+ */
+export declare function runSdkLogin(platform: IdentityPlatformSdk): Promise<SdkLoginResult>;
+/**
+ * Runs the anonymous key lookup and validates the documented result shape
+ * ({ type: "HASH", hash }): sentinel values, missing or malformed results
+ * reject with SdkError("INVALID_ANONYMOUS_KEY") — the adapter never
+ * fabricates a key. SDK rejections propagate unchanged.
+ */
+export declare function runSdkGetAnonymousKey(platform: IdentityPlatformSdk): Promise<SdkAnonymousKey>;
+export {};
+//# sourceMappingURL=platform-contract.d.ts.map

package/dist/identity/platform-contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"platform-contract.d.ts","sourceRoot":"","sources":["../../src/identity/platform-contract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,KAAK,eAAe,EAAE,KAAK,cAAc,EAAE,MAAM,aAAa,CAAC;AAElF;;;;;GAKG;AAEH,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,mBAAmB,CAAC,MAAM,OAAO,CAAC,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC;CAChE;AAED,MAAM,WAAW,QAAQ;IACvB,eAAe,EAAE,mBAAmB,CAAC,MAAM,OAAO,CAAC,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC;CAC1E;AAED,KAAK,mBAAmB,CAAC,CAAC,IAAI,CAAC,GAAG;IAAE,WAAW,CAAC,EAAE,MAAM,OAAO,CAAA;CAAE,CAAC;AAGlE,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,EAAE,YAAY,CAAC;IACxB,IAAI,CAAC,EAAE,QAAQ,CAAC;CACjB;AAED,MAAM,MAAM,sBAAsB,GAAG,MAAM,OAAO,CAChD;IAAE,SAAS,EAAE,IAAI,CAAC;IAAC,MAAM,EAAE,mBAAmB,CAAA;CAAE,GAAG;IAAE,SAAS,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CACxF,CAAC;AAIF;;;;;;GAMG;AACH,wBAAsB,WAAW,CAC/B,QAAQ,EAAE,mBAAmB,GAC5B,OAAO,CAAC,cAAc,CAAC,CA+BzB;AAED;;;;;GAKG;AACH,wBAAsB,qBAAqB,CACzC,QAAQ,EAAE,mBAAmB,GAC5B,OAAO,CAAC,eAAe,CAAC,CA2B1B"}

package/dist/identity/platform-contract.js

@@ -0,0 +1,71 @@
+import { SdkError } from "../index.js";
+const REFERRERS = new Set(["DEFAULT", "SANDBOX"]);
+/**
+ * Runs the platform login call and validates the result: the
+ * authorizationCode must be a non-empty string and the referrer one of the
+ * documented values, both preserved verbatim. SDK rejections propagate to
+ * the caller unchanged; unsupported environments reject with
+ * SdkError("UNSUPPORTED") when the platform exposes isSupported.
+ */
+export async function runSdkLogin(platform) {
+    const login = platform.TossAuth?.login;
+    if (typeof login !== "function") {
+        throw new SdkError("UNSUPPORTED", "the installed SDK does not expose TossAuth.login");
+    }
+    if (typeof login.isSupported === "function" && !login.isSupported()) {
+        throw new SdkError("UNSUPPORTED", "login is not supported on this app version");
+    }
+    // Receiver-preserving member call for class-instance modules.
+    const result = await platform.TossAuth.login();
+    const authorizationCode = typeof result === "object" && result !== null
+        ? result.authorizationCode
+        : undefined;
+    const referrer = typeof result === "object" && result !== null
+        ? result.referrer
+        : undefined;
+    if (typeof authorizationCode !== "string" || !authorizationCode.trim()) {
+        throw new SdkError("INVALID_LOGIN_RESULT", "login result did not include a non-blank authorizationCode string");
+    }
+    if (typeof referrer !== "string" || !REFERRERS.has(referrer)) {
+        throw new SdkError("INVALID_LOGIN_RESULT", `login result carried an unrecognized referrer: ${String(referrer)}`);
+    }
+    return { authorizationCode, referrer: referrer };
+}
+/**
+ * Runs the anonymous key lookup and validates the documented result shape
+ * ({ type: "HASH", hash }): sentinel values, missing or malformed results
+ * reject with SdkError("INVALID_ANONYMOUS_KEY") — the adapter never
+ * fabricates a key. SDK rejections propagate unchanged.
+ */
+export async function runSdkGetAnonymousKey(platform) {
+    const getAnonymousKey = platform.User?.getAnonymousKey;
+    if (typeof getAnonymousKey !== "function") {
+        throw new SdkError("UNSUPPORTED", "the installed SDK does not expose User.getAnonymousKey");
+    }
+    if (typeof getAnonymousKey.isSupported === "function" &&
+        !getAnonymousKey.isSupported()) {
+        throw new SdkError("UNSUPPORTED", "anonymous keys are not supported in this environment");
+    }
+    const result = await platform.User.getAnonymousKey();
+    const hash = typeof result === "object" && result !== null
+        ? result.hash
+        : undefined;
+    const type = typeof result === "object" && result !== null
+        ? result.type
+        : undefined;
+    if (type !== "HASH" || typeof hash !== "string" || !hash.trim()) {
+        throw new SdkError("INVALID_ANONYMOUS_KEY", `anonymous key result was not { type: "HASH", hash } with a non-blank hash: received ${describe(result)}`);
+    }
+    return { type: "HASH", hash };
+}
+function describe(value) {
+    if (value === undefined)
+        return "undefined";
+    if (value === null)
+        return "null";
+    if (typeof value === "object") {
+        const type = value.type;
+        return typeof type === "string" ? `{ type: ${type} }` : "an unrecognized object";
+    }
+    return typeof value;
+}