@receiz/sdk 96.2.0 → 97.1.0

package/dist/index.js

@@ -1,9 +1,12 @@
 import { buildReceizIdContinueRequest, createReceizIdIdentity, projectReceizIdentityAccount, readReceizIdentityArtifact, signReceizIdentityLoginProof, verifyReceizIdentityLoginProof, } from "./identity.js";
 export * from "./identity.js";
-export const RECEIZ_SDK_VERSION = "96.2.0";
+export const RECEIZ_SDK_VERSION = "97.1.0";
 export const RECEIZ_DEFAULT_BASE_URL = "https://receiz.com";
 export const RECEIZ_WEBHOOK_SIGNATURE_HEADER = "x-receiz-signature";
 export const RECEIZ_WEBHOOK_TIMESTAMP_HEADER = "x-receiz-timestamp";
+export const RECEIZ_APP_STATE_FEED_SCHEMA = "receiz.app.public_state_registry_feed.v1";
+export const RECEIZ_PUBLIC_STORE_STATE_FEED_SCHEMA = "receiz.app.public_store_state_registry_feed.v1";
+export const RECEIZ_PUBLIC_STORE_STATE_PROJECTION_SCHEMA = "receiz.app.public_store_state_projection.v1";
 export const RECEIZ_ASSET_MANIFEST_SCHEMA = {
     $schema: "https://json-schema.org/draft/2020-12/schema",
     $id: "https://receiz.com/standards/receiz.asset-manifest.schema.v1.json",
@@ -151,6 +154,226 @@ export function appendQuery(path, query) {
     const queryString = params.toString();
     return queryString ? `${path}?${queryString}` : path;
 }
+export function receizAppStateUrlFromHost(hostOrUrl) {
+    const trimmed = hostOrUrl.trim();
+    if (!trimmed)
+        throw new ReceizValidationError("receiz.appState.byHost", ["host is required"]);
+    if (/^https?:\/\//i.test(trimmed))
+        return trimmed;
+    return `https://${trimmed.replace(/^\/+/, "")}`;
+}
+export function receizAppStateNamespaceFromUrl(sourceUrl) {
+    const normalized = receizAppStateUrlFromHost(sourceUrl);
+    try {
+        return new URL(normalized).hostname.toLowerCase();
+    }
+    catch {
+        const host = normalized.replace(/^https?:\/\//i, "").split(/[/?#]/)[0] ?? normalized;
+        return host.toLowerCase();
+    }
+}
+export function receizAppStateObjectIdFromUrl(sourceUrl, prefix = "app_state") {
+    const normalized = receizAppStateUrlFromHost(sourceUrl);
+    let host = receizAppStateNamespaceFromUrl(normalized);
+    let pathPart = "";
+    try {
+        const parsed = new URL(normalized);
+        host = parsed.hostname.toLowerCase();
+        pathPart = parsed.pathname && parsed.pathname !== "/" ? parsed.pathname : "";
+    }
+    catch {
+        pathPart = "";
+    }
+    const safePath = pathPart
+        .replace(/^\/+|\/+$/g, "")
+        .replace(/[^a-zA-Z0-9_.-]+/g, "_");
+    return safePath ? `${prefix}:${host}:${safePath}` : `${prefix}:${host}`;
+}
+export function createReceizAppStateRecord(input) {
+    const sourceUrl = receizAppStateUrlFromHost(input.sourceUrl);
+    const record = {
+        ...input,
+        id: input.id ?? receizAppStateObjectIdFromUrl(sourceUrl),
+        sourceUrl,
+        namespace: input.namespace ?? receizAppStateNamespaceFromUrl(sourceUrl),
+        state: input.state ?? "published",
+    };
+    return record;
+}
+export function createReceizAppStateFeed(records, options = {}) {
+    const feed = {
+        schema: options.schema ?? RECEIZ_APP_STATE_FEED_SCHEMA,
+        records: records.map((record) => createReceizAppStateRecord(record)),
+    };
+    if (options.namespace)
+        feed.namespace = options.namespace;
+    if (options.externalCreatorId)
+        feed.externalCreatorId = options.externalCreatorId;
+    return feed;
+}
+export function createReceizPublicStoreStateRecord(input) {
+    return createReceizAppStateRecord({
+        ...input,
+        platform: input.platform ?? "Receiz.app Commerce Cloud",
+        schema: input.schema ?? RECEIZ_PUBLIC_STORE_STATE_PROJECTION_SCHEMA,
+    });
+}
+export function createReceizTenantAppStateRecord(input) {
+    const sourceUrl = input.sourceUrl ?? receizAppStateUrlFromHost(input.tenantHost);
+    const data = input.data ?? {
+        ...input.state,
+        ...(input.schemaVersion !== undefined ? { schemaVersion: input.schemaVersion } : {}),
+        tenantHost: normalizeReceizHost(input.tenantHost),
+    };
+    const record = {
+        sourceUrl,
+        state: input.projectionState ?? (input.visibility === "private" ? "private" : "published"),
+        platform: input.platform ?? "Receiz App Runtime",
+        schema: input.schema ?? RECEIZ_PUBLIC_STORE_STATE_PROJECTION_SCHEMA,
+        data,
+    };
+    if (input.id)
+        record.id = input.id;
+    const externalCreatorId = input.externalCreatorId ?? input.creatorReceizId;
+    if (externalCreatorId)
+        record.externalCreatorId = externalCreatorId;
+    if (input.title)
+        record.title = input.title;
+    record.namespace = input.namespace ?? receizAppStateNamespaceFromUrl(sourceUrl);
+    record.record = input.record ?? input.state;
+    return createReceizAppStateRecord(record);
+}
+function isReceizAppStateFeed(value) {
+    return isRecord(value) && Array.isArray(value.records);
+}
+export function normalizeReceizHost(hostOrUrl) {
+    const trimmed = hostOrUrl.trim();
+    if (!trimmed)
+        throw new ReceizValidationError("receiz.domains.normalizeHost", ["host is required"]);
+    try {
+        return new URL(/^https?:\/\//i.test(trimmed) ? trimmed : `https://${trimmed}`).hostname.toLowerCase();
+    }
+    catch {
+        return trimmed.replace(/^https?:\/\//i, "").split(/[/?#]/)[0]?.toLowerCase() ?? trimmed.toLowerCase();
+    }
+}
+function bodyWithIdempotency(body, idempotencyKey) {
+    if (!idempotencyKey || Object.prototype.hasOwnProperty.call(body, "idempotencyKey"))
+        return body;
+    return { ...body, idempotencyKey };
+}
+function headersWithIdempotency(headers, idempotencyKey) {
+    const next = new Headers(headers);
+    if (idempotencyKey)
+        next.set("idempotency-key", idempotencyKey);
+    return next;
+}
+function usdToCents(value) {
+    const trimmed = value.trim();
+    if (!/^\d+(\.\d{1,2})?$/.test(trimmed))
+        throw new ReceizValidationError("receiz.commerce.amountUsd", ["amountUsd must be a positive USD decimal"]);
+    const [whole = "0", fraction = ""] = trimmed.split(".");
+    return BigInt(whole) * 100n + BigInt((fraction + "00").slice(0, 2));
+}
+function centsToUsd(value) {
+    const sign = value < 0n ? "-" : "";
+    const abs = value < 0n ? -value : value;
+    return `${sign}${abs / 100n}.${String(abs % 100n).padStart(2, "0")}`;
+}
+function stringToCents(value) {
+    if (typeof value === "number" && Number.isFinite(value))
+        return BigInt(Math.max(0, Math.trunc(value)));
+    if (typeof value === "bigint")
+        return value < 0n ? 0n : value;
+    if (typeof value === "string" && /^\d+$/.test(value.trim()))
+        return BigInt(value.trim());
+    return 0n;
+}
+function sandboxProducts(count) {
+    return Array.from({ length: Math.max(0, count) }, (_, index) => ({
+        id: `sandbox_product_${index + 1}`,
+        title: `Sandbox Product ${index + 1}`,
+        amountUsd: centsToUsd(BigInt(index + 1) * 1200n),
+        proofObject: {
+            schema: "receiz.sdk.sandbox.proof_object.v1",
+            objectId: `sandbox_product_${index + 1}`,
+        },
+    }));
+}
+export async function verifyReceizWebhookRequest(request, options) {
+    const signature = request.headers.get(RECEIZ_WEBHOOK_SIGNATURE_HEADER) ?? "";
+    const timestamp = request.headers.get(RECEIZ_WEBHOOK_TIMESTAMP_HEADER) ?? "";
+    const body = await request.clone().text();
+    const verifyInput = {
+        secret: options.secret,
+        timestamp,
+        body,
+        signature,
+    };
+    if (options.toleranceSeconds !== undefined)
+        verifyInput.toleranceSeconds = options.toleranceSeconds;
+    if (options.nowMs !== undefined)
+        verifyInput.nowMs = options.nowMs;
+    return verifyReceizWebhookSignature(verifyInput);
+}
+function resolveReceizAppStateProjectionRecord(input) {
+    if (!input || !isRecord(input))
+        return null;
+    const looksLikeResponse = typeof input.ok === "boolean" &&
+        Object.prototype.hasOwnProperty.call(input, "record") &&
+        !Object.prototype.hasOwnProperty.call(input, "sourceUrl") &&
+        !Object.prototype.hasOwnProperty.call(input, "data");
+    if (looksLikeResponse) {
+        const response = input;
+        return response.record && isRecord(response.record) ? response.record : null;
+    }
+    return input;
+}
+function receizAppStateRestoreError(record, options) {
+    if (!record)
+        return "app_state_not_found";
+    if (options.schema && record.schema !== options.schema)
+        return "app_state_schema_mismatch";
+    if (options.state && record.state !== options.state)
+        return "app_state_state_mismatch";
+    if (!isRecord(record.data))
+        return "app_state_data_missing";
+    if (options.requiredDataKey && !Object.prototype.hasOwnProperty.call(record.data, options.requiredDataKey)) {
+        return "app_state_required_data_missing";
+    }
+    return "app_state_data_unavailable";
+}
+export function extractReceizAppStateData(input, options = {}) {
+    const record = resolveReceizAppStateProjectionRecord(input);
+    if (!record)
+        return null;
+    if (options.schema && record.schema !== options.schema)
+        return null;
+    if (options.state && record.state !== options.state)
+        return null;
+    if (!isRecord(record.data))
+        return null;
+    if (options.requiredDataKey && !Object.prototype.hasOwnProperty.call(record.data, options.requiredDataKey))
+        return null;
+    return record.data;
+}
+export function restoreReceizAppStateProjection(input, options = {}) {
+    const record = resolveReceizAppStateProjectionRecord(input);
+    const data = extractReceizAppStateData(input, options);
+    if (!record || !data) {
+        return {
+            ok: false,
+            record,
+            data: null,
+            error: receizAppStateRestoreError(record, options),
+        };
+    }
+    return {
+        ok: true,
+        record,
+        data,
+    };
+}
 function isRecord(value) {
     return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
@@ -318,6 +541,8 @@ export class ReceizClient {
     baseUrl;
     accessToken;
     fetchImpl;
+    doctor = (options = {}) => this.runDoctor(options);
+    capabilities = (options = {}) => this.inspectCapabilities(options);
     verification = {
         verifyArtifact: (file) => this.verifyArtifact(file),
         sealArtifact: (file, options) => this.sealArtifact(file, options),
@@ -331,11 +556,26 @@ export class ReceizClient {
         registryFeed: (feed, options = {}) => this.publishAppState(feed, options),
     };
     appState = {
-        publish: (feed, options = {}) => this.publishAppState(feed, options),
+        publish: (input, options = {}) => this.publishAppStateInput(input, options),
+        publishRecord: (record, options = {}) => this.publishAppStateRecord(record, options),
+        resolve: (input) => this.resolveAppState(input),
         byUrl: (url) => this.readAppStateByUrl(url),
+        byHost: (host) => this.readAppStateByHost(host),
         byCreator: (receizId) => this.readAppStateByCreator(receizId),
         byNamespace: (namespace) => this.readAppStateByNamespace(namespace),
         byId: (id) => this.readAppStateById(id),
+        restoreByUrl: (url, options = {}) => this.restoreAppStateByUrl(url, options),
+        restoreByHost: (host, options = {}) => this.restoreAppStateByHost(host, options),
+        restoreById: (id, options = {}) => this.restoreAppStateById(id, options),
+        createRecord: createReceizAppStateRecord,
+        createTenantRecord: createReceizTenantAppStateRecord,
+        createFeed: createReceizAppStateFeed,
+        createPublicStoreRecord: createReceizPublicStoreStateRecord,
+        urlFromHost: receizAppStateUrlFromHost,
+        namespaceFromUrl: receizAppStateNamespaceFromUrl,
+        objectIdFromUrl: receizAppStateObjectIdFromUrl,
+        extractData: extractReceizAppStateData,
+        restoreProjection: restoreReceizAppStateProjection,
     };
     sports = {
         conformance: () => this.sportsConformance(),
@@ -437,12 +677,51 @@ export class ReceizClient {
         bootstrap: (username) => this.request(`/api/connect/login/bootstrap/${encodePathSegment(username)}`),
         authorizeUrl: (options) => this.authorizeUrl(options),
     };
+    commerce = {
+        oneClickCheckout: (body) => this.oneClickCheckout(body),
+    };
     payments = {
         embeddedCheckout: (body) => this.request("/api/payments/embed/checkout", { method: "POST", body }),
         embeddedNoteClaim: (body) => this.request("/api/payments/embed/note-claim", { method: "POST", body }),
     };
+    media = {
+        upload: (file, options = {}) => this.uploadMedia(file, options),
+        objectUrl: (query) => appendQuery(`${this.baseUrl}/api/storage/object`, query),
+    };
+    domains = {
+        normalizeHost: normalizeReceizHost,
+        tenantUrl: receizAppStateUrlFromHost,
+        namespace: receizAppStateNamespaceFromUrl,
+        objectId: receizAppStateObjectIdFromUrl,
+        resolveTenant: (host, options = {}) => this.restoreAppStateByHost(host, options),
+        reserveSubdomain: (body, options = {}) => this.delegated("/api/connect/domains/subdomains/reserve", {
+            method: "POST",
+            body: bodyWithIdempotency(body, options.idempotencyKey),
+            headers: headersWithIdempotency(undefined, options.idempotencyKey),
+        }),
+        verifyCustomDomain: (body, options = {}) => this.delegated("/api/connect/domains/custom/verify", {
+            method: "POST",
+            body: bodyWithIdempotency(body, options.idempotencyKey),
+            headers: headersWithIdempotency(undefined, options.idempotencyKey),
+        }),
+        status: (query = {}) => this.delegated(appendQuery("/api/connect/domains/status", query)),
+    };
+    events = {
+        subscribe: (body) => this.eventSubscribe(body),
+    };
+    proof = {
+        query: (query) => this.delegated("/api/connect/proof/query", { method: "POST", body: query }),
+    };
+    jobs = {
+        enqueue: (body) => this.delegated("/api/connect/jobs", {
+            method: "POST",
+            body: bodyWithIdempotency(body, body.idempotencyKey),
+            headers: headersWithIdempotency(undefined, body.idempotencyKey),
+        }),
+    };
     webhooks = {
         sign: createReceizWebhookSignature,
+        verify: verifyReceizWebhookRequest,
         verifySignature: verifyReceizWebhookSignature,
         signaturePayload: buildReceizWebhookSignaturePayload,
         assertEvent: assertReceizWebhookEvent,
@@ -462,6 +741,33 @@ export class ReceizClient {
         assetManifest: projectReceizAssetManifest,
         sportsCardManifest: projectReceizSportsCardManifest,
     };
+    sandbox = {
+        seedStore: (options) => {
+            const tenantHost = normalizeReceizHost(options.tenantHost);
+            return {
+                ok: true,
+                schema: "receiz.sdk.sandbox.store.v1",
+                tenantHost,
+                state: {
+                    brand: tenantHost,
+                    products: sandboxProducts(options.products ?? 3),
+                    rewards: [{ id: "sandbox_reward_1", title: "Sandbox reward", type: "credit" }],
+                },
+            };
+        },
+        wallet: (options = {}) => ({
+            ok: true,
+            userId: "sandbox_customer",
+            balanceUsdCents: options.balanceUsdCents ?? "10000",
+            balancePhiMicro: options.balancePhiMicro ?? "100000000",
+        }),
+        checkout: (options) => ({
+            ok: options.outcome !== "failure",
+            checkoutSessionId: "sandbox_checkout",
+            status: options.outcome === "failure" ? "failed" : "succeeded",
+            amountUsd: options.amountUsd,
+        }),
+    };
     proofMemory = {
         createRegister: createReceizProofRegister,
         createMemory: createReceizProofMemory,
@@ -521,15 +827,132 @@ export class ReceizClient {
     async readPublicProofByUrl(url) {
         return this.request(appendQuery("/api/public-proof/by-url", { url }));
     }
+    async inspectCapabilities(options = {}) {
+        const tenantHost = options.tenantHost ? normalizeReceizHost(options.tenantHost) : undefined;
+        const scopes = options.scopes ?? [];
+        const delegatedAvailable = Boolean(this.accessToken);
+        const configured = (available, reason) => ({
+            available,
+            status: available ? "available" : "missing",
+            ...(reason ? { reason } : {}),
+            ...(!available ? { fixUrl: `${this.baseUrl}/developers` } : {}),
+        });
+        return {
+            ok: true,
+            schema: "receiz.sdk.capabilities.v1",
+            baseUrl: this.baseUrl,
+            ...(tenantHost ? { tenantHost } : {}),
+            scopes,
+            capabilities: {
+                identity: configured(true),
+                wallet: configured(delegatedAvailable, "Connect bearer token required for wallet reads."),
+                payments: configured(delegatedAvailable, "Connect bearer token required for checkout/session routes."),
+                proofStore: configured(true),
+                media: configured(delegatedAvailable, "Connect bearer token required for media uploads."),
+                domains: configured(Boolean(tenantHost), "tenantHost is required for tenant domain helpers."),
+                twin: configured(delegatedAvailable, "Connect bearer token required for Twin routes."),
+                commerce: configured(delegatedAvailable && Boolean(tenantHost), "Connect bearer token and tenantHost are required for commerce helpers."),
+                rewards: configured(delegatedAvailable && Boolean(tenantHost), "Connect bearer token and tenantHost are required for reward routes."),
+                events: configured(delegatedAvailable, "Connect bearer token required for event subscriptions."),
+                search: configured(delegatedAvailable, "Connect bearer token required for private proof search."),
+                permissions: configured(delegatedAvailable && Boolean(tenantHost), "Connect bearer token and tenantHost are required for tenant permissions."),
+                jobs: configured(delegatedAvailable, "Connect bearer token required for durable jobs."),
+            },
+        };
+    }
+    async runDoctor(options = {}) {
+        const capabilities = await this.inspectCapabilities(options);
+        const missing = [];
+        const warnings = [];
+        const fixes = [];
+        if (!this.accessToken) {
+            missing.push({
+                code: "missing_access_token",
+                message: "Create the Receiz client with a delegated Connect/OIDC bearer token before using wallet, media, commerce, events, domains, or jobs.",
+                fixUrl: `${this.baseUrl}/developers/connect`,
+            });
+        }
+        if (!options.tenantHost) {
+            warnings.push({
+                code: "missing_tenant_host",
+                message: "Pass tenantHost so app-state, commerce, domain, permission, and customer-session helpers can scope correctly.",
+                fixUrl: `${this.baseUrl}/developers/app-state`,
+            });
+        }
+        if (!options.callbackUrl) {
+            warnings.push({
+                code: "missing_callback_url",
+                message: "Pass callbackUrl to verify your Connect/OIDC redirect configuration before users hit the authorize screen.",
+                fixUrl: `${this.baseUrl}/developers/connect`,
+            });
+        }
+        const scopes = new Set(options.scopes ?? []);
+        for (const requiredScope of ["openid", "profile", "receiz:record"]) {
+            if (!scopes.has(requiredScope)) {
+                warnings.push({
+                    code: "missing_scope",
+                    message: `Recommended scope missing: ${requiredScope}.`,
+                    fixUrl: `${this.baseUrl}/developers/apps`,
+                });
+            }
+        }
+        fixes.push(...missing, ...warnings);
+        return {
+            ok: missing.length === 0,
+            schema: "receiz.sdk.doctor.v1",
+            baseUrl: this.baseUrl,
+            ...(capabilities.tenantHost ? { tenantHost: capabilities.tenantHost } : {}),
+            capabilities: capabilities.capabilities,
+            missing,
+            warnings,
+            fixes,
+        };
+    }
     async publishAppState(feed, options = {}) {
-        const requestOptions = { method: "POST", body: feed };
-        if (options.signature)
-            requestOptions.headers = { "x-public-proof-feed-signature": options.signature };
+        const requestOptions = {
+            method: "POST",
+            body: feed,
+            headers: headersWithIdempotency(undefined, options.idempotencyKey),
+        };
+        if (options.signature) {
+            const headers = headersWithIdempotency(requestOptions.headers, options.idempotencyKey);
+            headers.set("x-public-proof-feed-signature", options.signature);
+            requestOptions.headers = headers;
+        }
         return this.request("/api/public-proof/registry/feed", requestOptions);
     }
+    async publishAppStateInput(input, options = {}) {
+        if (isReceizAppStateFeed(input)) {
+            return this.publishAppState(input, options);
+        }
+        const record = createReceizTenantAppStateRecord(input);
+        const publishOptions = {};
+        if (options.signature)
+            publishOptions.signature = options.signature;
+        const idempotencyKey = options.idempotencyKey ?? input.idempotencyKey;
+        if (idempotencyKey)
+            publishOptions.idempotencyKey = idempotencyKey;
+        const feedOptions = { schema: RECEIZ_PUBLIC_STORE_STATE_FEED_SCHEMA };
+        if (record.namespace)
+            feedOptions.namespace = record.namespace;
+        if (record.externalCreatorId)
+            feedOptions.externalCreatorId = record.externalCreatorId;
+        return this.publishAppState(createReceizAppStateFeed([record], feedOptions), publishOptions);
+    }
+    async publishAppStateRecord(record, options = {}) {
+        const feed = createReceizAppStateFeed([record], {
+            schema: options.feedSchema ?? RECEIZ_APP_STATE_FEED_SCHEMA,
+            ...(options.namespace ? { namespace: options.namespace } : {}),
+            ...(options.externalCreatorId ? { externalCreatorId: options.externalCreatorId } : {}),
+        });
+        return this.publishAppState(feed, options.signature ? { signature: options.signature } : {});
+    }
     async readAppStateByUrl(url) {
         return this.request(appendQuery("/api/public-proof/by-url", { url }));
     }
+    async readAppStateByHost(host) {
+        return this.readAppStateByUrl(receizAppStateUrlFromHost(host));
+    }
     async readAppStateByCreator(receizId) {
         return this.request(`/api/public-proof/creator/${encodePathSegment(receizId)}`);
     }
@@ -539,6 +962,156 @@ export class ReceizClient {
     async readAppStateById(id) {
         return this.request(`/api/public-proof/${encodePathSegment(id)}`);
     }
+    async restoreAppStateByUrl(url, options = {}) {
+        const response = await this.readAppStateByUrl(url);
+        return restoreReceizAppStateProjection(response, options);
+    }
+    async restoreAppStateByHost(host, options = {}) {
+        return this.restoreAppStateByUrl(receizAppStateUrlFromHost(host), options);
+    }
+    async restoreAppStateById(id, options = {}) {
+        try {
+            const response = await this.readAppStateById(id);
+            return restoreReceizAppStateProjection(response, options);
+        }
+        catch (error) {
+            if (error instanceof ReceizHttpError && error.status === 404) {
+                return {
+                    ok: false,
+                    record: null,
+                    data: null,
+                    error: "app_state_not_found",
+                };
+            }
+            throw error;
+        }
+    }
+    async resolveAppState(input) {
+        const options = {
+            ...(input.schema ? { schema: input.schema } : {}),
+            ...(input.state ? { state: input.state } : {}),
+            ...(input.requiredDataKey ? { requiredDataKey: input.requiredDataKey } : {}),
+        };
+        if (input.id)
+            return this.restoreAppStateById(input.id, options);
+        if (input.url)
+            return this.restoreAppStateByUrl(input.url, options);
+        if (input.host || input.tenantHost)
+            return this.restoreAppStateByHost(input.host ?? input.tenantHost ?? "", options);
+        if (input.namespace) {
+            const response = await this.readAppStateByNamespace(input.namespace);
+            const records = response.records;
+            return { ok: response.ok, record: records[0] ?? null, data: null, records };
+        }
+        const creator = input.creatorReceizId ?? input.receizId;
+        if (creator) {
+            const response = await this.readAppStateByCreator(creator);
+            const records = response.records;
+            return { ok: response.ok, record: records[0] ?? null, data: null, records };
+        }
+        throw new ReceizValidationError("receiz.appState.resolve", ["id, url, host, tenantHost, namespace, creatorReceizId, or receizId is required"]);
+    }
+    async oneClickCheckout(body) {
+        const tenantHost = normalizeReceizHost(body.tenantHost);
+        const totalUsdCents = usdToCents(body.amountUsd);
+        const walletFirst = body.walletFirst !== false;
+        const cardFallback = body.cardFallback !== false;
+        const wallet = walletFirst ? await this.delegated("/api/connect/wallet/me") : null;
+        const walletAvailable = walletFirst ? stringToCents(wallet?.balanceUsdCents) : 0n;
+        const walletApplied = walletFirst ? (walletAvailable > totalUsdCents ? totalUsdCents : walletAvailable) : 0n;
+        const cardDelta = totalUsdCents - walletApplied;
+        let checkoutSession = null;
+        if (cardDelta > 0n) {
+            if (!cardFallback) {
+                const response = {
+                    ok: false,
+                    tenantHost,
+                    funding: {
+                        totalUsdCents: String(totalUsdCents),
+                        walletAppliedUsdCents: String(walletApplied),
+                        cardDeltaUsdCents: String(cardDelta),
+                        walletFirst,
+                        cardFallback,
+                    },
+                    wallet,
+                    checkoutSession: null,
+                    proofObject: null,
+                    events: [{ type: "checkout.card_delta_required", cardDeltaUsdCents: String(cardDelta) }],
+                    error: "card_delta_required",
+                };
+                if (body.orderId)
+                    response.orderId = body.orderId;
+                return response;
+            }
+            const checkoutBody = {
+                amountUsd: centsToUsd(cardDelta),
+                currency: body.currency ?? "usd",
+                uiMode: "embedded",
+                description: `Receiz one-click checkout for ${tenantHost}`,
+                tenantHost,
+            };
+            if (body.orderId)
+                checkoutBody.referenceId = body.orderId;
+            if (body.customerEmail)
+                checkoutBody.customerEmail = body.customerEmail;
+            if (body.successUrl)
+                checkoutBody.successUrl = body.successUrl;
+            if (body.cancelUrl)
+                checkoutBody.cancelUrl = body.cancelUrl;
+            if (body.cart)
+                checkoutBody.cart = body.cart;
+            checkoutSession = await this.delegated("/api/connect/payments/checkout", {
+                method: "POST",
+                body: bodyWithIdempotency(checkoutBody, body.idempotencyKey),
+                headers: headersWithIdempotency(undefined, body.idempotencyKey),
+            });
+        }
+        const response = {
+            ok: true,
+            tenantHost,
+            funding: {
+                totalUsdCents: String(totalUsdCents),
+                walletAppliedUsdCents: String(walletApplied),
+                cardDeltaUsdCents: String(cardDelta),
+                walletFirst,
+                cardFallback,
+            },
+            wallet,
+            checkoutSession,
+            proofObject: checkoutSession?.proofBundle ?? null,
+            events: [
+                { type: "wallet.summary.read", walletAppliedUsdCents: String(walletApplied) },
+                ...(checkoutSession ? [{ type: "checkout.session.created", checkoutSessionId: checkoutSession.checkoutSessionId ?? null }] : []),
+            ],
+        };
+        if (body.orderId)
+            response.orderId = body.orderId;
+        return response;
+    }
+    async uploadMedia(file, options = {}) {
+        const form = new FormData();
+        form.set("file", file, options.filename ?? "receiz-media");
+        if (options.tenantHost)
+            form.set("tenantHost", normalizeReceizHost(options.tenantHost));
+        if (options.purpose)
+            form.set("purpose", options.purpose);
+        if (options.metadata)
+            form.set("metadata", JSON.stringify(options.metadata));
+        if (options.idempotencyKey)
+            form.set("idempotencyKey", options.idempotencyKey);
+        return this.delegated("/api/connect/media/upload", {
+            method: "POST",
+            body: form,
+            headers: headersWithIdempotency(undefined, options.idempotencyKey),
+        });
+    }
+    async eventSubscribe(body) {
+        return this.delegated("/api/connect/events/subscribe", {
+            method: "POST",
+            body: bodyWithIdempotency(body, body.idempotencyKey),
+            headers: headersWithIdempotency(undefined, body.idempotencyKey),
+        });
+    }
     async sportsConformance() {
         return this.request("/api/game/sports/conformance");
     }