@receiz/sdk 97.0.0 → 97.2.0

package/dist/index.js

@@ -1,6 +1,6 @@
 import { buildReceizIdContinueRequest, createReceizIdIdentity, projectReceizIdentityAccount, readReceizIdentityArtifact, signReceizIdentityLoginProof, verifyReceizIdentityLoginProof, } from "./identity.js";
 export * from "./identity.js";
-export const RECEIZ_SDK_VERSION = "97.0.0";
+export const RECEIZ_SDK_VERSION = "97.2.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";
@@ -200,6 +200,193 @@ export function createReceizAppStateRecord(input) {
     };
     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 queryParams(input) {
+    const params = {};
+    for (const [key, value] of Object.entries(input)) {
+        if (value === null ||
+            value === undefined ||
+            typeof value === "string" ||
+            typeof value === "number" ||
+            typeof value === "boolean") {
+            params[key] = value;
+        }
+    }
+    return params;
+}
+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);
 }
@@ -367,6 +554,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),
@@ -380,13 +569,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(),
@@ -488,12 +690,154 @@ export class ReceizClient {
         bootstrap: (username) => this.request(`/api/connect/login/bootstrap/${encodePathSegment(username)}`),
         authorizeUrl: (options) => this.authorizeUrl(options),
     };
+    customers = {
+        session: (body, options = {}) => this.delegatedWrite("/api/connect/customers/session", body, options),
+        portal: (body) => this.delegatedWrite("/api/connect/customers/portal", body),
+        orders: (query = {}) => this.delegated(appendQuery("/api/connect/customers/orders", queryParams(query))),
+        rewards: (query = {}) => this.delegated(appendQuery("/api/connect/customers/rewards", queryParams(query))),
+        assets: (query = {}) => this.delegated(appendQuery("/api/connect/customers/assets", queryParams(query))),
+    };
+    merchants = {
+        onboard: (body, options = {}) => this.delegatedWrite("/api/connect/merchants/onboard", body, options),
+        profile: (query = {}) => this.delegated(appendQuery("/api/connect/merchants/profile", query)),
+        capabilities: (query = {}) => this.delegated(appendQuery("/api/connect/merchants/capabilities", query)),
+    };
+    commerce = {
+        oneClickCheckout: (body) => this.oneClickCheckout(body),
+        refunds: {
+            create: (body, options = {}) => this.delegatedWrite("/api/connect/commerce/refunds", body, options),
+        },
+        subscriptions: {
+            create: (body, options = {}) => this.delegatedWrite("/api/connect/commerce/subscriptions", body, options),
+            cancel: (subscriptionId, body, options = {}) => this.delegatedWrite(`/api/connect/commerce/subscriptions/${encodePathSegment(subscriptionId)}/cancel`, body, options),
+        },
+        shipping: {
+            quote: (body) => this.delegatedWrite("/api/connect/commerce/shipping/quote", body),
+            update: (body, options = {}) => this.delegatedWrite("/api/connect/commerce/shipping/update", body, options),
+        },
+        tax: {
+            quote: (body) => this.delegatedWrite("/api/connect/commerce/tax/quote", body),
+        },
+        discounts: {
+            create: (body, options = {}) => this.delegatedWrite("/api/connect/commerce/discounts", body, options),
+            redeem: (body, options = {}) => this.delegatedWrite("/api/connect/commerce/discounts/redeem", body, options),
+        },
+        giftCards: {
+            issue: (body, options = {}) => this.delegatedWrite("/api/connect/commerce/gift-cards", body, options),
+            redeem: (body, options = {}) => this.delegatedWrite("/api/connect/commerce/gift-cards/redeem", body, options),
+        },
+        accessPasses: {
+            issue: (body, options = {}) => this.delegatedWrite("/api/connect/commerce/access-passes", body, options),
+            verify: (body) => this.delegatedWrite("/api/connect/commerce/access-passes/verify", body),
+        },
+        inventory: {
+            reserve: (body, options = {}) => this.delegatedWrite("/api/connect/commerce/inventory/reserve", body, options),
+            adjust: (body, options = {}) => this.delegatedWrite("/api/connect/commerce/inventory/adjust", body, options),
+        },
+        fulfillment: {
+            update: (body, options = {}) => this.delegatedWrite("/api/connect/commerce/fulfillment", body, options),
+        },
+        payouts: {
+            create: (body, options = {}) => this.delegatedWrite("/api/connect/commerce/payouts", body, options),
+            status: (query = {}) => this.delegated(appendQuery("/api/connect/commerce/payouts/status", query)),
+        },
+    };
     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),
+        transform: (body, options = {}) => this.delegatedWrite("/api/connect/media/transform", body, 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),
+        replay: (body) => this.delegatedWrite("/api/connect/events/replay", body),
+        list: (query = {}) => this.delegated(appendQuery("/api/connect/events", queryParams(query))),
+        ack: (eventId, body = {}) => this.delegatedWrite(`/api/connect/events/${encodePathSegment(eventId)}/ack`, 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),
+        }),
+        status: (jobId) => this.delegated(`/api/connect/jobs/${encodePathSegment(jobId)}`),
+        cancel: (jobId, body = {}) => this.delegatedWrite(`/api/connect/jobs/${encodePathSegment(jobId)}/cancel`, body),
+        list: (query = {}) => this.delegated(appendQuery("/api/connect/jobs", queryParams(query))),
+    };
+    permissions = {
+        grant: (body, options = {}) => this.delegatedWrite("/api/connect/permissions/grants", body, options),
+        revoke: (body, options = {}) => this.delegatedWrite("/api/connect/permissions/revoke", body, options),
+        check: (body) => this.delegatedWrite("/api/connect/permissions/check", body),
+        roles: (query = {}) => this.delegated(appendQuery("/api/connect/permissions/roles", query)),
+    };
+    audit = {
+        append: (body, options = {}) => this.delegatedWrite("/api/connect/audit/events", body, options),
+        query: (query = {}) => this.delegated(appendQuery("/api/connect/audit/events", queryParams(query))),
+        export: (query = {}) => this.delegated(appendQuery("/api/connect/audit/export", queryParams(query))),
+    };
+    risk = {
+        scorePayment: (body) => this.delegatedWrite("/api/connect/risk/payment", body),
+        scoreAccountRecovery: (body) => this.delegatedWrite("/api/connect/risk/account-recovery", body),
+        velocity: (body) => this.delegatedWrite("/api/connect/risk/velocity", body),
+        proofActivity: (body) => this.delegatedWrite("/api/connect/risk/proof-activity", body),
+    };
+    compliance = {
+        exportOrders: (query) => this.delegated(appendQuery("/api/connect/compliance/orders", queryParams(query))),
+        exportTaxes: (query) => this.delegated(appendQuery("/api/connect/compliance/taxes", queryParams(query))),
+        exportPayouts: (query) => this.delegated(appendQuery("/api/connect/compliance/payouts", queryParams(query))),
+        exportCustomers: (query) => this.delegated(appendQuery("/api/connect/compliance/customers", queryParams(query))),
+        exportAudit: (query) => this.delegated(appendQuery("/api/connect/compliance/audit", queryParams(query))),
+    };
+    portability = {
+        exportStore: (query) => this.delegated(appendQuery("/api/connect/portability/store/export", query)),
+        importStore: (body, options = {}) => this.delegatedWrite("/api/connect/portability/store/import", body, options),
+    };
+    search = {
+        query: (body) => this.delegatedWrite("/api/connect/search/query", body),
+        products: (body) => this.delegatedWrite("/api/connect/search/products", body),
+        pages: (body) => this.delegatedWrite("/api/connect/search/pages", body),
+        blog: (body) => this.delegatedWrite("/api/connect/search/blog", body),
+        orders: (body) => this.delegatedWrite("/api/connect/search/orders", body),
+        customers: (body) => this.delegatedWrite("/api/connect/search/customers", body),
+        proofObjects: (body) => this.delegatedWrite("/api/connect/search/proof-objects", body),
+    };
+    notifications = {
+        send: (body, options = {}) => this.delegatedWrite("/api/connect/notifications/send", body, options),
+        subscribe: (body, options = {}) => this.delegatedWrite("/api/connect/notifications/subscribe", body, options),
+        templates: (query = {}) => this.delegated(appendQuery("/api/connect/notifications/templates", query)),
+    };
+    releases = {
+        pin: (body, options = {}) => this.delegatedWrite("/api/connect/releases/pin", body, options),
+        check: (query = {}) => this.delegated(appendQuery("/api/connect/releases/check", query)),
+        supported: () => this.request("/api/releases/rails/supported"),
+    };
     webhooks = {
         sign: createReceizWebhookSignature,
+        verify: verifyReceizWebhookRequest,
         verifySignature: verifyReceizWebhookSignature,
         signaturePayload: buildReceizWebhookSignaturePayload,
         assertEvent: assertReceizWebhookEvent,
@@ -513,6 +857,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,6 +892,12 @@ export class ReceizClient {
         assertSnapshot: assertReceizProofRegisterSnapshot,
         additionsQuery: receizProofMemoryAdditionsQuery,
     };
+    offline = {
+        createQueue: createReceizOfflineProofQueue,
+        createInMemoryStorage: createReceizInMemoryOfflineProofQueueStorage,
+        createLocalStorage: createReceizLocalStorageOfflineProofQueueStorage,
+        assertSnapshot: assertReceizOfflineProofQueueSnapshot,
+    };
     constructor(options = {}) {
         this.baseUrl = trimTrailingSlash(options.baseUrl ?? RECEIZ_DEFAULT_BASE_URL);
         this.accessToken = options.accessToken;
@@ -572,22 +949,131 @@ 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."),
+                audit: configured(delegatedAvailable && Boolean(tenantHost), "Connect bearer token and tenantHost are required for sealed tenant audit events."),
+                risk: configured(delegatedAvailable && Boolean(tenantHost), "Connect bearer token and tenantHost are required for risk signals."),
+                compliance: configured(delegatedAvailable && Boolean(tenantHost), "Connect bearer token and tenantHost are required for compliance exports."),
+                portability: configured(delegatedAvailable && Boolean(tenantHost), "Connect bearer token and tenantHost are required for store portability."),
+                notifications: configured(delegatedAvailable && Boolean(tenantHost), "Connect bearer token and tenantHost are required for notifications."),
+                offline: configured(true),
+                releases: configured(delegatedAvailable && Boolean(tenantHost), "Connect bearer token and tenantHost are required for release rail pinning."),
+            },
+        };
+    }
+    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 appStateRecord = createReceizAppStateRecord(record);
-        const feed = {
+        const feed = createReceizAppStateFeed([record], {
             schema: options.feedSchema ?? RECEIZ_APP_STATE_FEED_SCHEMA,
-            records: [appStateRecord],
-        };
-        if (options.namespace)
-            feed.namespace = options.namespace;
-        if (options.externalCreatorId)
-            feed.externalCreatorId = options.externalCreatorId;
+            ...(options.namespace ? { namespace: options.namespace } : {}),
+            ...(options.externalCreatorId ? { externalCreatorId: options.externalCreatorId } : {}),
+        });
         return this.publishAppState(feed, options.signature ? { signature: options.signature } : {});
     }
     async readAppStateByUrl(url) {
@@ -605,6 +1091,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");
     }
@@ -616,6 +1252,14 @@ export class ReceizClient {
             throw new Error("receiz_access_token_required");
         return this.request(path, { ...options, bearerToken: this.accessToken });
     }
+    async delegatedWrite(path, body = {}, options = {}) {
+        const idempotencyKey = options.idempotencyKey ?? (typeof body.idempotencyKey === "string" ? body.idempotencyKey : undefined);
+        return this.delegated(path, {
+            method: "POST",
+            body: bodyWithIdempotency(body, idempotencyKey),
+            headers: headersWithIdempotency(undefined, idempotencyKey),
+        });
+    }
     async delegatedBlob(path, options = {}) {
         if (!this.accessToken)
             throw new Error("receiz_access_token_required");
@@ -1450,6 +2094,213 @@ export function receizProofMemoryAdditionsQuery(value, limit) {
         ...(limit === undefined ? {} : { limit }),
     };
 }
+function normalizeOfflineQueueItem(value) {
+    const record = ensureRecord(value, "ReceizOfflineProofQueueItem");
+    const issues = [];
+    const id = ensureString(record, "id", issues);
+    const kind = ensureString(record, "kind", issues);
+    if (!isRecord(record.payload))
+        issues.push("payload must be an object");
+    const attempts = record.attempts;
+    if (attempts !== undefined && (typeof attempts !== "number" || !Number.isInteger(attempts) || attempts < 0)) {
+        issues.push("attempts must be a non-negative integer when present");
+    }
+    const item = {
+        id: id ?? "",
+        kind: (kind ?? ""),
+        payload: isRecord(record.payload) ? record.payload : {},
+        createdAt: typeof record.createdAt === "string" && record.createdAt.trim() ? record.createdAt : new Date().toISOString(),
+        attempts: typeof attempts === "number" ? attempts : 0,
+    };
+    if (typeof record.idempotencyKey === "string" && record.idempotencyKey.trim())
+        item.idempotencyKey = record.idempotencyKey;
+    if (record.lastError === null || isRecord(record.lastError))
+        item.lastError = record.lastError;
+    failIfIssues("ReceizOfflineProofQueueItem", issues);
+    return item;
+}
+export function assertReceizOfflineProofQueueSnapshot(value) {
+    const record = ensureRecord(value, "ReceizOfflineProofQueueSnapshot");
+    const issues = [];
+    if (record.schema !== "receiz.sdk.offline_proof_queue.v1")
+        issues.push("schema must be receiz.sdk.offline_proof_queue.v1");
+    const ownerId = record.ownerId;
+    if (ownerId !== null && ownerId !== undefined && typeof ownerId !== "string") {
+        issues.push("ownerId must be a string or null when present");
+    }
+    const createdAt = ensureString(record, "createdAt", issues);
+    const updatedAt = ensureString(record, "updatedAt", issues);
+    if (!Array.isArray(record.pending))
+        issues.push("pending must be an array");
+    if (!Array.isArray(record.settled))
+        issues.push("settled must be an array");
+    if (!Array.isArray(record.failed))
+        issues.push("failed must be an array");
+    failIfIssues("ReceizOfflineProofQueueSnapshot", issues);
+    return {
+        schema: "receiz.sdk.offline_proof_queue.v1",
+        ownerId: typeof ownerId === "string" || ownerId === null ? ownerId : null,
+        createdAt: createdAt ?? "",
+        updatedAt: updatedAt ?? "",
+        pending: Array.isArray(record.pending) ? record.pending.map(normalizeOfflineQueueItem) : [],
+        settled: Array.isArray(record.settled) ? record.settled.map(normalizeOfflineQueueItem) : [],
+        failed: Array.isArray(record.failed) ? record.failed.map(normalizeOfflineQueueItem) : [],
+    };
+}
+function parseOfflineProofQueueStorageValue(value) {
+    if (value === null || value === undefined)
+        return null;
+    if (typeof value === "string") {
+        const trimmed = value.trim();
+        if (!trimmed)
+            return null;
+        return assertReceizOfflineProofQueueSnapshot(JSON.parse(trimmed));
+    }
+    return assertReceizOfflineProofQueueSnapshot(value);
+}
+export class ReceizOfflineProofQueue {
+    ownerId;
+    createdAt;
+    pendingItems;
+    settledItems;
+    failedItems;
+    storage;
+    constructor(options = {}) {
+        const snapshot = options.snapshot ? assertReceizOfflineProofQueueSnapshot(options.snapshot) : null;
+        this.ownerId = options.ownerId ?? snapshot?.ownerId ?? null;
+        this.createdAt = snapshot?.createdAt ?? new Date().toISOString();
+        this.pendingItems = snapshot?.pending ? [...snapshot.pending] : [];
+        this.settledItems = snapshot?.settled ? [...snapshot.settled] : [];
+        this.failedItems = snapshot?.failed ? [...snapshot.failed] : [];
+        this.storage = options.storage ?? null;
+    }
+    enqueue(item) {
+        const normalized = normalizeOfflineQueueItem(item);
+        if (this.pendingItems.some((pending) => pending.id === normalized.id))
+            return this;
+        if (this.settledItems.some((settled) => settled.id === normalized.id))
+            return this;
+        this.pendingItems.push(normalized);
+        return this;
+    }
+    snapshot() {
+        return {
+            schema: "receiz.sdk.offline_proof_queue.v1",
+            ownerId: this.ownerId,
+            createdAt: this.createdAt,
+            updatedAt: new Date().toISOString(),
+            pending: [...this.pendingItems],
+            settled: [...this.settledItems],
+            failed: [...this.failedItems],
+        };
+    }
+    async flush() {
+        const snapshot = this.snapshot();
+        if (this.storage)
+            await this.storage.write(snapshot);
+        return snapshot;
+    }
+    async clear() {
+        this.pendingItems = [];
+        this.settledItems = [];
+        this.failedItems = [];
+        if (this.storage?.remove)
+            await this.storage.remove();
+    }
+    async replay(client) {
+        const originalPending = [...this.pendingItems];
+        let settled = 0;
+        let failed = 0;
+        this.pendingItems = [];
+        for (const item of originalPending) {
+            try {
+                await replayOfflineProofQueueItem(client, item);
+                this.settledItems.push({ ...item, attempts: (item.attempts ?? 0) + 1, lastError: null });
+                settled += 1;
+            }
+            catch (error) {
+                const failedItem = {
+                    ...item,
+                    attempts: (item.attempts ?? 0) + 1,
+                    lastError: errorDetail(error),
+                };
+                this.failedItems.push(failedItem);
+                failed += 1;
+            }
+        }
+        await this.flush();
+        return { ok: failed === 0, settled, failed };
+    }
+    toJSON() {
+        return this.snapshot();
+    }
+}
+async function replayOfflineProofQueueItem(client, item) {
+    if (item.kind === "app_state.publish") {
+        return client.appState.publish(item.payload, item.idempotencyKey ? { idempotencyKey: item.idempotencyKey } : {});
+    }
+    if (item.kind === "connect.record") {
+        return client.request("/api/connect/record", {
+            method: "POST",
+            body: bodyWithIdempotency(item.payload, item.idempotencyKey),
+            headers: headersWithIdempotency(undefined, item.idempotencyKey),
+        });
+    }
+    if (item.kind === "webhook.event") {
+        return client.request("/api/connect/webhooks/replay", {
+            method: "POST",
+            body: bodyWithIdempotency(item.payload, item.idempotencyKey),
+            headers: headersWithIdempotency(undefined, item.idempotencyKey),
+        });
+    }
+    return client.request("/api/connect/offline/replay", {
+        method: "POST",
+        body: bodyWithIdempotency({ kind: item.kind, payload: item.payload }, item.idempotencyKey),
+        headers: headersWithIdempotency(undefined, item.idempotencyKey),
+    });
+}
+export async function createReceizOfflineProofQueue(options = {}) {
+    const storedSnapshot = options.storage ? parseOfflineProofQueueStorageValue(await options.storage.read()) : null;
+    const queueOptions = {
+        ownerId: options.ownerId ?? storedSnapshot?.ownerId ?? null,
+    };
+    if (options.storage)
+        queueOptions.storage = options.storage;
+    const snapshot = options.snapshot ?? storedSnapshot;
+    if (snapshot)
+        queueOptions.snapshot = snapshot;
+    return new ReceizOfflineProofQueue(queueOptions);
+}
+export function createReceizInMemoryOfflineProofQueueStorage(initialValue = null) {
+    let storedText = typeof initialValue === "string"
+        ? initialValue
+        : initialValue
+            ? JSON.stringify(assertReceizOfflineProofQueueSnapshot(initialValue))
+            : null;
+    return {
+        read: () => storedText,
+        write: (snapshot) => {
+            storedText = JSON.stringify(assertReceizOfflineProofQueueSnapshot(snapshot));
+        },
+        remove: () => {
+            storedText = null;
+        },
+        readText: () => storedText,
+    };
+}
+export function createReceizLocalStorageOfflineProofQueueStorage(key = "receiz:offline-proof-queue:v1", storage = globalThis.localStorage) {
+    if (!storage)
+        throw new Error("receiz_local_storage_unavailable");
+    return {
+        read: () => storage.getItem(key),
+        write: (snapshot) => {
+            storage.setItem(key, JSON.stringify(assertReceizOfflineProofQueueSnapshot(snapshot)));
+        },
+        remove: () => {
+            storage.removeItem(key);
+        },
+    };
+}
 function bodyToString(body) {
     if (typeof body === "string")
         return body;